switchman-inst-jobs 4.3.1 → 4.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3d126fdf9fae2bd957760dd1fdf1cac821e5103eb691fc2b293b3bda6170bb5c
-  data.tar.gz: 977e7915aea7e1e389ad95c190e5ae749a868f869f1d28542ee264342f57b89e
+  metadata.gz: 2801cf9e3bb894d8c46915457a1b1cf2f77ca10e49e1947665eb077a8bb58378
+  data.tar.gz: 558b1db888887f7463c8cafc3399001341be364dea5e5ff15d88a1213d9ed420
 SHA512:
-  metadata.gz: 407591bf52c6068c6133b1654a68ffacb4aae0c0d941f7bdab9536a682c70a0a3ca04017c68e61ac6475fbd75a0b7cb93c35b1ce94e6e54b69fb638020802225
-  data.tar.gz: d5a69e5b56e07f4c90dcd5fea9f28f491c56f832acdd821b081ee5d3bb068af516b9ca114d464cda4f154edf4765b91c3d10c05f60b31c6612b5e72dca0c79ec
+  metadata.gz: b01ca10ff4988509cee9728241d954b4b9bbfc6e2c9971730235f9adbcf50694bcae0226362f68a9e5602591368cf24e866ea0fbf653b05091184f7406fef774
+  data.tar.gz: 0b15b1296d8b5bf887f7ca8bd745886757e57e76591829ea2028b4c7a7c803bd86bc219cca4df630b49e8d61807b088437f94c5eb40b0daa8aac4111ebedb4fd

data/db/migrate/20260120092005_add_migrate_from_jobs_shard.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class AddMigrateFromJobsShard < ActiveRecord::Migration[7.1]
+  def change
+    add_reference :switchman_shards, :migrate_from_delayed_jobs_shard, foreign_key: { to_table: :switchman_shards }, index: false, if_not_exists: true
+  end
+end

data/lib/switchman_inst_jobs/jobs_migrator.rb

@@ -39,17 +39,17 @@ module SwitchmanInstJobs
         source_shards = Hash.new([].freeze)
         target_shards = Hash.new([].freeze)
         # Also add any incomplete moves to the source shards to ensure we clean up appropriately
-        ::Switchman::Shard.where.not(previous_delayed_jobs_shard_id: nil).find_each do |shard|
+        ::Switchman::Shard.where.not(migrate_from_delayed_jobs_shard_id: nil).find_each do |shard|
           effective_map[shard.id] ||= shard.delayed_jobs_shard.id
         end
         effective_map.each do |(shard, target_shard)|
           shard = ::Switchman::Shard.find(shard) unless shard.is_a?(::Switchman::Shard)
           target_shard = target_shard.try(:id) || target_shard
           # if a move was interrupted, the new shard is already set as the delayed_jobs_shard
-          # but we still have the old shard stored in previous_delayed_jobs_shard and should
+          # but we still have the old shard stored in migrate_from_delayed_jobs_shard and should
           # act as if we are moving from there in the first place
-          if shard.previous_delayed_jobs_shard_id && shard.delayed_jobs_shard.id == target_shard
-            source_shards[shard.previous_delayed_jobs_shard_id] += [shard.id]
+          if shard.migrate_from_delayed_jobs_shard_id && shard.delayed_jobs_shard.id == target_shard
+            source_shards[shard.migrate_from_delayed_jobs_shard_id] += [shard.id]
           else
             source_shards[shard.delayed_jobs_shard.id] += [shard.id]
           end
@@ -63,7 +63,7 @@ module SwitchmanInstJobs
         ::Switchman::Shard.transaction do
           # Do the updates in batches and then just clear redis instead of clearing them one at a time
           source_shards.each do |source_shard, shards|
-            updates = { previous_delayed_jobs_shard_id: source_shard }
+            updates = { migrate_from_delayed_jobs_shard_id: source_shard }
             ::Switchman::Shard.where(id: shards).update_all(updates)
           end
           target_shards.each do |target_shard, shards|
@@ -86,7 +86,7 @@ module SwitchmanInstJobs
         end
         ensure_unblock_stranded_for(effective_map.map(&:first))
         # rubocop:enable Style/CombinableLoops
-        ::Switchman::Shard.where(id: effective_map.map(&:first)).update_all(previous_delayed_jobs_shard_id: nil)
+        ::Switchman::Shard.where(id: effective_map.map(&:first)).update_all(migrate_from_delayed_jobs_shard_id: nil)
       end
 
       # if :migrate_strands ran on any shards that fell into scenario 1, then

data/lib/switchman_inst_jobs/switchman/shard.rb

@@ -22,56 +22,82 @@ module SwitchmanInstJobs
       # Adapted from hold/unhold methods in base delayed jobs base
       # Wait is required to be able to safely move jobs
       def hold_jobs!(wait: false)
-        self.jobs_held = true
-        save! if changed?
-        delayed_jobs_shard.activate(::Delayed::Backend::ActiveRecord::AbstractJob) do
-          lock_jobs_for_hold
-        end
-        return unless wait
-
-        delayed_jobs_shard.activate(::Delayed::Backend::ActiveRecord::AbstractJob) do
-          while ::Delayed::Job.where(shard_id: id)
-                              .where.not(locked_at: nil)
-                              .where.not(locked_by: ::Delayed::Backend::Base::ON_HOLD_LOCKED_BY).exists?
-            sleep 10
-            lock_jobs_for_hold
-          end
-        end
+        ::Switchman::Shard.where(id: self).hold_jobs!(wait:)
       end
 
       def unhold_jobs!
-        self.jobs_held = false
-        if changed?
-          save!
+        ::Switchman::Shard.where(id: self).unhold_jobs!
+      end
+
+      module ClassMethods
+        # Adapted from hold/unhold methods in base delayed jobs base
+        # Wait is required to be able to safely move jobs
+        def hold_jobs!(wait: false)
+          shards = all.to_a
+          wait_for_caches = false
+          shards.each do |shard|
+            shard.jobs_held = true
+            if shard.changed?
+              shard.save!
+              wait_for_caches = true if wait
+            end
+          end
+          shards_by_jobs_shard(shards).each do |jobs_shard, shard_ids|
+            jobs_shard.activate(::Delayed::Backend::ActiveRecord::AbstractJob) do
+              lock_jobs_for_hold(shard_ids)
+            end
+          end
+          return unless wait
+
           # Wait a little over the 60 second in-process shard cache clearing
           # threshold to ensure that all new jobs are now being enqueued
-          # unlocked
+          # locked
           Rails.logger.debug("Waiting for caches to clear")
-          sleep(65)
-        end
-        delayed_jobs_shard.activate(::Delayed::Backend::ActiveRecord::AbstractJob) do
-          ::Delayed::Job.where(locked_by: ::Delayed::Backend::Base::ON_HOLD_LOCKED_BY, shard_id: id)
-                        .in_batches(of: 10_000)
-                        .update_all(
-                          locked_by: nil,
-                          locked_at: nil,
-                          attempts: 0,
-                          failed_at: nil
-                        )
+          sleep(65) if wait && wait_for_caches
+
+          shards_by_jobs_shard(shards).each do |jobs_shard, shard_ids|
+            jobs_shard.activate(::Delayed::Backend::ActiveRecord::AbstractJob) do
+              while ::Delayed::Job.where(shard_id: shard_ids)
+                                  .where.not(locked_at: nil)
+                                  .where.not(locked_by: ::Delayed::Backend::Base::ON_HOLD_LOCKED_BY).exists?
+                sleep 10
+                lock_jobs_for_hold(shard_ids)
+              end
+            end
+          end
         end
-      end
-
-      private
 
-      def lock_jobs_for_hold
-        ::Delayed::Job.where(locked_at: nil, shard_id: id).in_batches(of: 10_000).update_all(
-          locked_by: ::Delayed::Backend::Base::ON_HOLD_LOCKED_BY,
-          locked_at: ::Delayed::Job.db_time_now,
-          attempts: ::Delayed::Backend::Base::ON_HOLD_COUNT
-        )
-      end
+        def unhold_jobs!
+          shards = all.to_a
+          waited = false
+          shards.each do |shard|
+            shard.jobs_held = false
+            next unless shard.changed?
+
+            shard.save!
+            next if waited
+
+            # Wait a little over the 60 second in-process shard cache clearing
+            # threshold to ensure that all new jobs are now being enqueued
+            # unlocked
+            Rails.logger.debug("Waiting for caches to clear")
+            sleep(65)
+            waited = true
+          end
+          shards_by_jobs_shard(shards).each do |jobs_shard, shard_ids|
+            jobs_shard.activate(::Delayed::Backend::ActiveRecord::AbstractJob) do
+              ::Delayed::Job.where(locked_by: ::Delayed::Backend::Base::ON_HOLD_LOCKED_BY, shard_id: shard_ids)
+                            .in_batches(of: 10_000)
+                            .update_all(
+                              locked_by: nil,
+                              locked_at: nil,
+                              attempts: 0,
+                              failed_at: nil
+                            )
+            end
+          end
+        end
 
-      module ClassMethods
         def clear_cache
           super
           remove_instance_variable(:@delayed_jobs_shards) if instance_variable_defined?(:@delayed_jobs_shards)
@@ -130,6 +156,22 @@ module SwitchmanInstJobs
 
           ::Switchman::Shard.merge(scope)
         end
+
+        private
+
+        # Group the given shards by the shard their jobs live on, returning a
+        # hash of delayed_jobs_shard => [shard_id, ...]
+        def shards_by_jobs_shard(shards)
+          shards.group_by(&:delayed_jobs_shard).transform_values { |group| group.map(&:id) }
+        end
+
+        def lock_jobs_for_hold(shard_ids)
+          ::Delayed::Job.where(locked_at: nil, shard_id: shard_ids).in_batches(of: 10_000).update_all(
+            locked_by: ::Delayed::Backend::Base::ON_HOLD_LOCKED_BY,
+            locked_at: ::Delayed::Job.db_time_now,
+            attempts: ::Delayed::Backend::Base::ON_HOLD_COUNT
+          )
+        end
       end
     end
   end

data/lib/switchman_inst_jobs/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SwitchmanInstJobs
-  VERSION = "4.3.1"
+  VERSION = "4.3.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: switchman-inst-jobs
 version: !ruby/object:Gem::Version
-  version: 4.3.1
+  version: 4.3.3
 platform: ruby
 authors:
 - Bryan Petty
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-01-20 00:00:00.000000000 Z
+date: 2026-06-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: inst-jobs
@@ -136,7 +136,7 @@ files:
 - db/migrate/20220203063200_remove_old_singleton_index.rb
 - db/migrate/20220328152900_add_failed_jobs_indicies.rb
 - db/migrate/20220519204546_add_requeued_job_id_to_failed_jobs.rb
-- db/migrate/20260120092005_add_previous_jobs_shard.rb
+- db/migrate/20260120092005_add_migrate_from_jobs_shard.rb
 - lib/switchman-inst-jobs.rb
 - lib/switchman_inst_jobs.rb
 - lib/switchman_inst_jobs/active_record/connection_adapters/postgresql_adapter.rb

data/db/migrate/20260120092005_add_previous_jobs_shard.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-class AddPreviousJobsShard < ActiveRecord::Migration[7.1]
-  def change
-    add_reference :switchman_shards, :previous_delayed_jobs_shard, foreign_key: { to_table: :switchman_shards }, index: false, if_not_exists: true
-  end
-end