Set provider_job_id in active_jobs passed to enqueue_all

Only for those enqueued successfully, that's it.

Author: rosa

app/models/solid_queue/job.rb

@@ -12,17 +12,23 @@ class Job < Record
 
     class << self
       def enqueue_all(active_jobs)
+        active_jobs_by_job_id = active_jobs.index_by(&:job_id)
+
         transaction do
           jobs = create_all_from_active_jobs(active_jobs)
-          prepare_all_for_execution(jobs)
+          prepare_all_for_execution(jobs).tap do |enqueued_jobs|
+            enqueued_jobs.each do |enqueued_job|
+              active_jobs_by_job_id[enqueued_job.active_job_id].provider_job_id = enqueued_job.id
+            end
+          end
         end
       end
 
       def enqueue(active_job, scheduled_at: Time.current)
         active_job.scheduled_at = scheduled_at
 
-        create_from_active_job(active_job).tap do |job|
-          active_job.provider_job_id = job.id
+        create_from_active_job(active_job).tap do |enqueued_job|
+          active_job.provider_job_id = enqueued_job.id
         end
       end
 

app/models/solid_queue/job/executable.rb

@@ -23,30 +23,51 @@ module Executable
       class_methods do
         def prepare_all_for_execution(jobs)
           due, not_yet_due = jobs.partition(&:due?)
-
-          dispatch_all(due)
-          schedule_all(not_yet_due)
+          dispatch_all(due) + schedule_all(not_yet_due)
         end
 
         def dispatch_all(jobs)
           with_concurrency_limits, without_concurrency_limits = jobs.partition(&:concurrency_limited?)
 
           dispatch_all_at_once(without_concurrency_limits)
           dispatch_all_one_by_one(with_concurrency_limits)
+
+          successfully_dispatched(jobs)
         end
 
         def schedule_all(jobs)
-          ScheduledExecution.create_all_from_jobs(jobs)
+          schedule_all_at_once(jobs)
+          successfully_scheduled(jobs)
         end
 
         private
           def dispatch_all_at_once(jobs)
             ReadyExecution.create_all_from_jobs jobs
           end
 
+          def schedule_all_at_once(jobs)
+            ScheduledExecution.create_all_from_jobs(jobs)
+          end
+
           def dispatch_all_one_by_one(jobs)
             jobs.each(&:dispatch)
           end
+
+          def successfully_dispatched(jobs)
+            dispatched_and_ready(jobs) + dispatched_and_blocked(jobs)
+          end
+
+          def dispatched_and_ready(jobs)
+            where(id: ReadyExecution.where(job_id: jobs.map(&:id)).pluck(:job_id))
+          end
+
+          def dispatched_and_blocked(jobs)
+            where(id: BlockedExecution.where(job_id: jobs.map(&:id)).pluck(:job_id))
+          end
+
+          def successfully_scheduled(jobs)
+            where(id: ScheduledExecution.where(job_id: jobs.map(&:id)).pluck(:job_id))
+          end
       end
 
       %w[ ready claimed failed scheduled ].each do |status|

app/models/solid_queue/scheduled_execution.rb

@@ -22,25 +22,12 @@ def dispatch_next_batch(batch_size)
       private
         def dispatch_batch(job_ids)
           jobs = Job.where(id: job_ids)
-          Job.dispatch_all(jobs)
 
-          successfully_dispatched(job_ids).tap do |dispatched_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
-
-        def successfully_dispatched(job_ids)
-          dispatched_and_ready(job_ids) + dispatched_and_blocked(job_ids)
-        end
-
-        def dispatched_and_ready(job_ids)
-          ReadyExecution.where(job_id: job_ids).pluck(:job_id)
-        end
-
-        def dispatched_and_blocked(job_ids)
-          BlockedExecution.where(job_id: job_ids).pluck(:job_id)
-        end
     end
   end
 end

test/models/solid_queue/job_test.rb

@@ -35,6 +35,7 @@ class NonOverlappingGroupedJob2 < NonOverlappingJob
     end
 
     solid_queue_job = SolidQueue::Job.last
+    assert_equal solid_queue_job.id, active_job.provider_job_id
     assert_equal 8, solid_queue_job.priority
     assert_equal "test", solid_queue_job.queue_name
     assert_equal "AddToBufferJob", solid_queue_job.class_name
@@ -118,6 +119,9 @@ class NonOverlappingGroupedJob2 < NonOverlappingJob
     assert_multi(ready: 5, scheduled: 2, blocked: 2) do
       ActiveJob.perform_all_later(active_jobs)
     end
+
+    jobs = SolidQueue::Job.last(9)
+    assert_equal active_jobs.map(&:provider_job_id).sort, jobs.pluck(:id).sort
   end
 
   test "block jobs when concurrency limits are reached" do