resque-multi-job-forks 0.5.0 → 0.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 2bd1e8435173c27eefcab09cdc99cba876698404
-  data.tar.gz: 96f8db0967c05a3104fc48e78fa49f5a0c5c4e79
+SHA256:
+  metadata.gz: 142ac780146f82b8ab449daa58bfcb1319f113207045b9c94d6d81595e9dd399
+  data.tar.gz: fcaf1e33dc1aefae61e4a44f1cbab884635d266f9dbaed0fdcc8c9e458a0b720
 SHA512:
-  metadata.gz: 91ffc7a44dcb0353754bcc96410ed3d4c4701d3176427dfa8b626d5b6a3af3eb1ce3a1d5e8a6f5d39809e661de98121ba39d6d08fd17b5d550adb0731312fb44
-  data.tar.gz: 8bca3021d289308c02d199e30a7dea8551ca8103783effe134ab71dc641894ebd4ae727320a5551e3611357f786db2cb84a65872e74bf0130937d67735da4cae
+  metadata.gz: ef14ecd365691be385e6378b42beb60bd712687bcd1907e8899b5bb7e3b13b0c1c1a8821570631d7accb047cafeff444210fff7ea72802c036cc3b1d79c1976d
+  data.tar.gz: bf62253ac1e9cc96e6efc3c9d83da3918b479dc4ea904dfc3e0e47a860641cd507376a878c85c6982c9115942e80423a2351d25bebc10800ce904272d06f7520

data/lib/resque-multi-job-forks.rb

@@ -10,6 +10,8 @@ module Resque
     attr_accessor :memory_threshold
     attr_reader   :jobs_processed
 
+    WorkerTerminated = Class.new(StandardError)
+
     def self.multi_jobs_per_fork?
       ENV["DISABLE_MULTI_JOBS_PER_FORK"].nil?
     end
@@ -22,6 +24,20 @@ module Resque
         else
           if term_child
             unregister_signal_handlers
+            trap('TERM') do
+              trap('TERM') do
+                # Ignore subsequent term signals
+              end
+
+              if @performing_job
+                # If a job is in progress, stop it immediately.
+                raise TermException.new("SIGTERM")
+              else
+                # If we're not currently running a job, shut down cleanly.
+                # This allows us to push unworked jobs back on the queue.
+                shutdown
+              end
+            end
             trap('QUIT') { shutdown }
           end
           raise NotImplementedError, "Pretending to not have forked"
@@ -39,9 +55,20 @@ module Resque
 
       def perform_with_multi_job_forks(job = nil)
         @fork_per_job = true unless fork_hijacked? # reconnect and after_fork
+        if shutdown?
+          # We got a request to shut down _after_ grabbing a job but _before_ starting work
+          # on it. Immediately report the job as failed and return.
+          if job
+            report_failed_job(job, WorkerTerminated.new("shutdown before job start"))
+          end
+          return
+        end
+        @performing_job = true
         perform_without_multi_job_forks(job)
         hijack_fork unless fork_hijacked?
         @jobs_processed += 1
+      ensure
+        @performing_job = false
       end
       alias_method :perform_without_multi_job_forks, :perform
       alias_method :perform, :perform_with_multi_job_forks
@@ -54,14 +81,14 @@ module Resque
       alias_method :shutdown?, :shutdown_with_multi_job_forks?
 
       def shutdown_with_multi_job_forks
-        shutdown_child if is_parent_process?
+        shutdown_child
         shutdown_without_multi_job_forks
       end
       alias_method :shutdown_without_multi_job_forks, :shutdown
       alias_method :shutdown, :shutdown_with_multi_job_forks
 
       def pause_processing_with_multi_job_forks
-        shutdown_child if is_parent_process?
+        shutdown_child
         pause_processing_without_multi_job_forks
       end
       alias_method :pause_processing_without_multi_job_forks, :pause_processing
@@ -89,8 +116,9 @@ module Resque
     # multiple jobs per fork. The QUIT signal normally does a graceful shutdown,
     # and is re-registered in children (term_child normally unregisters it).
     def shutdown_child
+      return unless @child
       begin
-        log! "multi_jobs_per_fork: Sending QUIT signal to #{@child}"
+        log_with_severity :debug, "multi_jobs_per_fork: Sending QUIT signal to #{@child}"
         Process.kill('QUIT', @child)
       rescue Errno::ESRCH
         nil
@@ -111,7 +139,7 @@ module Resque
     end
 
     def hijack_fork
-      log 'hijack fork.'
+      log_with_severity :debug, 'hijack fork.'
       @suppressed_fork_hooks = [Resque.after_fork, Resque.before_fork]
       Resque.after_fork = Resque.before_fork = nil
       @release_fork_limit = fork_job_limit
@@ -120,11 +148,11 @@ module Resque
     end
 
     def release_fork
-      log "jobs processed by child: #{jobs_processed}; rss: #{rss}"
+      log_with_severity :info, "jobs processed by child: #{jobs_processed}; rss: #{rss}"
       run_hook :before_child_exit, self
       Resque.after_fork, Resque.before_fork = *@suppressed_fork_hooks
       @release_fork_limit = @jobs_processed = nil
-      log 'hijack over, counter terrorists win.'
+      log_with_severity :debug, 'hijack over, counter terrorists win.'
       @shutdown = true
     end
 
@@ -169,16 +197,11 @@ module Resque
   # Call with a block to set the hook.
   # Call with no arguments to return the hook.
   def self.before_child_exit(&block)
-    if block
-      @before_child_exit ||= []
-      @before_child_exit << block
-    end
-    @before_child_exit
+    block ? register_hook(:before_child_exit, block) : hooks(:before_child_exit)
   end
 
   # Set the before_child_exit proc.
   def self.before_child_exit=(before_child_exit)
-    @before_child_exit = before_child_exit.respond_to?(:each) ? before_child_exit : [before_child_exit].compact
+    register_hook(:before_child_exit, block)
   end
-
 end

data/test/helper.rb

@@ -19,6 +19,7 @@ Resque.redis = $redis
 # set `VERBOSE=true` when running the tests to view resques log output.
 module Resque
   class Worker
+    attr_accessor :start_lag
 
     def log_with_severity(severity, msg)
       if ENV['VERBOSE']
@@ -27,14 +28,18 @@ module Resque
       end
     end
 
-    def log(message)
-      log_with_severity :info, message
+    def report_failed_job(job, exception)
+      $SEQ_WRITER.print "failed_job_#{exception.class.name.downcase.gsub('::', '_')}\n"
     end
 
-    def log!(message)
-      log_with_severity :debug, message
+    def fork_hijacked?
+      if @release_fork_limit
+        if start_lag
+          sleep start_lag
+        end
+      end
+      @release_fork_limit
     end
-
   end
 end
 

data/test/test_resque-multi-job-forks.rb

@@ -8,7 +8,7 @@ class TestResqueMultiJobForks < Test::Unit::TestCase
   end
 
   def test_timeout_limit_sequence_of_events
-    @worker.log! "in test_timeout_limit_sequence_of_events"
+    @worker.log_with_severity :debug, "in test_timeout_limit_sequence_of_events"
     # only allow enough time for 3 jobs to process.
     @worker.seconds_per_fork = 3
 
@@ -29,7 +29,7 @@ class TestResqueMultiJobForks < Test::Unit::TestCase
   end
 
   def test_graceful_shutdown_during_first_job
-    @worker.log! "in test_graceful_shutdown_during_first_job"
+    @worker.log_with_severity :debug, "in test_graceful_shutdown_during_first_job"
     # enough time for all jobs to process.
     @worker.seconds_per_fork = 60
 
@@ -51,7 +51,7 @@ class TestResqueMultiJobForks < Test::Unit::TestCase
   end
 
   def test_immediate_shutdown_during_first_job
-    @worker.log! "in test_immediate_shutdown_during_first_job"
+    @worker.log_with_severity :debug, "in test_immediate_shutdown_during_first_job"
     # enough time for all jobs to process.
     @worker.seconds_per_fork = 60
     @worker.term_child = false
@@ -73,7 +73,7 @@ class TestResqueMultiJobForks < Test::Unit::TestCase
   end
 
   def test_sigterm_shutdown_during_first_job
-    @worker.log! "in test_sigterm_shutdown_during_first_job"
+    @worker.log_with_severity :debug, "in test_sigterm_shutdown_during_first_job"
     # enough time for all jobs to process.
     @worker.seconds_per_fork = 60
     @worker.term_child = true
@@ -91,14 +91,38 @@ class TestResqueMultiJobForks < Test::Unit::TestCase
     sequence = $SEQ_READER.each_line.map {|l| l.strip.to_sym }
 
     # test the sequence is correct.
-    assert_equal([:before_fork, :after_fork,
+    assert_equal([:before_fork, :after_fork, :failed_job_resque_termexception,
                   :before_child_exit_1], sequence, 'correct sequence')
     t.join
   end
 
+  def test_shutdown_between_jobs
+    @worker.log_with_severity :debug, "in test_sigterm_shutdown_during_first_job"
+    # enough time for all jobs to process.
+    @worker.seconds_per_fork = 60
+    @worker.term_child = true
+    @worker.graceful_term = true
+    @worker.term_timeout = 0.5
+    @worker.start_lag = 1
+
+    Resque.enqueue(QuickSequenceJob, 1)
+    Resque.enqueue(SequenceJob, 2)
+    t = Thread.new do
+      sleep 2
+      Process.kill("TERM", @worker.pid)
+    end
+    @worker.work(0)
+    $SEQ_WRITER.close
+
+    sequence = $SEQ_READER.each_line.map {|l| l.strip.to_sym }
+    assert_equal([:before_fork, :after_fork, :work_1, :before_child_exit_1, :failed_job_resque_worker_workerterminated], sequence, 'correct sequence')
+
+    t.join
+  end
+
   # test we can also limit fork job process by a job limit.
   def test_job_limit_sequence_of_events
-    @worker.log! "in test_job_limit_sequence_of_events"
+    @worker.log_with_severity :debug, "in test_job_limit_sequence_of_events"
     # only allow 20 jobs per fork
     ENV['JOBS_PER_FORK'] = '20'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: resque-multi-job-forks
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.4
 platform: ruby
 authors:
 - Mick Staugaard
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-02-10 00:00:00.000000000 Z
+date: 2021-11-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: resque
@@ -21,7 +21,7 @@ dependencies:
         version: 1.27.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '2.1'
+        version: '2.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -31,7 +31,7 @@ dependencies:
         version: 1.27.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '2.1'
+        version: '2.2'
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
@@ -121,8 +121,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.14.3
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: Have your resque workers process more that one job