Merge pull request resque#743 from mrzor/extra_module_hooks

Implement Resque.before_perform and Resque.after_perform

Author: steveklabnik

lib/resque.rb

@@ -153,6 +153,36 @@ def after_pause=(block)
     register_hook(:after_pause, block)
   end
 
+  # The `before_perform` hook will be run in the child process before
+  # the job code is performed. This hook will run before any
+  # Job.before_perform hook.
+  #
+  # Call with a block to register a hook.
+  # Call with no arguments to return all registered hooks.
+  def before_perform(&block)
+    block ? register_hook(:before_perform, block) : hooks(:before_perform)
+  end
+
+  # Register an before_perform proc.
+  def before_perform=(block)
+    register_hook(:before_perform, block)
+  end
+
+  # The `after_perform` hook will be run in the child process after
+  # the job code has performed. This hook will run after any
+  # Job.after_perform hook.
+  #
+  # Call with a block to register a hook.
+  # Call with no arguments to return all registered hooks.
+  def after_perform(&block)
+    block ? register_hook(:after_perform, block) : hooks(:after_perform)
+  end
+
+  # Register an after_perform proc.
+  def after_perform=(block)
+    register_hook(:after_perform, block)
+  end
+
   def to_s
     "Resque Client connected to #{redis_id}"
   end

lib/resque/worker.rb

@@ -181,7 +181,9 @@ def process(job = nil, &block)
     def perform(job)
       begin
         run_hook :after_fork, job if will_fork?
+        run_hook :before_perform, job
         job.perform
+        run_hook :after_perform, job
       rescue Object => e
         Resque.logger.info "#{job.inspect} failed: #{e.inspect}"
         begin

test/resque_hook_test.rb

@@ -7,6 +7,8 @@
     Resque.before_first_fork = nil
     Resque.before_fork = nil
     Resque.after_fork = nil
+    Resque.before_perform = nil
+    Resque.after_perform = nil
 
     @worker = Resque::Worker.new(:jobs)
 
@@ -23,6 +25,8 @@ def self.perform
     assert_equal [], Resque.before_first_fork
     assert_equal [], Resque.before_fork
     assert_equal [], Resque.after_fork
+    assert_equal [], Resque.before_perform
+    assert_equal [], Resque.after_perform
   end
 
   it 'calls before_first_fork once' do
@@ -47,6 +51,17 @@ def self.perform
     assert_equal(@worker.will_fork? ? 2 : 0, counter)
   end
 
+  it 'calls before_perform before each job' do
+    counter = 0
+
+    Resque.before_perform { counter += 1 }
+    2.times { Resque::Job.create(:jobs, CallNotifyJob) }
+
+    assert_equal(0, counter)
+    @worker.work(0)
+    assert_equal(2, counter)
+  end
+
   it 'calls after_fork after each job if forking' do
     counter = 0
 
@@ -58,6 +73,17 @@ def self.perform
     assert_equal(@worker.will_fork? ? 2 : 0, counter)
   end
 
+  it 'calls after_perform after each job' do
+    counter = 0
+
+    Resque.after_perform { counter += 1 }
+    2.times { Resque::Job.create(:jobs, CallNotifyJob) }
+
+    assert_equal(0, counter)
+    @worker.work(0)
+    assert_equal(2, counter)
+  end
+
   it 'calls before_first_fork before forking' do
     Resque.before_first_fork { assert(!$called) }
 
@@ -163,4 +189,31 @@ def self.perform
 
     assert(first && second)
   end
+
+  it 'registers multiple before_perform' do
+    first = false
+    second = false
+
+    Resque.before_perform { first = true }
+    Resque.before_perform { second = true }
+    Resque::Job.create(:jobs, CallNotifyJob)
+
+    assert(!first && !second)
+    @worker.work(0)
+    assert(first && second)
+  end
+
+  it 'registers multiple after_perform' do
+    first = false
+    second = false
+
+    Resque.after_perform { first = true }
+    Resque.after_perform { second = true }
+    Resque::Job.create(:jobs, CallNotifyJob)
+
+    assert(!first && !second)
+    @worker.work(0)
+    assert(first && second)
+  end
+
 end