switchman-inst-jobs 4.0.2 → 4.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e6f9f61d51da46ec92185649cc434d9168740c491ade56179d13537d9552fa8b
-  data.tar.gz: 5c53dbe8087c254444f995ee738cb4164db03fc8a91ae823938a13b372e3eb0d
+  metadata.gz: d08a92d9006c02ccc63baced88bc83fa916a2c78f4634f6b4344de2807b2dc57
+  data.tar.gz: 6ff57e36692acaea9e87cc15129e29e79d1963216c65c471ce3decb5cf600045
 SHA512:
-  metadata.gz: 44c3483d276b435c93abc3547b458cde60739b9a4843465541065ae5d71eb8dcee9d2c4ebebf8b1fe4fc31fd6c7951f983d8af76c44a340e7e29ce811466778f
-  data.tar.gz: 0acdee9429002d28e9368bf29fce1b64fa492132f43b8ff884bca36f5b5aded965343a621c2e61b07de7bd18dcc059b5e11d1a8571a8319a0582d9dc8e1fa206
+  metadata.gz: ae104486ac82a41356510c2793aeee3e883ee669192a72b694678b3c4800af9356308c4d938bd1f18432eecf4362897252c7ea7f13274b73c1050acab0fd6408
+  data.tar.gz: f372dfe516b76b19c68c861574b3c24c50af8b9f0101f4a846dfa7722fc43e162e0b907e9270362ca0217cf543ed3eb0288baf65ce4158d8f7e7ccb92b9fde2f

data/db/migrate/20101216224513_create_delayed_jobs.rb

@@ -1,8 +1,4 @@
 class CreateDelayedJobs < ActiveRecord::Migration[4.2]
-  def connection
-    Delayed::Backend::ActiveRecord::AbstractJob.connection
-  end
-
   def up
     unless connection.adapter_name == 'PostgreSQL'
       raise("#{connection.adapter_name} is not supported for delayed jobs queue")

data/db/migrate/20110208031356_add_delayed_jobs_tag.rb

@@ -1,8 +1,4 @@
 class AddDelayedJobsTag < ActiveRecord::Migration[4.2]
-  def connection
-    Delayed::Backend::ActiveRecord::AbstractJob.connection
-  end
-
   def up
     add_column :delayed_jobs, :tag, :string
     add_index :delayed_jobs, [:tag]

data/db/migrate/20110426161613_add_delayed_jobs_max_attempts.rb

@@ -1,8 +1,4 @@
 class AddDelayedJobsMaxAttempts < ActiveRecord::Migration[4.2]
-  def connection
-    Delayed::Backend::ActiveRecord::AbstractJob.connection
-  end
-
   def up
     add_column :delayed_jobs, :max_attempts, :integer
   end

data/db/migrate/20110516225834_add_delayed_jobs_strand.rb

@@ -1,8 +1,4 @@
 class AddDelayedJobsStrand < ActiveRecord::Migration[4.2]
-  def connection
-    Delayed::Backend::ActiveRecord::AbstractJob.connection
-  end
-
   def up
     add_column :delayed_jobs, :strand, :string
     add_index :delayed_jobs, :strand

data/db/migrate/20110531144916_cleanup_delayed_jobs_indexes.rb

@@ -1,14 +1,10 @@
 class CleanupDelayedJobsIndexes < ActiveRecord::Migration[4.2]
-  def connection
-    Delayed::Backend::ActiveRecord::AbstractJob.connection
-  end
-
   def up
     case connection.adapter_name
     when 'PostgreSQL'
       # "nulls first" syntax is postgresql specific, and allows for more
       # efficient querying for the next job
-      connection.execute("CREATE INDEX get_delayed_jobs_index ON #{::Delayed::Job.quoted_table_name} (priority, run_at, failed_at nulls first, locked_at nulls first, queue)")
+      connection.execute("CREATE INDEX get_delayed_jobs_index ON #{connection.quote_table_name(::Delayed::Job.table_name)} (priority, run_at, failed_at nulls first, locked_at nulls first, queue)")
     else
       add_index :delayed_jobs, %w[priority run_at locked_at failed_at queue], name: 'get_delayed_jobs_index'
     end

data/db/migrate/20110610213249_optimize_delayed_jobs.rb

@@ -1,8 +1,4 @@
 class OptimizeDelayedJobs < ActiveRecord::Migration[4.2]
-  def connection
-    Delayed::Backend::ActiveRecord::AbstractJob.connection
-  end
-
   def up
     create_table :failed_jobs do |t|
       t.integer  'priority',    default: 0
@@ -27,11 +23,6 @@ class OptimizeDelayedJobs < ActiveRecord::Migration[4.2]
 
     add_index :delayed_jobs, %w[run_at queue locked_at strand priority], name: 'index_delayed_jobs_for_get_next'
     add_index :delayed_jobs, %w[strand id], name: 'index_delayed_jobs_on_strand'
-
-    # move all failed jobs to the new failed table
-    Delayed::Backend::ActiveRecord::Job.where.not(failed_at: nil).find_each do |job|
-      job.fail! unless job.on_hold?
-    end
   end
 
   def down

data/db/migrate/20110831210257_add_delayed_jobs_next_in_strand.rb

@@ -1,15 +1,11 @@
 class AddDelayedJobsNextInStrand < ActiveRecord::Migration[4.2]
-  def connection
-    Delayed::Backend::ActiveRecord::AbstractJob.connection
-  end
-
   def up
     remove_index :delayed_jobs, name: 'index_delayed_jobs_for_get_next'
 
     add_column :delayed_jobs, :next_in_strand, :boolean, default: true, null: false
 
     # create the new index
-    connection.execute("CREATE INDEX get_delayed_jobs_index ON #{::Delayed::Job.quoted_table_name} (priority, run_at, queue) WHERE locked_at IS NULL AND next_in_strand = 't'")
+    connection.execute("CREATE INDEX get_delayed_jobs_index ON #{connection.quote_table_name(::Delayed::Job.table_name)} (priority, run_at, queue) WHERE locked_at IS NULL AND next_in_strand = 't'")
 
     # create the insert trigger
     execute(<<-CODE)
@@ -23,7 +19,7 @@ class AddDelayedJobsNextInStrand < ActiveRecord::Migration[4.2]
     END;
     $$ LANGUAGE plpgsql SET search_path TO #{::Switchman::Shard.current.name};
     CODE
-    execute("CREATE TRIGGER delayed_jobs_before_insert_row_tr BEFORE INSERT ON #{::Delayed::Job.quoted_table_name} FOR EACH ROW WHEN (NEW.strand IS NOT NULL) EXECUTE PROCEDURE #{connection.quote_table_name('delayed_jobs_before_insert_row_tr_fn')}()")
+    execute("CREATE TRIGGER delayed_jobs_before_insert_row_tr BEFORE INSERT ON #{connection.quote_table_name(::Delayed::Job.table_name)} FOR EACH ROW WHEN (NEW.strand IS NOT NULL) EXECUTE PROCEDURE #{connection.quote_table_name('delayed_jobs_before_insert_row_tr_fn')}()")
 
     # create the delete trigger
     execute(<<-CODE)
@@ -34,15 +30,15 @@ class AddDelayedJobsNextInStrand < ActiveRecord::Migration[4.2]
     END;
     $$ LANGUAGE plpgsql SET search_path TO #{::Switchman::Shard.current.name};
     CODE
-    execute("CREATE TRIGGER delayed_jobs_after_delete_row_tr AFTER DELETE ON #{::Delayed::Job.quoted_table_name} FOR EACH ROW WHEN (OLD.strand IS NOT NULL AND OLD.next_in_strand = 't') EXECUTE PROCEDURE #{connection.quote_table_name('delayed_jobs_after_delete_row_tr_fn')} ()")
+    execute("CREATE TRIGGER delayed_jobs_after_delete_row_tr AFTER DELETE ON #{connection.quote_table_name(::Delayed::Job.table_name)} FOR EACH ROW WHEN (OLD.strand IS NOT NULL AND OLD.next_in_strand = 't') EXECUTE PROCEDURE #{connection.quote_table_name('delayed_jobs_after_delete_row_tr_fn')} ()")
 
-    execute(%{UPDATE #{::Delayed::Job.quoted_table_name} SET next_in_strand = 'f' WHERE strand IS NOT NULL AND id <> (SELECT id FROM #{::Delayed::Job.quoted_table_name} j2 WHERE j2.strand = delayed_jobs.strand ORDER BY j2.strand, j2.id ASC LIMIT 1)})
+    execute(%{UPDATE #{connection.quote_table_name(::Delayed::Job.table_name)} SET next_in_strand = 'f' WHERE strand IS NOT NULL AND id <> (SELECT id FROM #{connection.quote_table_name(::Delayed::Job.table_name)} j2 WHERE j2.strand = delayed_jobs.strand ORDER BY j2.strand, j2.id ASC LIMIT 1)})
   end
 
   def down
-    execute %(DROP TRIGGER delayed_jobs_before_insert_row_tr ON #{::Delayed::Job.quoted_table_name})
+    execute %(DROP TRIGGER delayed_jobs_before_insert_row_tr ON #{connection.quote_table_name(::Delayed::Job.table_name)})
     execute %{DROP FUNCTION #{connection.quote_table_name('delayed_jobs_before_insert_row_tr_fn')} ()}
-    execute %(DROP TRIGGER delayed_jobs_after_delete_row_tr ON #{::Delayed::Job.quoted_table_name})
+    execute %(DROP TRIGGER delayed_jobs_after_delete_row_tr ON #{connection.quote_table_name(::Delayed::Job.table_name)})
     execute %{DROP FUNCTION #{connection.quote_table_name('delayed_jobs_after_delete_row_tr_fn')} ()}
 
     remove_column :delayed_jobs, :next_in_strand

data/db/migrate/20120510004759_delayed_jobs_delete_trigger_lock_for_update.rb

@@ -1,8 +1,4 @@
 class DelayedJobsDeleteTriggerLockForUpdate < ActiveRecord::Migration[4.2]
-  def connection
-    Delayed::Backend::ActiveRecord::AbstractJob.connection
-  end
-
   def up
     if connection.adapter_name == 'PostgreSQL'
       execute(<<-CODE)

data/db/migrate/20120531150712_drop_psql_jobs_pop_fn.rb

@@ -1,8 +1,4 @@
 class DropPsqlJobsPopFn < ActiveRecord::Migration[4.2]
-  def connection
-    Delayed::Backend::ActiveRecord::AbstractJob.connection
-  end
-
   def up
     if connection.adapter_name == 'PostgreSQL'
       connection.execute('DROP FUNCTION IF EXISTS pop_from_delayed_jobs(varchar, varchar, integer, integer, timestamp without time zone)')

data/db/migrate/20120607164022_delayed_jobs_use_advisory_locks.rb

@@ -1,8 +1,4 @@
 class DelayedJobsUseAdvisoryLocks < ActiveRecord::Migration[4.2]
-  def connection
-    Delayed::Backend::ActiveRecord::AbstractJob.connection
-  end
-
   def up
     # use an advisory lock based on the name of the strand, instead of locking the whole table
     # note that we're using half of the md5, so collisions are possible, but we don't really

data/db/migrate/20120607181141_index_jobs_on_locked_by.rb

@@ -1,10 +1,6 @@
 class IndexJobsOnLockedBy < ActiveRecord::Migration[4.2]
   disable_ddl_transaction!
 
-  def connection
-    Delayed::Backend::ActiveRecord::AbstractJob.connection
-  end
-
   def up
     add_index :delayed_jobs, :locked_by, algorithm: :concurrently, where: 'locked_by IS NOT NULL'
   end

data/db/migrate/20120608191051_add_jobs_run_at_index.rb

@@ -1,10 +1,6 @@
 class AddJobsRunAtIndex < ActiveRecord::Migration[4.2]
   disable_ddl_transaction!
 
-  def connection
-    Delayed::Backend::ActiveRecord::AbstractJob.connection
-  end
-
   def up
     add_index :delayed_jobs, %w[run_at tag], algorithm: :concurrently
   end

data/db/migrate/20120927184213_change_delayed_jobs_handler_to_text.rb

@@ -1,8 +1,4 @@
 class ChangeDelayedJobsHandlerToText < ActiveRecord::Migration[4.2]
-  def connection
-    Delayed::Backend::ActiveRecord::AbstractJob.connection
-  end
-
   def up
     change_column :delayed_jobs, :handler, :text
   end

data/db/migrate/20140505215131_add_failed_jobs_original_job_id.rb

@@ -1,8 +1,4 @@
 class AddFailedJobsOriginalJobId < ActiveRecord::Migration[4.2]
-  def connection
-    Delayed::Backend::ActiveRecord::AbstractJob.connection
-  end
-
   def up
     add_column :failed_jobs, :original_job_id, :integer, limit: 8
   end

data/db/migrate/20140505215510_copy_failed_jobs_original_id.rb

@@ -1,11 +1,7 @@
 class CopyFailedJobsOriginalId < ActiveRecord::Migration[4.2]
-  def connection
-    Delayed::Backend::ActiveRecord::AbstractJob.connection
-  end
-
   def up
-    # this is a smaller, less frequently accessed table, so we just update all at once
-    Delayed::Backend::ActiveRecord::Job::Failed.where(original_job_id: nil).update_all('original_job_id = original_id')
+    # Noop since we don't want to modify the shard using a different connection than the one we are using to build it and
+    # this migration is very old
   end
 
   def down; end

data/db/migrate/20140505223637_drop_failed_jobs_original_id.rb

@@ -1,8 +1,4 @@
 class DropFailedJobsOriginalId < ActiveRecord::Migration[4.2]
-  def connection
-    Delayed::Backend::ActiveRecord::AbstractJob.connection
-  end
-
   def up
     remove_column :failed_jobs, :original_id
   end

data/db/migrate/20140512213941_add_source_to_jobs.rb

@@ -1,8 +1,4 @@
 class AddSourceToJobs < ActiveRecord::Migration[4.2]
-  def connection
-    Delayed::Backend::ActiveRecord::AbstractJob.connection
-  end
-
   def up
     add_column :delayed_jobs, :source, :string
     add_column :failed_jobs, :source, :string

data/db/migrate/20150807133223_add_max_concurrent_to_jobs.rb

@@ -1,8 +1,4 @@
 class AddMaxConcurrentToJobs < ActiveRecord::Migration[4.2]
-  def connection
-    Delayed::Backend::ActiveRecord::AbstractJob.connection
-  end
-
   def up
     add_column :delayed_jobs, :max_concurrent, :integer, default: 1, null: false
 

data/db/migrate/20151123210429_add_expires_at_to_jobs.rb

@@ -1,8 +1,4 @@
 class AddExpiresAtToJobs < ActiveRecord::Migration[4.2]
-  def connection
-    Delayed::Backend::ActiveRecord::AbstractJob.connection
-  end
-
   def up
     add_column :delayed_jobs, :expires_at, :datetime
     add_column :failed_jobs, :expires_at, :datetime

data/db/migrate/20151210162949_improve_max_concurrent.rb

@@ -1,8 +1,4 @@
 class ImproveMaxConcurrent < ActiveRecord::Migration[4.2]
-  def connection
-    Delayed::Backend::ActiveRecord::AbstractJob.connection
-  end
-
   def up
     if connection.adapter_name == 'PostgreSQL'
       execute(<<-CODE)

data/db/migrate/20161206323555_add_back_default_string_limits_jobs.rb

@@ -1,8 +1,4 @@
 class AddBackDefaultStringLimitsJobs < ActiveRecord::Migration[4.2]
-  def connection
-    Delayed::Backend::ActiveRecord::AbstractJob.connection
-  end
-
   def up
     drop_triggers
 
@@ -22,13 +18,13 @@ class AddBackDefaultStringLimitsJobs < ActiveRecord::Migration[4.2]
   end
 
   def drop_triggers
-    execute %(DROP TRIGGER delayed_jobs_before_insert_row_tr ON #{::Delayed::Job.quoted_table_name})
-    execute %(DROP TRIGGER delayed_jobs_after_delete_row_tr ON #{::Delayed::Job.quoted_table_name})
+    execute %(DROP TRIGGER delayed_jobs_before_insert_row_tr ON #{connection.quote_table_name(::Delayed::Job.table_name)})
+    execute %(DROP TRIGGER delayed_jobs_after_delete_row_tr ON #{connection.quote_table_name(::Delayed::Job.table_name)})
   end
 
   def readd_triggers
-    execute("CREATE TRIGGER delayed_jobs_before_insert_row_tr BEFORE INSERT ON #{::Delayed::Job.quoted_table_name} FOR EACH ROW WHEN (NEW.strand IS NOT NULL) EXECUTE PROCEDURE #{connection.quote_table_name('delayed_jobs_before_insert_row_tr_fn')}()")
-    execute("CREATE TRIGGER delayed_jobs_after_delete_row_tr AFTER DELETE ON #{::Delayed::Job.quoted_table_name} FOR EACH ROW WHEN (OLD.strand IS NOT NULL AND OLD.next_in_strand = 't') EXECUTE PROCEDURE #{connection.quote_table_name('delayed_jobs_after_delete_row_tr_fn')}()")
+    execute("CREATE TRIGGER delayed_jobs_before_insert_row_tr BEFORE INSERT ON #{connection.quote_table_name(::Delayed::Job.table_name)} FOR EACH ROW WHEN (NEW.strand IS NOT NULL) EXECUTE PROCEDURE #{connection.quote_table_name('delayed_jobs_before_insert_row_tr_fn')}()")
+    execute("CREATE TRIGGER delayed_jobs_after_delete_row_tr AFTER DELETE ON #{connection.quote_table_name(::Delayed::Job.table_name)} FOR EACH ROW WHEN (OLD.strand IS NOT NULL AND OLD.next_in_strand = 't') EXECUTE PROCEDURE #{connection.quote_table_name('delayed_jobs_after_delete_row_tr_fn')}()")
   end
 
   def add_string_limit_if_missing(table, column)

data/db/migrate/20170308045400_add_shard_id_to_delayed_jobs.rb

@@ -1,10 +1,6 @@
 class AddShardIdToDelayedJobs < ActiveRecord::Migration[4.2]
   disable_ddl_transaction!
 
-  def connection
-    Delayed::Backend::ActiveRecord::AbstractJob.connection
-  end
-
   def up
     add_column :delayed_jobs, :shard_id, :integer, limit: 8
     add_index :delayed_jobs, :shard_id, algorithm: :concurrently

data/db/migrate/20181217155351_speed_up_max_concurrent_triggers.rb

@@ -1,8 +1,4 @@
 class SpeedUpMaxConcurrentTriggers < ActiveRecord::Migration[4.2]
-  def connection
-    Delayed::Backend::ActiveRecord::AbstractJob.connection
-  end
-
   def up
     if connection.adapter_name == 'PostgreSQL'
       # tl;dr sacrifice some responsiveness to max_concurrent changes for faster performance

data/db/migrate/20190726154743_make_critical_columns_not_null.rb

@@ -1,8 +1,4 @@
 class MakeCriticalColumnsNotNull < ActiveRecord::Migration[4.2]
-  def connection
-    Delayed::Backend::ActiveRecord::AbstractJob.connection
-  end
-
   def up
     change_column_null :delayed_jobs, :run_at, false
     change_column_null :delayed_jobs, :queue, false

data/db/migrate/20200330230722_add_id_to_get_delayed_jobs_index.rb

@@ -1,10 +1,6 @@
 class AddIdToGetDelayedJobsIndex < ActiveRecord::Migration[4.2]
   disable_ddl_transaction!
 
-  def connection
-    Delayed::Backend::ActiveRecord::AbstractJob.connection
-  end
-
   def up
     rename_index :delayed_jobs, 'get_delayed_jobs_index', 'get_delayed_jobs_index_old'
     add_index :delayed_jobs, %i[queue priority run_at id],

data/db/migrate/20200824222232_speed_up_max_concurrent_delete_trigger.rb

@@ -1,8 +1,4 @@
 class SpeedUpMaxConcurrentDeleteTrigger < ActiveRecord::Migration[4.2]
-  def connection
-    Delayed::Backend::ActiveRecord::AbstractJob.connection
-  end
-
   def up
     if connection.adapter_name == 'PostgreSQL'
       # tl;dr sacrifice some responsiveness to max_concurrent changes for faster performance

data/db/migrate/20200825011002_add_strand_order_override.rb

@@ -1,10 +1,6 @@
 class AddStrandOrderOverride < ActiveRecord::Migration[4.2]
   disable_ddl_transaction!
 
-  def connection
-    Delayed::Backend::ActiveRecord::AbstractJob.connection
-  end
-
   def up
     add_column :delayed_jobs, :strand_order_override, :integer, default: 0, null: false
     add_column :failed_jobs, :strand_order_override, :integer, default: 0, null: false

data/db/migrate/20210812210128_add_singleton_column.rb

@@ -181,20 +181,20 @@ class AddSingletonColumn < ActiveRecord::Migration[5.2]
       reversible do |direction|
         direction.up do
           drop_triggers
-          execute("CREATE TRIGGER delayed_jobs_before_insert_row_tr BEFORE INSERT ON #{::Delayed::Job.quoted_table_name} FOR EACH ROW WHEN (NEW.strand IS NOT NULL OR NEW.singleton IS NOT NULL) EXECUTE PROCEDURE #{connection.quote_table_name('delayed_jobs_before_insert_row_tr_fn')}()")
-          execute("CREATE TRIGGER delayed_jobs_after_delete_row_tr AFTER DELETE ON #{::Delayed::Job.quoted_table_name} FOR EACH ROW WHEN ((OLD.strand IS NOT NULL OR OLD.singleton IS NOT NULL) AND OLD.next_in_strand=true) EXECUTE PROCEDURE #{connection.quote_table_name('delayed_jobs_after_delete_row_tr_fn')}()")
+          execute("CREATE TRIGGER delayed_jobs_before_insert_row_tr BEFORE INSERT ON #{connection.quote_table_name(::Delayed::Job.table_name)} FOR EACH ROW WHEN (NEW.strand IS NOT NULL OR NEW.singleton IS NOT NULL) EXECUTE PROCEDURE #{connection.quote_table_name('delayed_jobs_before_insert_row_tr_fn')}()")
+          execute("CREATE TRIGGER delayed_jobs_after_delete_row_tr AFTER DELETE ON #{connection.quote_table_name(::Delayed::Job.table_name)} FOR EACH ROW WHEN ((OLD.strand IS NOT NULL OR OLD.singleton IS NOT NULL) AND OLD.next_in_strand=true) EXECUTE PROCEDURE #{connection.quote_table_name('delayed_jobs_after_delete_row_tr_fn')}()")
         end
         direction.down do
           drop_triggers
-          execute("CREATE TRIGGER delayed_jobs_before_insert_row_tr BEFORE INSERT ON #{::Delayed::Job.quoted_table_name} FOR EACH ROW WHEN (NEW.strand IS NOT NULL) EXECUTE PROCEDURE #{connection.quote_table_name('delayed_jobs_before_insert_row_tr_fn')}()")
-          execute("CREATE TRIGGER delayed_jobs_after_delete_row_tr AFTER DELETE ON #{::Delayed::Job.quoted_table_name} FOR EACH ROW WHEN (OLD.strand IS NOT NULL AND OLD.next_in_strand = 't') EXECUTE PROCEDURE #{connection.quote_table_name('delayed_jobs_after_delete_row_tr_fn()')}")
+          execute("CREATE TRIGGER delayed_jobs_before_insert_row_tr BEFORE INSERT ON #{connection.quote_table_name(::Delayed::Job.table_name)} FOR EACH ROW WHEN (NEW.strand IS NOT NULL) EXECUTE PROCEDURE #{connection.quote_table_name('delayed_jobs_before_insert_row_tr_fn')}()")
+          execute("CREATE TRIGGER delayed_jobs_after_delete_row_tr AFTER DELETE ON #{connection.quote_table_name(::Delayed::Job.table_name)} FOR EACH ROW WHEN (OLD.strand IS NOT NULL AND OLD.next_in_strand = 't') EXECUTE PROCEDURE #{connection.quote_table_name('delayed_jobs_after_delete_row_tr_fn()')}")
         end
       end
     end
   end
 
   def drop_triggers
-    execute("DROP TRIGGER delayed_jobs_before_insert_row_tr ON #{::Delayed::Job.quoted_table_name}")
-    execute("DROP TRIGGER delayed_jobs_after_delete_row_tr ON #{::Delayed::Job.quoted_table_name}")
+    execute("DROP TRIGGER delayed_jobs_before_insert_row_tr ON #{connection.quote_table_name(::Delayed::Job.table_name)}")
+    execute("DROP TRIGGER delayed_jobs_after_delete_row_tr ON #{connection.quote_table_name(::Delayed::Job.table_name)}")
   end
 end

data/db/migrate/20210917232626_add_delete_conflicting_singletons_before_unlock_trigger.rb

@@ -13,7 +13,7 @@ class AddDeleteConflictingSingletonsBeforeUnlockTrigger < ActiveRecord::Migratio
       $$ LANGUAGE plpgsql SET search_path TO #{::Switchman::Shard.current.name};
     SQL
     execute(<<~SQL)
-      CREATE TRIGGER delayed_jobs_before_unlock_delete_conflicting_singletons_row_tr BEFORE UPDATE ON #{::Delayed::Job.quoted_table_name} FOR EACH ROW WHEN (
+      CREATE TRIGGER delayed_jobs_before_unlock_delete_conflicting_singletons_row_tr BEFORE UPDATE ON #{connection.quote_table_name(::Delayed::Job.table_name)} FOR EACH ROW WHEN (
         OLD.singleton IS NOT NULL AND
         OLD.singleton=NEW.singleton AND
         OLD.locked_by IS NOT NULL AND

data/db/migrate/20211220112800_fix_singleton_race_condition_insert.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+class FixSingletonRaceConditionInsert < ActiveRecord::Migration[5.2]
+  def change
+    reversible do |direction|
+      direction.up do
+        execute(<<~SQL)
+          CREATE OR REPLACE FUNCTION #{connection.quote_table_name('delayed_jobs_before_insert_row_tr_fn')} () RETURNS trigger AS $$
+          BEGIN
+            IF NEW.strand IS NOT NULL THEN
+              PERFORM pg_advisory_xact_lock(half_md5_as_bigint(NEW.strand));
+              IF (SELECT COUNT(*) FROM (
+                  SELECT 1 FROM delayed_jobs WHERE strand = NEW.strand AND next_in_strand=true LIMIT NEW.max_concurrent
+                ) s) = NEW.max_concurrent THEN
+                NEW.next_in_strand := false;
+              END IF;
+            END IF;
+            IF NEW.singleton IS NOT NULL THEN
+              PERFORM pg_advisory_xact_lock(half_md5_as_bigint(CONCAT('singleton:', NEW.singleton)));
+              -- this condition seems silly, but it forces postgres to use the two partial indexes on singleton,
+              -- rather than doing a seq scan
+              PERFORM 1 FROM delayed_jobs WHERE singleton = NEW.singleton AND (locked_by IS NULL OR locked_by IS NOT NULL);
+              IF FOUND THEN
+                NEW.next_in_strand := false;
+              END IF;
+            END IF;
+            RETURN NEW;
+          END;
+          $$ LANGUAGE plpgsql SET search_path TO #{::Switchman::Shard.current.name};
+        SQL
+      end
+      direction.down do
+        execute(<<~SQL)
+          CREATE OR REPLACE FUNCTION #{connection.quote_table_name('delayed_jobs_before_insert_row_tr_fn')} () RETURNS trigger AS $$
+          BEGIN
+            IF NEW.strand IS NOT NULL THEN
+              PERFORM pg_advisory_xact_lock(half_md5_as_bigint(NEW.strand));
+              IF (SELECT COUNT(*) FROM (
+                  SELECT 1 FROM delayed_jobs WHERE strand = NEW.strand AND next_in_strand=true LIMIT NEW.max_concurrent
+                ) s) = NEW.max_concurrent THEN
+                NEW.next_in_strand := false;
+              END IF;
+            END IF;
+            IF NEW.singleton IS NOT NULL THEN
+              -- this condition seems silly, but it forces postgres to use the two partial indexes on singleton,
+              -- rather than doing a seq scan
+              PERFORM 1 FROM delayed_jobs WHERE singleton = NEW.singleton AND (locked_by IS NULL OR locked_by IS NOT NULL);
+              IF FOUND THEN
+                NEW.next_in_strand := false;
+              END IF;
+            END IF;
+            RETURN NEW;
+          END;
+          $$ LANGUAGE plpgsql SET search_path TO #{::Switchman::Shard.current.name};
+        SQL
+      end
+    end
+  end
+end