resque 1.22.0 → 1.23.0

data/HISTORY.md

@@ -1,3 +1,10 @@
+## 1.23.0 (2012-10-01)
+
+* don't run `before_fork` hook if Resque can't fork (@kjwierenga, @tarcieri, #672, #697)
+* don't run `after_fork` hook if Resque can't fork (@kjwierenga, @tarcieri, #672, #697)
+* retry connecting to redis up to 3 times (@trevorturk, #693)
+* pass exceptions raised by the worker into the Failure backend (@trevorturk, #693)
+
 ## 1.22.0 (2012-08-21)
 
 * unregister signal handlers in child process when ENV["TERM_CHILD"] is set (@dylanasmith, #621)

data/lib/resque/version.rb

@@ -1,3 +1,3 @@
 module Resque
-  Version = VERSION = '1.22.0'
+  Version = VERSION = '1.23.0'
 end

data/lib/resque/worker.rb

@@ -136,10 +136,9 @@ module Resque
         if not paused? and job = reserve
           log "got: #{job.inspect}"
           job.worker = self
-          run_hook :before_fork, job
           working_on job
 
-          if @child = fork
+          if @child = fork(job)
             srand # Reseeding
             procline "Forked #{@child} at #{Time.now.to_i}"
             begin
@@ -148,11 +147,11 @@ module Resque
               nil
             end
           else
-            unregister_signal_handlers if !@cant_fork && term_child
+            unregister_signal_handlers if will_fork? && term_child
             procline "Processing #{job.queue} since #{Time.now.to_i}"
-            redis.client.reconnect # Don't share connection with parent
+            reconnect
             perform(job, &block)
-            exit! unless @cant_fork
+            exit! if will_fork?
           end
 
           done_working
@@ -165,8 +164,9 @@ module Resque
         end
       end
 
-    ensure
       unregister_worker
+    rescue Exception => exception
+      unregister_worker(exception)
     end
 
     # DEPRECATED. Processes a single job. If none is given, it will
@@ -184,7 +184,7 @@ module Resque
     # Processes a given job in the child.
     def perform(job)
       begin
-        run_hook :after_fork, job
+        run_hook :after_fork, job if will_fork?
         job.perform
       rescue Object => e
         log "#{job.inspect} failed: #{e.inspect}"
@@ -219,6 +219,24 @@ module Resque
       raise e
     end
 
+    # Reconnect to Redis to avoid sharing a connection with the parent,
+    # retry up to 3 times with increasing delay before giving up.
+    def reconnect
+      tries = 0
+      begin
+        redis.client.reconnect
+      rescue Redis::BaseConnectionError
+        if (tries += 1) <= 3
+          log "Error reconnecting to Redis; retrying"
+          sleep(tries)
+          retry
+        else
+          log "Error reconnecting to Redis; quitting"
+          raise
+        end
+      end
+    end
+
     # Returns a list of queues to use when searching for a job.
     # A splat ("*") means you want every queue (in alpha order) - this
     # can be useful for dynamically adding new queues.
@@ -228,15 +246,17 @@ module Resque
 
     # Not every platform supports fork. Here we do our magic to
     # determine if yours does.
-    def fork
-      @cant_fork = true if $TESTING
-
+    def fork(job)
       return if @cant_fork
+      
+      # Only run before_fork hooks if we're actually going to fork
+      # (after checking @cant_fork)
+      run_hook :before_fork, job
 
       begin
         # IronRuby doesn't support `Kernel.fork` yet
         if Kernel.respond_to?(:fork)
-          Kernel.fork
+          Kernel.fork if will_fork?
         else
           raise NotImplementedError
         end
@@ -424,7 +444,7 @@ module Resque
     end
 
     # Unregisters ourself as a worker. Useful when shutting down.
-    def unregister_worker
+    def unregister_worker(exception = nil)
       # If we're still processing a job, make sure it gets logged as a
       # failure.
       if (hash = processing) && !hash.empty?
@@ -432,7 +452,7 @@ module Resque
         # Ensure the proper worker is attached to this job, even if
         # it's not the precise instance that died.
         job.worker = self
-        job.fail(DirtyExit.new)
+        job.fail(exception || DirtyExit.new)
       end
 
       redis.srem(:workers, self)
@@ -507,6 +527,10 @@ module Resque
     def idle?
       state == :idle
     end
+    
+    def will_fork?
+      !(@cant_fork || $TESTING)
+    end
 
     # Returns a symbol representing the current worker state,
     # which can be either :working or :idle

data/test/resque_failure_redis_test.rb

@@ -13,10 +13,6 @@ context "Resque::Failure::Redis" do
 
   test 'cleans up bad strings before saving the failure, in order to prevent errors on the resque UI' do
     # test assumption: the bad string should not be able to round trip though JSON
-    assert_raises(MultiJson::DecodeError) {
-      MultiJson.decode(MultiJson.encode(@bad_string))
-    }
-
     @redis_backend.save
     Resque::Failure::Redis.all # should not raise an error
   end

data/test/test_helper.rb

@@ -161,14 +161,18 @@ class Time
   self.fake_time = nil
 end
 
-def capture_stderr
-  # The output stream must be an IO-like object. In this case we capture it in
-  # an in-memory IO object so we can return the string value. You can assign any
-  # IO object here.
-  previous_stderr, $stderr = $stderr, StringIO.new
+# From minitest/unit
+def capture_io
+  require 'stringio'
+
+  orig_stdout, orig_stderr         = $stdout, $stderr
+  captured_stdout, captured_stderr = StringIO.new, StringIO.new
+  $stdout, $stderr                 = captured_stdout, captured_stderr
+
   yield
-  $stderr.string
+
+  return captured_stdout.string, captured_stderr.string
 ensure
-  # Restore the previous value of stderr (typically equal to STDERR).
-  $stderr = previous_stderr
+  $stdout = orig_stdout
+  $stderr = orig_stderr
 end

data/test/worker_test.rb

@@ -32,11 +32,20 @@ context "Resque::Worker" do
     end
   end
 
-  test "fails uncompleted jobs on exit" do
+  test "fails uncompleted jobs with DirtyExit by default on exit" do
     job = Resque::Job.new(:jobs, {'class' => 'GoodJob', 'args' => "blah"})
     @worker.working_on(job)
     @worker.unregister_worker
     assert_equal 1, Resque::Failure.count
+    assert_equal('Resque::DirtyExit', Resque::Failure.all['exception'])
+  end
+
+  test "fails uncompleted jobs with worker exception on exit" do
+    job = Resque::Job.new(:jobs, {'class' => 'GoodJob', 'args' => "blah"})
+    @worker.working_on(job)
+    @worker.unregister_worker(StandardError.new)
+    assert_equal 1, Resque::Failure.count
+    assert_equal('StandardError', Resque::Failure.all['exception'])
   end
 
   class ::SimpleJobWithFailureHandling
@@ -376,6 +385,19 @@ context "Resque::Worker" do
     workerA.work(0)
     assert $BEFORE_FORK_CALLED
   end
+  
+  test "Will not call a before_fork hook when the worker can't fork" do
+    Resque.redis.flushall
+    $BEFORE_FORK_CALLED = false
+    Resque.before_fork = Proc.new { $BEFORE_FORK_CALLED = true }
+    workerA = Resque::Worker.new(:jobs)
+    workerA.cant_fork = true
+
+    assert !$BEFORE_FORK_CALLED, "before_fork should not have been called before job runs"
+    Resque::Job.create(:jobs, SomeJob, 20, '/tmp')
+    workerA.work(0)
+    assert !$BEFORE_FORK_CALLED, "before_fork should not have been called after job runs"
+  end
 
   test "very verbose works in the afternoon" do
     begin
@@ -396,16 +418,29 @@ context "Resque::Worker" do
     end
   end
 
-  test "Will call an after_fork hook after forking" do
+  test "Will call an after_fork hook if we're forking" do
+    Resque.redis.flushall
+    $AFTER_FORK_CALLED = false
+    Resque.after_fork = Proc.new { $AFTER_FORK_CALLED = true }
+    workerA = Resque::Worker.new(:jobs)
+
+    assert !$AFTER_FORK_CALLED
+    Resque::Job.create(:jobs, SomeJob, 20, '/tmp')
+    workerA.work(0)
+    assert $AFTER_FORK_CALLED == workerA.will_fork?
+  end
+
+  test "Will not call an after_fork hook when the worker can't fork" do
     Resque.redis.flushall
     $AFTER_FORK_CALLED = false
     Resque.after_fork = Proc.new { $AFTER_FORK_CALLED = true }
     workerA = Resque::Worker.new(:jobs)
+    workerA.cant_fork = true
 
     assert !$AFTER_FORK_CALLED
     Resque::Job.create(:jobs, SomeJob, 20, '/tmp')
     workerA.work(0)
-    assert $AFTER_FORK_CALLED
+    assert !$AFTER_FORK_CALLED
   end
 
   test "returns PID of running process" do
@@ -438,6 +473,40 @@ context "Resque::Worker" do
     assert_not_equal original_connection, Resque.redis.client.connection.instance_variable_get("@sock")
   end
 
+  test "tries to reconnect three times before giving up" do
+    begin
+      class Redis::Client
+        alias_method :original_reconnect, :reconnect
+
+        def reconnect
+          raise Redis::BaseConnectionError
+        end
+      end
+
+      class Resque::Worker
+        alias_method :original_sleep, :sleep
+
+        def sleep(duration = nil)
+          # noop
+        end
+      end
+
+      @worker.very_verbose = true
+      stdout, stderr = capture_io { @worker.work(0) }
+
+      assert_equal 3, stdout.scan(/retrying/).count
+      assert_equal 1, stdout.scan(/quitting/).count
+    ensure
+      class Redis::Client
+        alias_method :reconnect, :original_reconnect
+      end
+
+      class Resque::Worker
+        alias_method :sleep, :original_sleep
+      end
+    end
+  end
+
   if !defined?(RUBY_ENGINE) || defined?(RUBY_ENGINE) && RUBY_ENGINE != "jruby"
     test "old signal handling is the default" do
       rescue_time = nil
@@ -573,14 +642,14 @@ context "Resque::Worker" do
     end
 
     test "displays warning when not using term_child" do
-      stderr = capture_stderr { @worker.work(0) }
+      stdout, stderr = capture_io { @worker.work(0) }
 
       assert stderr.match(/^WARNING:/)
     end
 
     test "it does not display warning when using term_child" do
       @worker.term_child = "1"
-      stderr = capture_stderr { @worker.work(0) }
+      stdout, stderr = capture_io { @worker.work(0) }
 
       assert !stderr.match(/^WARNING:/)
     end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: resque
 version: !ruby/object:Gem::Version 
-  hash: 79
+  hash: 75
   prerelease: 
   segments: 
   - 1
-  - 22
+  - 23
   - 0
-  version: 1.22.0
+  version: 1.23.0
 platform: ruby
 authors: 
 - Chris Wanstrath
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-08-21 00:00:00 Z
+date: 2012-10-01 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: redis-namespace
@@ -151,7 +151,6 @@ files:
 - test/test_helper.rb
 - test/hoptoad_test.rb
 - test/resque_test.rb
-- test/dump.rdb
 - test/job_plugins_test.rb
 homepage: http://github.com/defunkt/resque
 licenses: []