resque-multi-job-forks 0.4.5 → 0.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e14fad0b41eaab14a736ac76d9e234314c97279b190d90ab935a74717bc18921
-  data.tar.gz: fc1a9a67f6a6825180044316144b70923f771d454e5c6338c86ccd22aecb3fb8
+  metadata.gz: 7cb28f2bcae133394c2e1a4e2cd71c256030fdefcb86dfb9c3300913056a9324
+  data.tar.gz: a2a002cc266e7c42ac9e92388ea2837392e697b3a27aa4d033577223f3900596
 SHA512:
-  metadata.gz: 2da4375dc2b26da0c670e402954c0b5496a6ce46c3100eabe4f9991d50cd987b0c8d4e5745fdb72f1632f35934f112eb42df6a141c7d838904ed12419f0e8a7d
-  data.tar.gz: cc8c72fa05245eae3aa8a19811b54279ee00f6257fb8093942c9fd7c8d62336fb4ce1e7242de96e997772baff15486838cd3418ca0436d21ec38dd6f4cb4a3fe
+  metadata.gz: a66af847f0dece95ba2e0990433d5dfde52cee08b51b9163f3551269d5c8fd0bc31c2207a45aad23a3d1af19e065482c5871afd4f7014bcd58f10d2b24dae9db
+  data.tar.gz: 5acdcd7e2b3eb9ee375852a6d3539016994e0344a57b1256e33bacaf533fce2fb89c088f3fb7dfb2b96002e10bd8930c9161b9591b17cafced036eb8ae13ae75

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

@@ -15,6 +15,20 @@ module Resque
     end
 
     if multi_jobs_per_fork? && !method_defined?(:shutdown_without_multi_job_forks)
+
+      def fork(&block)
+        if child = Kernel.fork
+          return child
+        else
+          if term_child
+            unregister_signal_handlers
+            trap('QUIT') { shutdown }
+          end
+          raise NotImplementedError, "Pretending to not have forked"
+          # perform_with_fork will run the job and continue working...
+        end
+      end
+
       def work_with_multi_job_forks(*args)
         pid # forces @pid to be set in the parent
         work_without_multi_job_forks(*args)
@@ -24,7 +38,7 @@ module Resque
       alias_method :work, :work_with_multi_job_forks
 
       def perform_with_multi_job_forks(job = nil)
-        trap('QUIT') { shutdown } unless fork_hijacked?
+        @fork_per_job = true unless fork_hijacked? # reconnect and after_fork
         perform_without_multi_job_forks(job)
         hijack_fork unless fork_hijacked?
         @jobs_processed += 1
@@ -40,14 +54,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
@@ -75,8 +89,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
@@ -97,22 +112,21 @@ 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
       @jobs_processed = 0
-      @cant_fork = true
-      trap('QUIT') { shutdown }
+      @fork_per_job = false
     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 = @cant_fork = nil
-      log 'hijack over, counter terrorists win.'
-      @shutdown = true unless $TESTING
+      @release_fork_limit = @jobs_processed = nil
+      log_with_severity :debug, 'hijack over, counter terrorists win.'
+      @shutdown = true
     end
 
     def fork_job_limit
@@ -156,16 +170,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

@@ -20,10 +20,12 @@ Resque.redis = $redis
 module Resque
   class Worker
 
-    def log(msg)
-      puts "*** #{msg}" unless ENV['VERBOSE'].nil?
+    def log_with_severity(severity, msg)
+      if ENV['VERBOSE']
+        s = severity.to_s[0].upcase
+        $stderr.print "*** [#{Time.now}] [#{Process.pid}] #{self} #{s}: #{msg}\n"
+      end
     end
-    alias_method :log!, :log
 
   end
 end

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

@@ -8,6 +8,7 @@ class TestResqueMultiJobForks < Test::Unit::TestCase
   end
 
   def 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
 
@@ -28,6 +29,7 @@ class TestResqueMultiJobForks < Test::Unit::TestCase
   end
 
   def 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
 
@@ -49,6 +51,7 @@ class TestResqueMultiJobForks < Test::Unit::TestCase
   end
 
   def 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
@@ -70,6 +73,7 @@ class TestResqueMultiJobForks < Test::Unit::TestCase
   end
 
   def 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
@@ -94,6 +98,7 @@ class TestResqueMultiJobForks < Test::Unit::TestCase
 
   # test we can also limit fork job process by a job limit.
   def 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'
 
@@ -105,18 +110,26 @@ class TestResqueMultiJobForks < Test::Unit::TestCase
     $SEQ_WRITER.close
     sequence = $SEQ_READER.each_line.map {|l| l.strip.to_sym }
 
-    assert_equal :before_fork,          sequence[0],  'first before_fork call.'
-    assert_equal :after_fork,           sequence[1],  'first after_fork call.'
-    assert_equal :work_20,              sequence[21], '20th chunk of work.'
-    assert_equal :before_child_exit_20, sequence[22], 'first before_child_exit call.'
-    assert_equal :before_fork,          sequence[23], 'final before_fork call.'
-    assert_equal :after_fork,           sequence[24], 'final after_fork call.'
-    assert_equal :work_40,              sequence[44], '40th chunk of work.'
-    assert_equal :before_child_exit_20, sequence[45], 'final before_child_exit call.'
+    assert_equal(%i[
+      before_fork after_fork
+      work_1 work_2 work_3 work_4 work_5
+      work_6 work_7 work_8 work_9 work_10
+      work_11 work_12 work_13 work_14 work_15
+      work_16 work_17 work_18 work_19 work_20
+      before_child_exit_20
+      before_fork after_fork
+      work_21 work_22 work_23 work_24 work_25
+      work_26 work_27 work_28 work_29 work_30
+      work_31 work_32 work_33 work_34 work_35
+      work_36 work_37 work_38 work_39 work_40
+      before_child_exit_20
+    ], sequence, 'correct sequence')
   end
 
   def teardown
     # make sure we don't clobber any other tests.
     ENV['JOBS_PER_FORK'] = nil
+    Resque::Worker.kill_all_heartbeat_threads
   end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: resque-multi-job-forks
 version: !ruby/object:Gem::Version
-  version: 0.4.5
+  version: 0.5.3
 platform: ruby
 authors:
 - Mick Staugaard
@@ -10,22 +10,28 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-02-10 00:00:00.000000000 Z
+date: 2021-08-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: resque
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.27.0
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 1.26.0
+        version: '2.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.27.0
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 1.26.0
+        version: '2.2'
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
@@ -115,7 +121,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.1
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: Have your resque workers process more that one job