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

Author: hoangtrann

queue_job/jobrunner/runner.py

@@ -361,52 +361,26 @@ def _query_requeue_dead_jobs(self):
                         ELSE exc_info
                     END)
             WHERE
-                id in (
-                    SELECT
-                        queue_job_id
-                    FROM
-                        queue_job_lock
-                    WHERE
-                        queue_job_id in (
-                            SELECT
-                                id
-                            FROM
-                                queue_job
-                            WHERE
-                                state IN ('enqueued','started')
-                                AND date_enqueued <
-                                (now() AT TIME ZONE 'utc' - INTERVAL '10 sec')
-                        )
-                    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'
+                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_id = queue_job.id
+                AND (
+                    id in (
+                        SELECT
+                            queue_job_id
+                        FROM
+                            queue_job_lock
+                        WHERE
+                            queue_job_lock.queue_job_id = queue_job.id
+                        FOR UPDATE SKIP LOCKED
+                    )
+                    OR NOT EXISTS (
+                        SELECT
+                            1
+                        FROM
+                            queue_job_lock
+                        WHERE
+                            queue_job_lock.queue_job_id = queue_job.id
+                    )
                 )
             RETURNING uuid
             """
@@ -429,6 +403,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:
@@ -439,14 +419,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

@@ -93,14 +93,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)