Implement retry_all by selecting, locking, dispatching and deleting

This is very similar to the work we have to do when dispatching scheduled
executions, so this extracts that common functionality into its own concern.

Author: rosa

app/models/solid_queue/execution/dispatching.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module SolidQueue
+  class Execution
+    module Dispatching
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def dispatch_batch(job_ids)
+          jobs = Job.where(id: job_ids)
+
+          Job.dispatch_all(jobs).map(&:id).tap do |dispatched_job_ids|
+            where(job_id: dispatched_job_ids).delete_all
+            SolidQueue.logger.info("[SolidQueue] Dispatched scheduled batch with #{dispatched_job_ids.size} jobs")
+          end
+        end
+      end
+    end
+  end
+end

app/models/solid_queue/failed_execution.rb

@@ -1,27 +1,40 @@
 # frozen_string_literal: true
 
-class SolidQueue::FailedExecution < SolidQueue::Execution
-  serialize :error, coder: JSON
+module SolidQueue
+  class FailedExecution < Execution
+    include Dispatching
 
-  before_create :expand_error_details_from_exception
+    serialize :error, coder: JSON
 
-  attr_accessor :exception
+    before_create :expand_error_details_from_exception
 
-  def retry
-    transaction do
-      job.prepare_for_execution
-      destroy!
+    attr_accessor :exception
+
+    class << self
+      def retry_all(jobs)
+        transaction do
+          retriable_job_ids = where(job_id: jobs.map(&:id)).order(:job_id).lock.pluck(:job_id)
+          dispatch_batch(retriable_job_ids)
+        end
+      end
+    end
+
+    def retry
+      with_lock do
+        job.prepare_for_execution
+        destroy!
+      end
     end
-  end
 
-  %i[ exception_class message backtrace ].each do |attribute|
-    define_method(attribute) { error.with_indifferent_access[attribute] }
-  end
+    %i[ exception_class message backtrace ].each do |attribute|
+      define_method(attribute) { error.with_indifferent_access[attribute] }
+    end
 
-  private
-    def expand_error_details_from_exception
-      if exception
-        self.error = { exception_class: exception.class.name, message: exception.message, backtrace: exception.backtrace }
+    private
+      def expand_error_details_from_exception
+        if exception
+          self.error = { exception_class: exception.class.name, message: exception.message, backtrace: exception.backtrace }
+        end
       end
     end
 end

app/models/solid_queue/ready_execution.rb

@@ -41,12 +41,5 @@ def lock_candidates(job_ids, process_id)
           end
         end
     end
-
-    def discard
-      with_lock do
-        job.destroy
-        destroy
-      end
-    end
   end
 end

app/models/solid_queue/scheduled_execution.rb

@@ -2,6 +2,8 @@
 
 module SolidQueue
   class ScheduledExecution < Execution
+    include Dispatching
+
     scope :due, -> { where(scheduled_at: ..Time.current) }
     scope :ordered, -> { order(scheduled_at: :asc, priority: :asc) }
     scope :next_batch, ->(batch_size) { due.ordered.limit(batch_size) }
@@ -18,16 +20,6 @@ def dispatch_next_batch(batch_size)
           end
         end
       end
-
-      private
-        def dispatch_batch(job_ids)
-          jobs = Job.where(id: job_ids)
-
-          Job.dispatch_all(jobs).map(&:id).tap do |dispatched_job_ids|
-            where(job_id: dispatched_job_ids).delete_all
-            SolidQueue.logger.info("[SolidQueue] Dispatched scheduled batch with #{dispatched_job_ids.size} jobs")
-          end
-        end
     end
   end
 end

test/integration/jobs_lifecycle_test.rb

@@ -3,8 +3,8 @@
 
 class JobsLifecycleTest < ActiveSupport::TestCase
   setup do
-    @worker = SolidQueue::Worker.new(queues: "background", threads: 3, polling_interval: 0.5)
-    @dispatcher = SolidQueue::Dispatcher.new(batch_size: 10, polling_interval: 1)
+    @worker = SolidQueue::Worker.new(queues: "background", threads: 3)
+    @dispatcher = SolidQueue::Dispatcher.new(batch_size: 10, polling_interval: 0.2)
   end
 
   teardown do

test/models/solid_queue/failed_execution_test.rb

@@ -0,0 +1,40 @@
+require "test_helper"
+
+class SolidQueue::FailedExecutionTest < ActiveSupport::TestCase
+  setup do
+    @worker = SolidQueue::Worker.new(queues: "background")
+    @worker.mode = :inline
+  end
+
+  test "run job that fails" do
+    RaisingJob.perform_later(RuntimeError, "A")
+    @worker.start
+
+    assert_equal 1, SolidQueue::FailedExecution.count
+    assert SolidQueue::Job.last.failed?
+  end
+
+  test "retry failed job" do
+    RaisingJob.perform_later(RuntimeError, "A")
+    @worker.start
+
+    assert_difference -> { SolidQueue::FailedExecution.count }, -1 do
+      assert_difference -> { SolidQueue::ReadyExecution.count }, +1 do
+        SolidQueue::FailedExecution.last.retry
+      end
+    end
+  end
+
+  test "retry failed jobs in bulk" do
+    1.upto(5) { |i| RaisingJob.perform_later(RuntimeError, i) }
+    1.upto(3) { |i| AddToBufferJob.perform_later(i) }
+
+    @worker.start
+
+    assert_difference -> { SolidQueue::FailedExecution.count }, -5 do
+      assert_difference -> { SolidQueue::ReadyExecution.count }, +5 do
+        SolidQueue::FailedExecution.retry_all(SolidQueue::Job.all)
+      end
+    end
+  end
+end