[IMP] queue_job: let _acquire_job obtain any job in ENQUEUED state

Author: sbidoul

queue_job/controllers/main.py

@@ -28,7 +28,9 @@
 
 class RunJobController(http.Controller):
     @classmethod
-    def _acquire_job(cls, env: api.Environment, job_uuid: str) -> Job | None:
+    def _acquire_job(
+        cls, env: api.Environment, job_uuid: str | None = None
+    ) -> Job | None:
         """Acquire a job for execution.
 
         - make sure it is in ENQUEUED state
@@ -38,30 +40,32 @@ def _acquire_job(cls, env: api.Environment, job_uuid: str) -> Job | None:
         If successful, return the Job instance, otherwise return None. This
         function may fail to acquire the job is not in the expected state or is
         already locked by another worker.
+
+        If no job_uuid is given, acquire any available job in ENQUEUED state.
         """
-        env.cr.execute(
-            "SELECT uuid FROM queue_job WHERE uuid=%s AND state=%s "
-            "FOR UPDATE SKIP LOCKED",
-            (job_uuid, ENQUEUED),
-        )
-        if not env.cr.fetchone():
-            _logger.warning(
-                "was requested to run job %s, but it does not exist, "
-                "or is not in state %s, or is being handled by another worker",
-                job_uuid,
-                ENQUEUED,
+        if job_uuid:
+            env.cr.execute(
+                "SELECT uuid FROM queue_job WHERE uuid=%s AND state=%s "
+                "FOR UPDATE SKIP LOCKED",
+                (job_uuid, ENQUEUED),
             )
+        else:
+            env.cr.execute(
+                "SELECT uuid FROM queue_job WHERE state=%s LIMIT 1 "
+                "FOR UPDATE SKIP LOCKED",
+                (ENQUEUED,),
+            )
+        job_row = env.cr.fetchone()
+        if not job_row:
+            _logger.debug("no job to run")
             return None
-        job = Job.load(env, job_uuid)
+        job = Job.load(env, job_uuid=job_row[0])
         assert job and job.state == ENQUEUED
         job.set_started()
         job.store()
         env.cr.commit()
         if not job.lock():
-            _logger.warning(
-                "was requested to run job %s, but it could not be locked",
-                job_uuid,
-            )
+            _logger.debug("could not acquire lock for job %s", job.uuid)
             return None
         return job
 

test_queue_job/tests/test_acquire_job.py

@@ -1,11 +1,11 @@
 # Copyright 2026 ACSONE SA/NV
 # License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
-import logging
 from unittest import mock
 
 from odoo.tests import tagged
 
 from odoo.addons.queue_job.controllers.main import RunJobController
+from odoo.addons.queue_job.job import ENQUEUED, STARTED
 
 from .common import JobCommonCase
 
@@ -27,25 +27,37 @@ def test_acquire_enqueued_job(self):
             mock_commit.assert_called_once()
             self.assertIsNotNone(job)
             self.assertEqual(job.uuid, "test_enqueued_job")
-            self.assertEqual(job.state, "started")
+            self.assertEqual(job.state, STARTED)
             self.assertTrue(
                 self.env["queue.job.lock"].search(
                     [("queue_job_id", "=", job_record.id)]
                 ),
                 "A job lock record should exist at this point",
             )
 
+    def test_acquire_any_enqueued_job(self):
+        available_job_uuids = (
+            self.env["queue.job"].search([("state", "=", ENQUEUED)]).mapped("uuid")
+        )
+        with mock.patch.object(
+            self.env.cr, "commit", mock.Mock(side_effect=self.env.flush_all)
+        ) as mock_commit:
+            job = RunJobController._acquire_job(self.env)
+            mock_commit.assert_called_once()
+            self.assertIsNotNone(job)
+            self.assertIn(job.uuid, available_job_uuids)
+            self.assertEqual(job.state, STARTED)
+            self.assertTrue(
+                self.env["queue.job.lock"].search(
+                    [("queue_job_id", "=", job.db_record().id)]
+                ),
+                "A job lock record should exist at this point",
+            )
+
     def test_acquire_started_job(self):
-        with (
-            mock.patch.object(
-                self.env.cr, "commit", mock.Mock(side_effect=self.env.flush_all)
-            ) as mock_commit,
-            self.assertLogs(level=logging.WARNING) as logs,
-        ):
+        with mock.patch.object(
+            self.env.cr, "commit", mock.Mock(side_effect=self.env.flush_all)
+        ) as mock_commit:
             job = RunJobController._acquire_job(self.env, "test_started_job")
             mock_commit.assert_not_called()
             self.assertIsNone(job)
-            self.assertIn(
-                "was requested to run job test_started_job, but it does not exist",
-                logs.output[0],
-            )