inst-jobs 2.4.3 → 2.4.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a5cde929174dd49e07d06025310bcea4cb0a6b55b3d83a40ea7b7bde9c9b775
-  data.tar.gz: 1028828aa017afc111c89f410425a58939c42697066279b7a22174463384d1f1
+  metadata.gz: 48186ffba65e38c8e10702a68c93d9b4bb7f8ea13f98a7175e6755a1e693595f
+  data.tar.gz: 8a6e51516ffeaaa31d8b3bcb07a25e859259b9e734c5a8e14af019d842a01ed7
 SHA512:
-  metadata.gz: ba08cb3d2e9ff3a72bdaf8c47d9265cc21a7bfd401b1657349c12043852955ac3c7e02d52c1ef1ab602207cbcc35e48e7293c77fceb34f12aec660d9e9638a7f
-  data.tar.gz: d86f8ead17b6ddc679350dc9b9e5ee52a2ffc5b8ad62be52e5f375a28e0ccd9b9a1a6aad5255e08273a26fa9ed0d90a31afd618caee5e0378adf5481494bdc78
+  metadata.gz: 385dcba329c82516cc6ac3b17aa7254cb427fce7d964c40c20ddd64c73a04af0cc687e4626e0dc2af890bf10ef1ec534f355e0dc8203416120c36ec453a9eb71
+  data.tar.gz: 42c9316bb0ab5ad237fb70719ddbfa9ba9dc7f4b8dfd75b13880e7be228f9a03b566eb94c0771bdd6672f92919b5c79db4dafd041b1194a3cd4a829a96c006c4

data/db/migrate/20210917232626_add_delete_conflicting_singletons_before_unlock_trigger.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class AddDeleteConflictingSingletonsBeforeUnlockTrigger < ActiveRecord::Migration[5.2]
+  def up
+    execute(<<~SQL)
+      CREATE FUNCTION delayed_jobs_before_unlock_delete_conflicting_singletons_row_fn () RETURNS trigger AS $$
+      BEGIN
+        IF EXISTS (SELECT 1 FROM delayed_jobs j2 WHERE j2.singleton=OLD.singleton) THEN
+          DELETE FROM delayed_jobs WHERE id<>OLD.id AND singleton=OLD.singleton;
+        END IF;
+        RETURN NEW;
+      END;
+      $$ LANGUAGE plpgsql;
+    SQL
+    execute(<<~SQL)
+      CREATE TRIGGER delayed_jobs_before_unlock_delete_conflicting_singletons_row_tr BEFORE UPDATE ON delayed_jobs FOR EACH ROW WHEN (
+        OLD.singleton IS NOT NULL AND
+        OLD.singleton=NEW.singleton AND
+        OLD.locked_by IS NOT NULL AND
+        NEW.locked_by IS NULL) EXECUTE PROCEDURE delayed_jobs_before_unlock_delete_conflicting_singletons_row_fn();
+    SQL
+  end
+
+  def down
+    execute("DROP FUNCTION delayed_jobs_before_unlock_delete_conflicting_singletons_row_tr_fn()")
+  end
+end

data/lib/delayed/backend/active_record.rb

@@ -38,6 +38,16 @@ module Delayed
             job = new(attributes, &block)
             job.single_step_create(on_conflict: on_conflict)
           end
+
+          def attempt_advisory_lock(lock_name)
+            fn_name = connection.quote_table_name("half_md5_as_bigint")
+            connection.select_value("SELECT pg_try_advisory_xact_lock(#{fn_name}('#{lock_name}'));")
+          end
+
+          def advisory_lock(lock_name)
+            fn_name = connection.quote_table_name("half_md5_as_bigint")
+            connection.execute("SELECT pg_advisory_xact_lock(#{fn_name}('#{lock_name}'));")
+          end
         end
 
         def single_step_create(on_conflict: nil)
@@ -98,11 +108,11 @@ module Delayed
               fn_name = connection.quote_table_name("half_md5_as_bigint")
               sql = "SELECT pg_advisory_xact_lock(#{fn_name}(#{connection.quote(values['strand'])})); #{sql}"
             end
-            result = connection.execute(sql, "#{self} Create")
+            result = connection.execute(sql, "#{self.class} Create")
             self.id = result.values.first&.first
             result.clear
           else
-            result = connection.exec_query(sql, "#{self} Create", binds)
+            result = connection.exec_query(sql, "#{self.class} Create", binds)
             self.id = connection.send(:last_inserted_id, result)
           end
 
@@ -458,9 +468,19 @@ module Delayed
           where("locked_by LIKE ?", "#{name}:%").pluck(:locked_by).map { |locked_by| locked_by.split(":").last.to_i }
         end
 
+        def self.prefetch_jobs_lock_name
+          "Delayed::Job.unlock_orphaned_prefetched_jobs"
+        end
+
         def self.unlock_orphaned_prefetched_jobs
-          horizon = db_time_now - (Settings.parent_process[:prefetched_jobs_timeout] * 4)
-          where("locked_by LIKE 'prefetch:%' AND locked_at<?", horizon).update_all(locked_at: nil, locked_by: nil)
+          transaction do
+            # for db performance reasons, we only need one process doing this at a time
+            # so if we can't get an advisory lock, just abort. we'll try again soon
+            return unless attempt_advisory_lock(prefetch_jobs_lock_name)
+
+            horizon = db_time_now - (Settings.parent_process[:prefetched_jobs_timeout] * 4)
+            where("locked_by LIKE 'prefetch:%' AND locked_at<?", horizon).update_all(locked_at: nil, locked_by: nil)
+          end
         end
 
         def self.unlock(jobs)

data/lib/delayed/periodic.rb

@@ -33,7 +33,13 @@ module Delayed
       # we used to queue up a job in a strand here, and perform the audit inside that job
       # however, now that we're using singletons for scheduling periodic jobs,
       # it's fine to just do the audit in-line here without risk of creating duplicates
-      perform_audit!
+      Delayed::Job.transaction do
+        # for db performance reasons, we only need one process doing this at a time
+        # so if we can't get an advisory lock, just abort. we'll try again soon
+        return unless Delayed::Job.attempt_advisory_lock("Delayed::Periodic#audit_queue")
+
+        perform_audit!
+      end
     end
 
     # make sure all periodic jobs are scheduled for their next run in the job queue

data/lib/delayed/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Delayed
-  VERSION = "2.4.3"
+  VERSION = "2.4.7"
 end

data/lib/delayed/work_queue/parent_process/server.rb

@@ -195,11 +195,13 @@ module Delayed
         def unlock_timed_out_prefetched_jobs
           @prefetched_jobs.each do |(worker_config, jobs)|
             next if jobs.empty?
+            next unless jobs.first.locked_at < Time.now.utc - Settings.parent_process[:prefetched_jobs_timeout]
 
-            if jobs.first.locked_at < Time.now.utc - Settings.parent_process[:prefetched_jobs_timeout]
+            Delayed::Job.transaction do
+              Delayed::Job.advisory_lock(Delayed::Job.prefetch_jobs_lock_name)
               Delayed::Job.unlock(jobs)
-              @prefetched_jobs[worker_config] = []
             end
+            @prefetched_jobs[worker_config] = []
           end
         end
 
@@ -207,7 +209,10 @@ module Delayed
           @prefetched_jobs.each do |(_worker_config, jobs)|
             next if jobs.empty?
 
-            Delayed::Job.unlock(jobs)
+            Delayed::Job.transaction do
+              Delayed::Job.advisory_lock(Delayed::Job.prefetch_jobs_lock_name)
+              Delayed::Job.unlock(jobs)
+            end
           end
           @prefetched_jobs = {}
         end

data/lib/delayed/worker/health_check.rb

@@ -33,7 +33,7 @@ module Delayed
             # and we try to get an advisory lock when it runs.  If we succeed,
             # no other worker is trying to do this right now (and if we abandon the
             # operation, the transaction will end, releasing the advisory lock).
-            result = attempt_advisory_lock
+            result = Delayed::Job.attempt_advisory_lock("Delayed::Worker::HealthCheck#reschedule_abandoned_jobs")
             return unless result
 
             checker = Worker::HealthCheck.build(
@@ -65,13 +65,6 @@ module Delayed
             end
           end
         end
-
-        def attempt_advisory_lock
-          lock_name = "Delayed::Worker::HealthCheck#reschedule_abandoned_jobs"
-          conn = ActiveRecord::Base.connection
-          fn_name = conn.quote_table_name("half_md5_as_bigint")
-          conn.select_value("SELECT pg_try_advisory_xact_lock(#{fn_name}('#{lock_name}'));")
-        end
       end
 
       attr_accessor :config, :worker_name

data/spec/delayed/worker/health_check_spec.rb

@@ -111,7 +111,7 @@ RSpec.describe Delayed::Worker::HealthCheck do
     end
 
     it "bails immediately if advisory lock already taken" do
-      allow(described_class).to receive(:attempt_advisory_lock).and_return(false)
+      allow(Delayed::Job).to receive(:attempt_advisory_lock).and_return(false)
       described_class.reschedule_abandoned_jobs
       @dead_job.reload
       expect(@dead_job.run_at.to_i).to eq(initial_run_at.to_i)

data/spec/shared/shared_backend.rb

@@ -491,6 +491,19 @@ shared_examples_for "a backend" do
           expect(@job2).to be_new_record
         end
       end
+
+      context "when unlocking with another singleton pending" do
+        it "deletes the pending singleton" do
+          @job1 = create_job(singleton: "myjobs", max_attempts: 2)
+          expect(Delayed::Job.get_and_lock_next_available("w1")).to eq(@job1)
+
+          @job2 = create_job(singleton: "myjobs", max_attempts: 2)
+
+          @job1.reload.reschedule
+          expect { @job1.reload }.not_to raise_error
+          expect { @job2.reload }.to raise_error(ActiveRecord::RecordNotFound)
+        end
+      end
     end
   end
 

data/spec/spec_helper.rb

@@ -4,6 +4,7 @@ require "delayed_job"
 require "delayed/testing"
 
 require "database_cleaner"
+require "fileutils"
 require "rack/test"
 require "timecop"
 require "webmock/rspec"
@@ -80,7 +81,8 @@ Delayed::Backend::ActiveRecord::Job.reset_column_information
 Delayed::Backend::ActiveRecord::Job::Failed.reset_column_information
 
 Time.zone = "UTC" # rubocop:disable Rails/TimeZoneAssignment
-Rails.logger = Logger.new(nil)
+FileUtils.mkdir_p("tmp")
+ActiveRecord::Base.logger = Rails.logger = Logger.new("tmp/test.log")
 
 # Purely useful for test cases...
 class Story < ActiveRecord::Base

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: inst-jobs
 version: !ruby/object:Gem::Version
-  version: 2.4.3
+  version: 2.4.7
 platform: ruby
 authors:
 - Tobias Luetke
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-09-17 00:00:00.000000000 Z
+date: 2021-09-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -431,6 +431,7 @@ files:
 - db/migrate/20200825011002_add_strand_order_override.rb
 - db/migrate/20210809145804_add_n_strand_index.rb
 - db/migrate/20210812210128_add_singleton_column.rb
+- db/migrate/20210917232626_add_delete_conflicting_singletons_before_unlock_trigger.rb
 - exe/inst_jobs
 - lib/delayed/backend/active_record.rb
 - lib/delayed/backend/base.rb
@@ -511,7 +512,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.16
+rubygems_version: 3.2.24
 signing_key:
 specification_version: 4
 summary: Instructure-maintained fork of delayed_job