inst-jobs 2.2.1 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9550c353f31dc1d34a15993bdfbf279d87979ebb625ae776fb6727d7dc9e897e
-  data.tar.gz: 379f8faac5d3369551b4012a00f522d7871a4001776120c4e02535b70bdef8a3
+  metadata.gz: 02cb2ab5274e3a6616a74bb75cc8c74cd767c850cfb5451931e08ff582096238
+  data.tar.gz: 045a1caa153d01bb8f9ec756bb53777efe564597822d71e58652ef4a86e6a2d5
 SHA512:
-  metadata.gz: 4dbb7a9366256f16a0fd7fbf22938d94c7754cdd3d9189d3d7d94e0d8deda59859ec4822f1e3c1d05cc7a2a67c8501a79c83d7b0b69f91fd106d9b24b4f35b06
-  data.tar.gz: 637e09a985feeef6144e5b172a04c8ceee5980eed3b1b49f2597e33bbf26522c43244bc2778905ba400cf0de6485166258103e09aa7a765e261f8971b89b2c06
+  metadata.gz: 5be013e7266ffad6f13bfb0020adf1f8c1b7cae8041bcb03e2840f1c9073de265f61ed2054434faa8abcb33f0ce3c89e800b941fa6c107f005a254a1cdf4fc3b
+  data.tar.gz: 49b689debce5e7bb40313905ded5af1b7232c4a2224e2e42f1637902d66c9e4ddadd64139d48593a78a54afbe539451f16708df43067efcabd1997c433ecd7e5

data/db/migrate/20101216224513_create_delayed_jobs.rb

@@ -6,19 +6,21 @@ class CreateDelayedJobs < ActiveRecord::Migration[4.2]
   end
 
   def up
-    raise("#{connection.adapter_name} is not supported for delayed jobs queue") unless connection.adapter_name == 'PostgreSQL'
+    unless connection.adapter_name == "PostgreSQL"
+      raise("#{connection.adapter_name} is not supported for delayed jobs queue")
+    end
 
     create_table :delayed_jobs do |table|
       # Allows some jobs to jump to the front of the queue
-      table.integer  :priority, :default => 0
+      table.integer  :priority, default: 0
       # Provides for retries, but still fail eventually.
-      table.integer  :attempts, :default => 0
+      table.integer  :attempts, default: 0
       # YAML-encoded string of the object that will do work
-      table.text     :handler, :limit => (500 * 1024)
+      table.text     :handler, limit: (500 * 1024)
       # reason for last failure (See Note below)
       table.text     :last_error
       # The queue that this job is in
-      table.string   :queue, :default => nil
+      table.string   :queue, default: nil
       # When to run.
       # Could be Time.zone.now for immediately, or sometime in the future.
       table.datetime :run_at
@@ -32,8 +34,8 @@ class CreateDelayedJobs < ActiveRecord::Migration[4.2]
       table.timestamps
     end
 
-    add_index :delayed_jobs, [:priority, :run_at], :name => 'delayed_jobs_priority'
-    add_index :delayed_jobs, [:queue], :name => 'delayed_jobs_queue'
+    add_index :delayed_jobs, %i[priority run_at], name: "delayed_jobs_priority"
+    add_index :delayed_jobs, [:queue], name: "delayed_jobs_queue"
   end
 
   def down

data/db/migrate/20110531144916_cleanup_delayed_jobs_indexes.rb

@@ -6,23 +6,18 @@ class CleanupDelayedJobsIndexes < ActiveRecord::Migration[4.2]
   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_jobs (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
+    # "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_jobs (priority, run_at, failed_at nulls first, locked_at nulls first, queue)")
 
     # unused indexes
-    remove_index :delayed_jobs, :name => 'delayed_jobs_queue'
-    remove_index :delayed_jobs, :name => 'delayed_jobs_priority'
+    remove_index :delayed_jobs, name: "delayed_jobs_queue"
+    remove_index :delayed_jobs, name: "delayed_jobs_priority"
   end
 
   def down
-    remove_index :delayed_jobs, :name => 'get_delayed_jobs_index'
-    add_index :delayed_jobs, [:priority, :run_at], :name => 'delayed_jobs_priority'
-    add_index :delayed_jobs, [:queue], :name => 'delayed_jobs_queue'
+    remove_index :delayed_jobs, name: "get_delayed_jobs_index"
+    add_index :delayed_jobs, %i[priority run_at], name: "delayed_jobs_priority"
+    add_index :delayed_jobs, [:queue], name: "delayed_jobs_queue"
   end
 end

data/db/migrate/20110610213249_optimize_delayed_jobs.rb

@@ -7,10 +7,10 @@ class OptimizeDelayedJobs < ActiveRecord::Migration[4.2]
 
   def up
     create_table :failed_jobs do |t|
-      t.integer  "priority",    :default => 0
-      t.integer  "attempts",    :default => 0
-      t.string   "handler",     :limit => 512000
-      t.integer  "original_id", :limit => 8
+      t.integer  "priority",    default: 0
+      t.integer  "attempts",    default: 0
+      t.string   "handler",     limit: 512_000
+      t.integer  "original_id", limit: 8
       t.text     "last_error"
       t.string   "queue"
       t.datetime "run_at"
@@ -24,14 +24,14 @@ class OptimizeDelayedJobs < ActiveRecord::Migration[4.2]
       t.string   "strand"
     end
 
-    remove_index :delayed_jobs, :name => 'get_delayed_jobs_index'
+    remove_index :delayed_jobs, name: "get_delayed_jobs_index"
     remove_index :delayed_jobs, [:strand]
 
-    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'
+    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("failed_at IS NOT NULL").find_each do |job|
+    Delayed::Backend::ActiveRecord::Job.where.not(failed_at: nil).find_each do |job|
       job.fail! unless job.on_hold?
     end
   end

data/db/migrate/20110831210257_add_delayed_jobs_next_in_strand.rb

@@ -6,49 +6,49 @@ class AddDelayedJobsNextInStrand < ActiveRecord::Migration[4.2]
   end
 
   def up
-    remove_index :delayed_jobs, :name => 'index_delayed_jobs_for_get_next'
+    remove_index :delayed_jobs, name: "index_delayed_jobs_for_get_next"
 
-    add_column :delayed_jobs, :next_in_strand, :boolean, :default => true, :null => false
+    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_jobs (priority, run_at, queue) WHERE locked_at IS NULL AND next_in_strand = 't'")
 
     # create the insert trigger
-    execute(<<-CODE)
-    CREATE FUNCTION delayed_jobs_before_insert_row_tr_fn () RETURNS trigger AS $$
-    BEGIN
-      LOCK delayed_jobs IN SHARE ROW EXCLUSIVE MODE;
-      IF (SELECT 1 FROM delayed_jobs WHERE strand = NEW.strand LIMIT 1) = 1 THEN
-        NEW.next_in_strand := 'f';
-      END IF;
-      RETURN NEW;
-    END;
-    $$ LANGUAGE plpgsql;
-    CODE
+    execute(<<~SQL)
+      CREATE FUNCTION delayed_jobs_before_insert_row_tr_fn () RETURNS trigger AS $$
+      BEGIN
+        LOCK delayed_jobs IN SHARE ROW EXCLUSIVE MODE;
+        IF (SELECT 1 FROM delayed_jobs WHERE strand = NEW.strand LIMIT 1) = 1 THEN
+          NEW.next_in_strand := 'f';
+        END IF;
+        RETURN NEW;
+      END;
+      $$ LANGUAGE plpgsql;
+    SQL
     execute("CREATE TRIGGER delayed_jobs_before_insert_row_tr BEFORE INSERT ON delayed_jobs FOR EACH ROW WHEN (NEW.strand IS NOT NULL) EXECUTE PROCEDURE delayed_jobs_before_insert_row_tr_fn()")
 
     # create the delete trigger
-    execute(<<-CODE)
-    CREATE FUNCTION delayed_jobs_after_delete_row_tr_fn () RETURNS trigger AS $$
-    BEGIN
-      UPDATE delayed_jobs SET next_in_strand = 't' WHERE id = (SELECT id FROM delayed_jobs j2 WHERE j2.strand = OLD.strand ORDER BY j2.strand, j2.id ASC LIMIT 1);
-      RETURN OLD;
-    END;
-    $$ LANGUAGE plpgsql;
-    CODE
+    execute(<<~SQL)
+      CREATE FUNCTION delayed_jobs_after_delete_row_tr_fn () RETURNS trigger AS $$
+      BEGIN
+        UPDATE delayed_jobs SET next_in_strand = 't' WHERE id = (SELECT id FROM delayed_jobs j2 WHERE j2.strand = OLD.strand ORDER BY j2.strand, j2.id ASC LIMIT 1);
+        RETURN OLD;
+      END;
+      $$ LANGUAGE plpgsql;
+    SQL
     execute("CREATE TRIGGER delayed_jobs_after_delete_row_tr AFTER DELETE ON delayed_jobs FOR EACH ROW WHEN (OLD.strand IS NOT NULL AND OLD.next_in_strand = 't') EXECUTE PROCEDURE delayed_jobs_after_delete_row_tr_fn()")
 
     execute(%{UPDATE delayed_jobs SET next_in_strand = 'f' WHERE strand IS NOT NULL AND id <> (SELECT id FROM delayed_jobs 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_jobs}
+    execute %(DROP TRIGGER delayed_jobs_before_insert_row_tr ON delayed_jobs)
     execute %{DROP FUNCTION delayed_jobs_before_insert_row_tr_fn()}
-    execute %{DROP TRIGGER delayed_jobs_after_delete_row_tr ON delayed_jobs}
+    execute %(DROP TRIGGER delayed_jobs_after_delete_row_tr ON delayed_jobs)
     execute %{DROP FUNCTION delayed_jobs_after_delete_row_tr_fn()}
 
     remove_column :delayed_jobs, :next_in_strand
-    remove_index :delayed_jobs, :name => 'get_delayed_jobs_index'
-    add_index :delayed_jobs, %w(run_at queue locked_at strand priority), :name => 'index_delayed_jobs_for_get_next'
+    remove_index :delayed_jobs, name: "get_delayed_jobs_index"
+    add_index :delayed_jobs, %w[run_at queue locked_at strand priority], name: "index_delayed_jobs_for_get_next"
   end
 end

data/db/migrate/20120510004759_delayed_jobs_delete_trigger_lock_for_update.rb

@@ -6,28 +6,24 @@ class DelayedJobsDeleteTriggerLockForUpdate < ActiveRecord::Migration[4.2]
   end
 
   def up
-    if connection.adapter_name == 'PostgreSQL'
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_after_delete_row_tr_fn () RETURNS trigger AS $$
       BEGIN
         UPDATE delayed_jobs SET next_in_strand = 't' WHERE id = (SELECT id FROM delayed_jobs j2 WHERE j2.strand = OLD.strand ORDER BY j2.strand, j2.id ASC LIMIT 1 FOR UPDATE);
         RETURN OLD;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
-    end
+    SQL
   end
 
   def down
-    if connection.adapter_name == 'PostgreSQL'
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_after_delete_row_tr_fn () RETURNS trigger AS $$
       BEGIN
         UPDATE delayed_jobs SET next_in_strand = 't' WHERE id = (SELECT id FROM delayed_jobs j2 WHERE j2.strand = OLD.strand ORDER BY j2.strand, j2.id ASC LIMIT 1);
         RETURN OLD;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
-    end
+    SQL
   end
 end

data/db/migrate/20120531150712_drop_psql_jobs_pop_fn.rb

@@ -6,9 +6,7 @@ class DropPsqlJobsPopFn < ActiveRecord::Migration[4.2]
   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)")
-    end
+    connection.execute("DROP FUNCTION IF EXISTS pop_from_delayed_jobs(varchar, varchar, integer, integer, timestamp without time zone)")
   end
 
   def down

data/db/migrate/20120607164022_delayed_jobs_use_advisory_locks.rb

@@ -10,8 +10,7 @@ class DelayedJobsUseAdvisoryLocks < ActiveRecord::Migration[4.2]
     # note that we're using half of the md5, so collisions are possible, but we don't really
     # care because that would just be the old behavior, whereas for the most part locking will
     # be much smaller
-    if connection.adapter_name == 'PostgreSQL'
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE FUNCTION half_md5_as_bigint(strand varchar) RETURNS bigint AS $$
       DECLARE
         strand_md5 bytea;
@@ -27,9 +26,9 @@ class DelayedJobsUseAdvisoryLocks < ActiveRecord::Migration[4.2]
                                    get_byte(strand_md5, 7);
       END;
       $$ LANGUAGE plpgsql;
-      CODE
+    SQL
 
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_before_insert_row_tr_fn () RETURNS trigger AS $$
       BEGIN
         PERFORM pg_advisory_xact_lock(half_md5_as_bigint(NEW.strand));
@@ -39,9 +38,9 @@ class DelayedJobsUseAdvisoryLocks < ActiveRecord::Migration[4.2]
         RETURN NEW;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
+    SQL
 
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_after_delete_row_tr_fn () RETURNS trigger AS $$
       BEGIN
         PERFORM pg_advisory_xact_lock(half_md5_as_bigint(OLD.strand));
@@ -49,13 +48,11 @@ class DelayedJobsUseAdvisoryLocks < ActiveRecord::Migration[4.2]
         RETURN OLD;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
-    end
+    SQL
   end
 
   def down
-    if connection.adapter_name == 'PostgreSQL'
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_before_insert_row_tr_fn () RETURNS trigger AS $$
       BEGIN
         LOCK delayed_jobs IN SHARE ROW EXCLUSIVE MODE;
@@ -65,18 +62,17 @@ class DelayedJobsUseAdvisoryLocks < ActiveRecord::Migration[4.2]
         RETURN NEW;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
+    SQL
 
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_after_delete_row_tr_fn () RETURNS trigger AS $$
       BEGIN
         UPDATE delayed_jobs SET next_in_strand = 't' WHERE id = (SELECT id FROM delayed_jobs j2 WHERE j2.strand = OLD.strand ORDER BY j2.strand, j2.id ASC LIMIT 1 FOR UPDATE);
         RETURN OLD;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
+    SQL
 
-      execute('DROP FUNCTION half_md5_as_bigint(varchar)')
-    end
+    execute("DROP FUNCTION half_md5_as_bigint(varchar)")
   end
 end

data/db/migrate/20120607181141_index_jobs_on_locked_by.rb

@@ -8,7 +8,7 @@ class IndexJobsOnLockedBy < ActiveRecord::Migration[4.2]
   end
 
   def up
-    add_index :delayed_jobs, :locked_by, :algorithm => :concurrently, :where => "locked_by IS NOT NULL"
+    add_index :delayed_jobs, :locked_by, algorithm: :concurrently, where: "locked_by IS NOT NULL"
   end
 
   def down

data/db/migrate/20120608191051_add_jobs_run_at_index.rb

@@ -8,10 +8,10 @@ class AddJobsRunAtIndex < ActiveRecord::Migration[4.2]
   end
 
   def up
-    add_index :delayed_jobs, %w[run_at tag], :algorithm => :concurrently
+    add_index :delayed_jobs, %w[run_at tag], algorithm: :concurrently
   end
 
   def down
-    remove_index :delayed_jobs, :name => "index_delayed_jobs_on_run_at_and_tag"
+    remove_index :delayed_jobs, name: "index_delayed_jobs_on_run_at_and_tag"
   end
 end

data/db/migrate/20120927184213_change_delayed_jobs_handler_to_text.rb

@@ -10,6 +10,6 @@ class ChangeDelayedJobsHandlerToText < ActiveRecord::Migration[4.2]
   end
 
   def down
-    change_column :delayed_jobs, :handler, :string, :limit => 500.kilobytes
+    change_column :delayed_jobs, :handler, :string, limit: 500.kilobytes
   end
 end

data/db/migrate/20140505215510_copy_failed_jobs_original_id.rb

@@ -7,9 +7,8 @@ class CopyFailedJobsOriginalId < ActiveRecord::Migration[4.2]
 
   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 is null").update_all("original_job_id = original_id")
+    Delayed::Backend::ActiveRecord::Job::Failed.where(original_job_id: nil).update_all("original_job_id = original_id")
   end
 
-  def down
-  end
+  def down; end
 end

data/db/migrate/20150807133223_add_max_concurrent_to_jobs.rb

@@ -6,10 +6,9 @@ class AddMaxConcurrentToJobs < ActiveRecord::Migration[4.2]
   end
 
   def up
-    add_column :delayed_jobs, :max_concurrent, :integer, :default => 1, :null => false
+    add_column :delayed_jobs, :max_concurrent, :integer, default: 1, null: false
 
-    if connection.adapter_name == 'PostgreSQL'
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_before_insert_row_tr_fn () RETURNS trigger AS $$
       BEGIN
         IF NEW.strand IS NOT NULL THEN
@@ -21,9 +20,9 @@ class AddMaxConcurrentToJobs < ActiveRecord::Migration[4.2]
         RETURN NEW;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
+    SQL
 
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_after_delete_row_tr_fn () RETURNS trigger AS $$
       BEGIN
         IF OLD.strand IS NOT NULL THEN
@@ -38,15 +37,13 @@ class AddMaxConcurrentToJobs < ActiveRecord::Migration[4.2]
         RETURN OLD;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
-    end
+    SQL
   end
 
   def down
     remove_column :delayed_jobs, :max_concurrent
 
-    if connection.adapter_name == 'PostgreSQL'
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_before_insert_row_tr_fn () RETURNS trigger AS $$
       BEGIN
         PERFORM pg_advisory_xact_lock(half_md5_as_bigint(NEW.strand));
@@ -56,9 +53,9 @@ class AddMaxConcurrentToJobs < ActiveRecord::Migration[4.2]
         RETURN NEW;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
+    SQL
 
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_after_delete_row_tr_fn () RETURNS trigger AS $$
       BEGIN
         PERFORM pg_advisory_xact_lock(half_md5_as_bigint(OLD.strand));
@@ -66,7 +63,6 @@ class AddMaxConcurrentToJobs < ActiveRecord::Migration[4.2]
         RETURN OLD;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
-    end
+    SQL
   end
 end

data/db/migrate/20151210162949_improve_max_concurrent.rb

@@ -6,8 +6,7 @@ class ImproveMaxConcurrent < ActiveRecord::Migration[4.2]
   end
 
   def up
-    if connection.adapter_name == 'PostgreSQL'
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_after_delete_row_tr_fn () RETURNS trigger AS $$
       DECLARE
         running_count integer;
@@ -25,13 +24,11 @@ class ImproveMaxConcurrent < ActiveRecord::Migration[4.2]
         RETURN OLD;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
-    end
+    SQL
   end
 
   def down
-    if connection.adapter_name == 'PostgreSQL'
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_after_delete_row_tr_fn () RETURNS trigger AS $$
       BEGIN
         IF OLD.strand IS NOT NULL THEN
@@ -46,7 +43,6 @@ class ImproveMaxConcurrent < ActiveRecord::Migration[4.2]
         RETURN OLD;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
-    end
+    SQL
   end
 end