solid_queue 1.7.1 → 1.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d55976c5a8d2a3e411cfb10099c0bbbeedc4652fcb02edfb8474b31b793c164c
-  data.tar.gz: 5a4a9ddffa329ef4ff6feb7fb642f18baaae637d8248f55bfa739d56a7f16824
+  metadata.gz: 0d1bbdf59a147fbbf0dbb46fe048353340c9f78ee31a5285318b244d3dc4fa7c
+  data.tar.gz: 804fe9402e26203920158d705ef2d0353c5d99dba05ae156c3a4ee148b155cdd
 SHA512:
-  metadata.gz: 8301a9c5150cc8f0a99b47755fd2e22e41832a913618fffe3280bd61be27c7f84a570ba2ade570a8228b6d07b4587b914fa61b626b24e87b4d57f8cd702e9949
-  data.tar.gz: af764dc8c6749f5a88a50993693b36450a0dfe158ea04a6dd267fd23476208c858e96a17cf767152be75eb6bbc0bfb82d1cdfb3863091b5cfc4d8430eec72997
+  metadata.gz: a6d1a1426fd0be06daf3c0b7ac0b508cc7eaa75a32024d89088ac19d5abc2373c8b75ad6795a248e007bd376ebcf2c6ef10a30649625c6f3555703090a75d9fb
+  data.tar.gz: 5f57c878e6876d91ec56fd4492f9db5b190071db5efd12ff618ab566c618fc03720c4f76bb522758a9f4f58b258313fc0255020d05aa4cb5815fa041f1fec9bd

data/UPGRADING.md

@@ -1,3 +1,10 @@
+# Upgrading to version 1.7.2
+Jobs with [concurrency controls](README.md#concurrency-controls) now remember which semaphore they got their slot from, in their serialized job data, and give the slot back only to that semaphore. Before, a job that ran past its `duration` gave its slot back to the semaphore a later job had created after the job's own one expired, so one more job than the limit allowed could run at the same time, and keep doing so until the jobs waiting for that key ran out.
+
+There's nothing to change or migrate. Jobs that got their slot before you upgrade have nothing recorded and give it back as before, so old and new versions can run side by side while you deploy.
+
+Solid Queue 2.0 will stop giving back slots that weren't recorded. Before upgrading to 2.0, make sure the concurrency-limited jobs that were ready or running when you upgraded to 1.7.2 have finished. Otherwise their slots won't be given back: a slot like that only comes back when its semaphore expires, and every job that takes or gives back a slot for the same key pushes that expiry out by another `duration`, so on a busy key with a limit above 1 it can stay lost for as long as the key stays busy.
+
 # Upgrading to version 1.7.x
 This version introduces support for grouping jobs into batches, which needs new tables. Fresh installs get them with the base schema; existing installations need to copy the migration that adds them and run it:
 

data/app/models/solid_queue/blocked_execution.rb

@@ -51,7 +51,7 @@ module SolidQueue
             destroy!
 
             payload[:failed] = true
-          elsif acquire_concurrency_lock
+          elsif job.acquire_concurrency_lock
             promote_to_ready
             destroy!
 
@@ -63,12 +63,7 @@ module SolidQueue
 
     private
       def set_expires_at
-        duration = job.job_class ? job.concurrency_duration : SolidQueue.default_concurrency_control_period
-        self.expires_at = duration.from_now
-      end
-
-      def acquire_concurrency_lock
-        Semaphore.wait(job)
+        self.expires_at = job.concurrency_duration.from_now
       end
 
       def promote_to_ready

data/app/models/solid_queue/job/concurrency_controls.rb

@@ -5,11 +5,12 @@ module SolidQueue
     module ConcurrencyControls
       extend ActiveSupport::Concern
 
+      # Stored in the job's serialized Active Job data, which Active Job ignores when running the job
+      CONCURRENCY_LOCK_KEY = "solid_queue_concurrency_lock"
+
       included do
         has_one :blocked_execution
 
-        delegate :concurrency_limit, :concurrency_duration, to: :job_class
-
         before_destroy :unblock_next_blocked_job, if: -> { concurrency_limited? && ready? }
       end
 
@@ -25,8 +26,39 @@ module SolidQueue
         end
       end
 
+      def acquire_concurrency_lock
+        return true unless concurrency_limited?
+
+        if job_class.nil?
+          # A job whose class doesn't load skips its limits. Record that it holds no slot,
+          # so it doesn't give one back if it runs somewhere its class does load.
+          record_concurrency_lock(semaphore_id: nil)
+        elsif semaphore_id = Semaphore.wait(self)
+          record_concurrency_lock(semaphore_id:, limit: concurrency_limit)
+        end
+      end
+
       def concurrency_limited?
-        concurrency_key.present? && job_class.present?
+        concurrency_key.present?
+      end
+
+      # A job that kept its concurrency key after its class dropped limits_concurrency gets a limit of 1
+      def concurrency_limit
+        job_class.concurrency_limit || 1 if concurrency_limited?
+      end
+
+      def concurrency_duration
+        job_class ? job_class.concurrency_duration : SolidQueue.default_concurrency_control_period
+      end
+
+      # The semaphore the job got its concurrency slot from
+      def acquired_semaphore_id
+        concurrency_lock&.dig("semaphore_id")
+      end
+
+      # The concurrency limit the job had when it got its slot
+      def acquired_concurrency_limit
+        concurrency_lock&.dig("limit")
       end
 
       def blocked?
@@ -38,20 +70,35 @@ module SolidQueue
       end
 
       private
-        def concurrency_on_conflict
-          job_class.concurrency_on_conflict.to_s.inquiry
+        def release_concurrency_lock
+          holds_concurrency_slot? && Semaphore.signal(self)
         end
 
-        def acquire_concurrency_lock
-          return true unless concurrency_limited?
+        def holds_concurrency_slot?
+          if concurrency_lock_recorded?
+            acquired_semaphore_id.present?
+          else
+            # Jobs dispatched before Solid Queue recorded their semaphore, which need their class to know their limit
+            concurrency_limited? && job_class.present?
+          end
+        end
 
-          Semaphore.wait(self)
+        def concurrency_lock_recorded?
+          arguments.key?(CONCURRENCY_LOCK_KEY)
         end
 
-        def release_concurrency_lock
-          return false unless concurrency_limited?
+        def release_next_blocked_job
+          BlockedExecution.release_one(concurrency_key)
+        end
+
+        def record_concurrency_lock(semaphore_id:, limit: nil)
+          arguments[CONCURRENCY_LOCK_KEY] = { "semaphore_id" => semaphore_id, "limit" => limit }
+          update_column :arguments, arguments
+          true
+        end
 
-          Semaphore.signal(self)
+        def concurrency_lock
+          arguments[CONCURRENCY_LOCK_KEY]
         end
 
         def handle_concurrency_conflict
@@ -62,12 +109,12 @@ module SolidQueue
           end
         end
 
-        def block
-          BlockedExecution.create_or_find_by!(job: self)
+        def concurrency_on_conflict
+          job_class.concurrency_on_conflict.to_s.inquiry
         end
 
-        def release_next_blocked_job
-          BlockedExecution.release_one(concurrency_key)
+        def block
+          BlockedExecution.create_or_find_by!(job: self)
         end
 
         def execution

data/app/models/solid_queue/semaphore.rb

@@ -31,9 +31,10 @@ module SolidQueue
         @job = job
       end
 
+      # Returns the id of the semaphore the job got a slot on, or nil if there was none free
       def wait
         if semaphore = Semaphore.lock.find_by(key: key)
-          semaphore.value > 0 && attempt_decrement
+          semaphore.id if semaphore.value > 0 && attempt_decrement
         else
           attempt_creation
         end
@@ -46,24 +47,46 @@ module SolidQueue
       private
         attr_accessor :job
 
+        def attempt_decrement
+          Semaphore.available.where(key: key).update_all([ "value = value - 1, expires_at = ?", expires_at ]) > 0
+        end
+
         def attempt_creation
           if Semaphore.create_unique_by(key: key, value: limit - 1, expires_at: expires_at)
-            true
+            acquired_semaphore_id
           else
             check_limit_or_decrement
           end
         end
 
-        def check_limit_or_decrement
-          limit == 1 ? false : attempt_decrement
+        # A locking read, so it sees the latest committed rows rather than the transaction's
+        # snapshot, which on MySQL can still include a semaphore that expired and was deleted
+        def acquired_semaphore_id
+          Semaphore.lock.where(key: key).pick(:id)
         end
 
-        def attempt_decrement
-          Semaphore.available.where(key: key).update_all([ "value = value - 1, expires_at = ?", expires_at ]) > 0
+        def check_limit_or_decrement
+          acquired_semaphore_id if limit > 1 && attempt_decrement
         end
 
         def attempt_increment
-          Semaphore.where(key: key, value: ...limit).update_all([ "value = value + 1, expires_at = ?", expires_at ]) > 0
+          semaphore_to_release.where(value: ...limit_to_release).update_all([ "value = value + 1, expires_at = ?", expires_at ]) > 0
+        end
+
+        # A job only gives its slot back to the semaphore it got it from. If that one expired
+        # and was deleted, a semaphore for the same key now belongs to other jobs.
+        # Jobs dispatched before Solid Queue recorded their semaphore give it back by key.
+        def semaphore_to_release
+          if job.acquired_semaphore_id
+            Semaphore.where(id: job.acquired_semaphore_id)
+          else
+            Semaphore.where(key: key)
+          end
+        end
+
+        # Recorded when the job got its slot, so it's known even if the job's class no longer loads
+        def limit_to_release
+          job.acquired_concurrency_limit || limit
         end
 
         def key
@@ -75,7 +98,7 @@ module SolidQueue
         end
 
         def limit
-          job.concurrency_limit || 1
+          job.concurrency_limit
         end
     end
   end

data/lib/solid_queue/version.rb

@@ -1,5 +1,5 @@
 module SolidQueue
-  VERSION = "1.7.1"
+  VERSION = "1.7.2"
 
   def self.next_major_version
     Gem::Version.new(VERSION).segments.first + 1

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: solid_queue
 version: !ruby/object:Gem::Version
-  version: 1.7.1
+  version: 1.7.2
 platform: ruby
 authors:
 - Rosa Gutierrez