[IMP] queue_job: query orphaned dead job not exist in lock table

Author: hoangtrann

queue_job/jobrunner/runner.py

@@ -357,13 +357,13 @@ def _query_requeue_dead_jobs(self):
                         ELSE exc_info
                     END)
             WHERE
-                id in (
+                id IN (
                     SELECT
                         queue_job_id
                     FROM
                         queue_job_lock
                     WHERE
-                        queue_job_id in (
+                        queue_job_id IN (
                             SELECT
                                 id
                             FROM
@@ -375,34 +375,18 @@ def _query_requeue_dead_jobs(self):
                         )
                     FOR UPDATE SKIP LOCKED
                 )
-            RETURNING uuid
-            """
-
-    def _query_requeue_orphaned_jobs(self):
-        """Query to requeue jobs stuck in 'enqueued' state without a lock.
-
-        This handles the edge case where the runner marks a job as 'enqueued'
-        but the HTTP request to start the job never reaches the Odoo server
-        (e.g., due to server shutdown/crash between setting enqueued and
-        the controller receiving the request). These jobs have no lock record
-        because set_started() was never called, so they are invisible to
-        _query_requeue_dead_jobs().
-        """
-        return """
-            UPDATE
-                queue_job
-            SET
-                state='pending'
-            WHERE
-                state = 'enqueued'
-                AND date_enqueued < (now() AT TIME ZONE 'utc' - INTERVAL '10 sec')
-                AND NOT EXISTS (
-                    SELECT
-                        1
-                    FROM
-                        queue_job_lock
-                    WHERE
-                        queue_job_id = queue_job.id
+                OR (
+                    state IN ('enqueued','started')
+                    AND date_enqueued <
+                    (now() AT TIME ZONE 'utc' - INTERVAL '10 sec')
+                    AND NOT EXISTS (
+                        SELECT
+                            1
+                        FROM
+                            queue_job_lock
+                        WHERE
+                            queue_job_lock.queue_job_id = queue_job.id
+                    )
                 )
             RETURNING uuid
             """
@@ -425,6 +409,12 @@ def requeue_dead_jobs(self):
         However, when the Odoo server crashes or is otherwise force-stopped,
         running jobs are interrupted while the runner has no chance to know
         they have been aborted.
+
+        This also handles orphaned jobs (enqueued but never started, no lock).
+        This edge case occurs when the runner marks a job as 'enqueued'
+        but the HTTP request to start the job never reaches the Odoo server
+        (e.g., due to server shutdown/crash between setting enqueued and
+        the controller receiving the request).
         """
 
         with closing(self.conn.cursor()) as cr:
@@ -435,14 +425,6 @@ def requeue_dead_jobs(self):
             for (uuid,) in cr.fetchall():
                 _logger.warning("Re-queued dead job with uuid: %s", uuid)
 
-            # Requeue orphaned jobs (enqueued but never started, no lock)
-            query = self._query_requeue_orphaned_jobs()
-            cr.execute(query)
-            for (uuid,) in cr.fetchall():
-                _logger.warning(
-                    "Re-queued orphaned job (enqueued without lock) with uuid: %s", uuid
-                )
-
 
 class QueueJobRunner:
     def __init__(

test_queue_job/tests/test_requeue_dead_job.py

@@ -110,14 +110,8 @@ def test_requeue_orphaned_jobs(self):
         job_obj.date_enqueued = datetime.now() - timedelta(minutes=1)
         job_obj.store()
 
-        # job ins't actually picked up by the first requeue attempt
+        # job is now picked up by the requeue query (which includes orphaned jobs)
         query = Database(self.env.cr.dbname)._query_requeue_dead_jobs()
         self.env.cr.execute(query)
         uuids_requeued = self.env.cr.fetchall()
-        self.assertFalse(uuids_requeued)
-
-        # job is picked up by the 2nd requeue attempt
-        query = Database(self.env.cr.dbname)._query_requeue_orphaned_jobs()
-        self.env.cr.execute(query)
-        uuids_requeued = self.env.cr.fetchall()
         self.assertTrue(queue_job.uuid in j[0] for j in uuids_requeued)