make new signal handling behavior default in 2.0.0

Author: hone

lib/resque/tasks.rb

@@ -15,7 +15,6 @@
       worker.verbose = ENV['LOGGING'] || ENV['VERBOSE']
       worker.very_verbose = ENV['VVERBOSE']
       worker.term_timeout = ENV['RESQUE_TERM_TIMEOUT'] || 4.0
-      worker.term_child = ENV['TERM_CHILD']
     rescue Resque::NoQueueError
       abort "set QUEUE env var, e.g. $ QUEUE=critical,high rake resque:work"
     end

lib/resque/worker.rb

@@ -22,9 +22,6 @@ class Worker
 
     attr_accessor :term_timeout
 
-    # decide whether to use new_kill_child logic
-    attr_accessor :term_child
-
     attr_writer :to_s
 
     # Returns an array of all worker objects.
@@ -150,7 +147,7 @@ def work(interval = 5.0, &block)
               nil
             end
           else
-            unregister_signal_handlers if !@cant_fork && term_child
+            unregister_signal_handlers if !@cant_fork
             procline "Processing #{job.queue} since #{Time.now.to_i}"
             redis.client.reconnect # Don't share connection with parent
             perform(job, &block)
@@ -286,11 +283,7 @@ def register_signal_handlers
 
       begin
         trap('QUIT') { shutdown   }
-        if term_child
-          trap('USR1') { new_kill_child }
-        else
-          trap('USR1') { kill_child }
-        end
+        trap('USR1') { kill_child }
         trap('USR2') { pause_processing }
       rescue ArgumentError
         warn "Signals QUIT, USR1, USR2, and/or CONT not supported."
@@ -321,36 +314,18 @@ def shutdown
     # Kill the child and shutdown immediately.
     def shutdown!
       shutdown
-      if term_child
-        new_kill_child
-      else
-        kill_child
-      end
+      kill_child
     end
 
     # Should this worker shutdown as soon as current job is finished?
     def shutdown?
       @shutdown
     end
 
-    # Kills the forked child immediately, without remorse. The job it
-    # is processing will not be completed.
-    def kill_child
-      if @child
-        log! "Killing child at #{@child}"
-        if system("ps -o pid,state -p #{@child}")
-          Process.kill("KILL", @child) rescue nil
-        else
-          log! "Child #{@child} not found, restarting."
-          shutdown
-        end
-      end
-    end
-
     # Kills the forked child immediately with minimal remorse. The job it
     # is processing will not be completed. Send the child a TERM signal,
     # wait 5 seconds, and then a KILL signal if it has not quit
-    def new_kill_child
+    def kill_child
       if @child
         unless Process.waitpid(@child, Process::WNOHANG)
           log! "Sending TERM signal to child #{@child}"

test/worker_test.rb

@@ -470,66 +470,6 @@ def self.perform
     assert_not_equal original_connection, Resque.redis.client.connection.instance_variable_get("@sock")
   end
 
-  if !defined?(RUBY_ENGINE) || defined?(RUBY_ENGINE) && RUBY_ENGINE != "jruby"
-    it "old signal handling is the default" do
-      rescue_time = nil
-
-      begin
-        class LongRunningJob
-          @queue = :long_running_job
-
-          def self.perform( run_time, rescue_time=nil )
-            Resque.redis.client.reconnect # get its own connection
-            Resque.redis.rpush( 'sigterm-test:start', Process.pid )
-            sleep run_time
-            Resque.redis.rpush( 'sigterm-test:result', 'Finished Normally' )
-          rescue Resque::TermException => e
-            Resque.redis.rpush( 'sigterm-test:result', %Q(Caught SignalException: #{e.inspect}))
-            sleep rescue_time unless rescue_time.nil?
-          ensure
-            puts 'fuuuu'
-            Resque.redis.rpush( 'sigterm-test:final', 'exiting.' )
-          end
-        end
-
-        Resque.enqueue( LongRunningJob, 5, rescue_time )
-
-        worker_pid = Kernel.fork do
-          # ensure we actually fork
-          $TESTING = false
-          # reconnect since we just forked
-          Resque.redis.client.reconnect
-
-          worker = Resque::Worker.new(:long_running_job)
-
-          worker.work(0)
-          exit!
-        end
-
-        # ensure the worker is started
-        start_status = Resque.redis.blpop( 'sigterm-test:start', 5 )
-        assert_not_nil start_status
-        child_pid = start_status[1].to_i
-        assert_operator child_pid, :>, 0
-
-        # send signal to abort the worker
-        Process.kill('TERM', worker_pid)
-        Process.waitpid(worker_pid)
-
-        # wait to see how it all came down
-        result = Resque.redis.blpop( 'sigterm-test:result', 5 )
-        assert_nil result
-
-        # ensure that the child pid is no longer running
-        child_still_running = !(`ps -p #{child_pid.to_s} -o pid=`).empty?
-        assert !child_still_running
-      ensure
-        remaining_keys = Resque.redis.keys('sigterm-test:*') || []
-        Resque.redis.del(*remaining_keys) unless remaining_keys.empty?
-      end
-    end
-  end
-
   if !defined?(RUBY_ENGINE) || defined?(RUBY_ENGINE) && RUBY_ENGINE != "jruby"
     [SignalException, Resque::TermException].each do |exception|
       {
@@ -565,7 +505,6 @@ def self.perform( run_time, rescue_time=nil )
 
               worker = Resque::Worker.new(:long_running_job)
               worker.term_timeout = 1
-              worker.term_child = 1
 
               worker.work(0)
               exit!