resque-mongo 1.4.0 → 1.8.1

data/lib/resque/worker.rb

@@ -109,26 +109,25 @@ module Resque
 
         if not @paused and job = reserve
           log "got: #{job.inspect}"
+          run_hook :before_fork
+          working_on job
 
           if @child = fork
             rand # Reseeding
-            procline = "resque: Forked #{@child} at #{Time.now.to_i}"
-            $0 = procline
-            log! procline
+            procline "Forked #{@child} at #{Time.now.to_i}"
             Process.wait
           else
-            procline = "resque: Processing #{job.queue} since #{Time.now.to_i}"
-            $0 = procline
-            log! procline
-            process(job, &block)
+            procline "Processing #{job.queue} since #{Time.now.to_i}"
+            perform(job, &block)
             exit! unless @cant_fork
           end
 
+          done_working
           @child = nil
         else
           break if interval.to_i == 0
           log! "Sleeping for #{interval.to_i}"
-          $0 = @paused ? "resque: Paused" : "resque: Waiting for #{@queues.join(',')}"
+          procline @paused ? "Paused" : "Waiting for #{@queues.join(',')}"
           sleep interval.to_i
         end
       end
@@ -137,13 +136,21 @@ module Resque
       unregister_worker
     end
 
-    # Processes a single job. If none is given, it will try to produce
-    # one.
-    def process(job = nil)
+    # DEPRECATED. Processes a single job. If none is given, it will
+    # try to produce one. Usually run in the child.
+    def process(job = nil, &block)
       return unless job ||= reserve
 
+      working_on job
+      perform(job, &block)
+    ensure
+      done_working
+    end
+
+    # Processes a given job in the child.
+    def perform(job)
       begin
-        working_on job
+        run_hook :after_fork, job
         job.perform
       rescue Object => e
         log "#{job.inspect} failed: #{e.inspect}"
@@ -153,7 +160,6 @@ module Resque
         log "done: #{job.inspect}"
       ensure
         yield job if block_given?
-        done_working
       end
     end
 
@@ -203,7 +209,12 @@ module Resque
       enable_gc_optimizations
       register_signal_handlers
       prune_dead_workers
+      run_hook :before_first_fork
       register_worker
+
+      # Fix buffering so we can `rake resque:work > resque.log` and
+      # get output from the child in there.
+      $stdout.sync = true
     end
 
     # Enables GC Optimizations if you're running REE.
@@ -307,8 +318,28 @@ module Resque
       started!
     end
 
+    # Runs a named hook, passing along any arguments.
+    def run_hook(name, *args)
+      return unless hook = Resque.send(name)
+      msg = "Running #{name} hook"
+      msg << " with #{args.inspect}" if args.any?
+      log msg
+
+      args.any? ? hook.call(*args) : hook.call
+    end
+
     # Unregisters ourself as a worker. Useful when shutting down.
     def unregister_worker
+      # If we're still processing a job, make sure it gets logged as a
+      # failure.
+      if (hash = processing) && !hash.empty?
+        job = Job.new(hash['queue'], hash['payload'])
+        # 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)
+      end
+
       mongo_workers.remove(:worker => self.to_s)
 
       Stat.clear("processed:#{self}")
@@ -318,13 +349,13 @@ module Resque
     # Given a job, tells Redis we're working on it. Useful for seeing
     # what workers are doing and when.
     def working_on(job)
-      job.worker = self.to_s
+      job.worker = self
       data = encode \
         :queue   => job.queue,
         :run_at  => Time.now.to_s,
       :payload => job.payload
       working_on = {'working_on' => data}
-      mongo_workers.update({:worker => self.to_s},  {'$set' => working_on})
+      mongo_workers.update({:worker => self.to_s},  {'$set' => working_on}, :upsert => true )
     end
 
     # Called when we are done working - clears our `working_on` state
@@ -424,6 +455,14 @@ module Resque
       end
     end
 
+    # Given a string, sets the procline ($0) and logs.
+    # Procline is always in the format of:
+    #   resque-VERSION: STRING
+    def procline(string)
+      $0 = "resque-#{Resque::Version}: #{string}"
+      log! $0
+    end
+
     # Log a message to STDOUT if we are verbose or very_verbose.
     def log(message)
       if verbose

data/tasks/redis.rake

@@ -1,20 +1,28 @@
 # Inspired by rabbitmq.rake the Redbox project at http://github.com/rick/redbox/tree/master
 require 'fileutils'
 require 'open-uri'
+require 'pathname'
 
 class RedisRunner
 
-  def self.redisdir
-    "/tmp/redis/"
+  def self.redis_dir
+    @redis_dir ||= if ENV['PREFIX']
+                     Pathname.new(ENV['PREFIX'])
+                   else
+                     Pathname.new(`which redis-server`) + '..' + '..'
+                   end
   end
 
-  def self.redisconfdir
-    server_dir = File.dirname(`which redis-server`)
-    conf_file = "#{server_dir}/../etc/redis.conf"
-    unless File.exists? conf_file
-      conf_file = "#{server_dir}/../../etc/redis.conf"
-    end
-    conf_file
+  def self.bin_dir
+    redis_dir + 'bin'
+  end
+
+  def self.config
+    @config ||= if File.exists?(redis_dir + 'etc/redis.conf')
+                  redis_dir + 'etc/redis.conf'
+                else
+                  redis_dir + '../etc/redis.conf'
+                end
   end
 
   def self.dtach_socket
@@ -29,12 +37,12 @@ class RedisRunner
   def self.start
     puts 'Detach with Ctrl+\  Re-attach with rake redis:attach'
     sleep 1
-    command = "dtach -A #{dtach_socket} redis-server #{redisconfdir}"
+    command = "#{bin_dir}/dtach -A #{dtach_socket} #{bin_dir}/redis-server #{config}"
     sh command
   end
 
   def self.attach
-    exec "dtach -a #{dtach_socket}"
+    exec "#{bin_dir}/dtach -a #{dtach_socket}"
   end
 
   def self.stop
@@ -73,31 +81,39 @@ namespace :redis do
 
   desc 'Install the latest verison of Redis from Github (requires git, duh)'
   task :install => [:about, :download, :make] do
-    ENV['PREFIX'] and bin_dir = "#{ENV['PREFIX']}/bin" or bin_dir = '/usr/bin'
+    bin_dir = '/usr/bin'
+    conf_dir = '/etc'
+
+    if ENV['PREFIX']
+      bin_dir = "#{ENV['PREFIX']}/bin"
+      sh "mkdir -p #{bin_dir}" unless File.exists?("#{bin_dir}")
+
+      conf_dir = "#{ENV['PREFIX']}/etc"
+      sh "mkdir -p #{conf_dir}" unless File.exists?("#{conf_dir}")
+    end
+
     %w(redis-benchmark redis-cli redis-server).each do |bin|
       sh "cp /tmp/redis/#{bin} #{bin_dir}"
     end
 
     puts "Installed redis-benchmark, redis-cli and redis-server to #{bin_dir}"
 
-    ENV['PREFIX'] and conf_dir = "#{ENV['PREFIX']}/etc" or conf_dir = '/etc'
     unless File.exists?("#{conf_dir}/redis.conf")
-      sh "mkdir #{conf_dir}" unless File.exists?("#{conf_dir}")
       sh "cp /tmp/redis/redis.conf #{conf_dir}/redis.conf"
       puts "Installed redis.conf to #{conf_dir} \n You should look at this file!"
     end
   end
 
   task :make do
-    sh "cd #{RedisRunner.redisdir} && make clean"
-    sh "cd #{RedisRunner.redisdir} && make"
+    sh "cd /tmp/redis && make clean"
+    sh "cd /tmp/redis && make"
   end
 
   desc "Download package"
   task :download do
-    sh 'rm -rf /tmp/redis/' if File.exists?("#{RedisRunner.redisdir}/.svn")
-    sh 'git clone git://github.com/antirez/redis.git /tmp/redis' unless File.exists?(RedisRunner.redisdir)
-    sh "cd #{RedisRunner.redisdir} && git pull" if File.exists?("#{RedisRunner.redisdir}/.git")
+    sh 'rm -rf /tmp/redis/' if File.exists?("/tmp/redis/.svn")
+    sh 'git clone git://github.com/antirez/redis.git /tmp/redis' unless File.exists?('/tmp/redis')
+    sh "cd /tmp/redis && git pull" if File.exists?("/tmp/redis/.git")
   end
 
 end
@@ -110,9 +126,24 @@ namespace :dtach do
   end
 
   desc 'Install dtach 0.8 from source'
-  task :install => [:about] do
+  task :install => [:about, :download, :make] do
+
+    bin_dir = "/usr/bin"
+
+    if ENV['PREFIX']
+      bin_dir = "#{ENV['PREFIX']}/bin"
+      sh "mkdir -p #{bin_dir}" unless File.exists?("#{bin_dir}")
+    end
+
+    sh "cp /tmp/dtach-0.8/dtach #{bin_dir}"
+  end
+
+  task :make do
+    sh 'cd /tmp/dtach-0.8/ && ./configure && make'
+  end
 
-    Dir.chdir('/tmp/')
+  desc "Download package"
+  task :download do
     unless File.exists?('/tmp/dtach-0.8.tar.gz')
       require 'net/http'
 
@@ -121,15 +152,8 @@ namespace :dtach do
     end
 
     unless File.directory?('/tmp/dtach-0.8')
-      system('tar xzf dtach-0.8.tar.gz')
+      sh 'cd /tmp && tar xzf dtach-0.8.tar.gz'
     end
-
-    ENV['PREFIX'] and bin_dir = "#{ENV['PREFIX']}/bin" or bin_dir = "/usr/bin"
-    Dir.chdir('/tmp/dtach-0.8/')
-    sh 'cd /tmp/dtach-0.8/ && ./configure && make'
-    sh "cp /tmp/dtach-0.8/dtach #{bin_dir}"
-
-    puts "Dtach successfully installed to #{bin_dir}"
   end
 end
 

data/test/job_hooks_test.rb

@@ -0,0 +1,302 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+context "Resque::Job before_perform" do
+  include PerformJob
+
+  class BeforePerformJob
+    def self.before_perform_record_history(history)
+      history << :before_perform
+    end
+
+    def self.perform(history)
+      history << :perform
+    end
+  end
+
+  test "it runs before_perform before perform" do
+    result = perform_job(BeforePerformJob, history=[])
+    assert_equal true, result, "perform returned true"
+    assert_equal history, [:before_perform, :perform]
+  end
+
+  class BeforePerformJobFails
+    def self.before_perform_fail_job(history)
+      history << :before_perform
+      raise StandardError
+    end
+    def self.perform(history)
+      history << :perform
+    end
+  end
+
+  test "raises an error and does not perform if before_perform fails" do
+    history = []
+    assert_raises StandardError do
+      perform_job(BeforePerformJobFails, history)
+    end
+    assert_equal history, [:before_perform], "Only before_perform was run"
+  end
+
+  class BeforePerformJobAborts
+    def self.before_perform_abort(history)
+      history << :before_perform
+      raise Resque::Job::DontPerform
+    end
+    def self.perform(history)
+      history << :perform
+    end
+  end
+
+  test "does not perform if before_perform raises Resque::Job::DontPerform" do
+    result = perform_job(BeforePerformJobAborts, history=[])
+    assert_equal false, result, "perform returned false"
+    assert_equal history, [:before_perform], "Only before_perform was run"
+  end
+end
+
+context "Resque::Job after_perform" do
+  include PerformJob
+
+  class AfterPerformJob
+    def self.perform(history)
+      history << :perform
+    end
+    def self.after_perform_record_history(history)
+      history << :after_perform
+    end
+  end
+
+  test "it runs after_perform after perform" do
+    result = perform_job(AfterPerformJob, history=[])
+    assert_equal true, result, "perform returned true"
+    assert_equal history, [:perform, :after_perform]
+  end
+
+  class AfterPerformJobFails
+    def self.perform(history)
+      history << :perform
+    end
+    def self.after_perform_fail_job(history)
+      history << :after_perform
+      raise StandardError
+    end
+  end
+
+  test "raises an error but has already performed if after_perform fails" do
+    history = []
+    assert_raises StandardError do
+      perform_job(AfterPerformJobFails, history)
+    end
+    assert_equal history, [:perform, :after_perform], "Only after_perform was run"
+  end
+end
+
+context "Resque::Job around_perform" do
+  include PerformJob
+
+  class AroundPerformJob
+    def self.perform(history)
+      history << :perform
+    end
+    def self.around_perform_record_history(history)
+      history << :start_around_perform
+      yield
+      history << :finish_around_perform
+    end
+  end
+
+  test "it runs around_perform then yields in order to perform" do
+    result = perform_job(AroundPerformJob, history=[])
+    assert_equal true, result, "perform returned true"
+    assert_equal history, [:start_around_perform, :perform, :finish_around_perform]
+  end
+
+  class AroundPerformJobFailsBeforePerforming
+    def self.perform(history)
+      history << :perform
+    end
+    def self.around_perform_fail(history)
+      history << :start_around_perform
+      raise StandardError
+      yield
+      history << :finish_around_perform
+    end
+  end
+
+  test "raises an error and does not perform if around_perform fails before yielding" do
+    history = []
+    assert_raises StandardError do
+      perform_job(AroundPerformJobFailsBeforePerforming, history)
+    end
+    assert_equal history, [:start_around_perform], "Only part of around_perform was run"
+  end
+
+  class AroundPerformJobFailsWhilePerforming
+    def self.perform(history)
+      history << :perform
+      raise StandardError
+    end
+    def self.around_perform_fail_in_yield(history)
+      history << :start_around_perform
+      begin
+        yield
+      ensure
+        history << :ensure_around_perform
+      end
+      history << :finish_around_perform
+    end
+  end
+
+  test "raises an error but may handle exceptions if perform fails" do
+    history = []
+    assert_raises StandardError do
+      perform_job(AroundPerformJobFailsWhilePerforming, history)
+    end
+    assert_equal history, [:start_around_perform, :perform, :ensure_around_perform], "Only part of around_perform was run"
+  end
+
+  class AroundPerformJobDoesNotHaveToYield
+    def self.perform(history)
+      history << :perform
+    end
+    def self.around_perform_dont_yield(history)
+      history << :start_around_perform
+      history << :finish_around_perform
+    end
+  end
+
+  test "around_perform is not required to yield" do
+    history = []
+    result = perform_job(AroundPerformJobDoesNotHaveToYield, history)
+    assert_equal false, result, "perform returns false"
+    assert_equal history, [:start_around_perform, :finish_around_perform], "perform was not run"
+  end
+end
+
+context "Resque::Job on_failure" do
+  include PerformJob
+
+  class FailureJobThatDoesNotFail
+    def self.perform(history)
+      history << :perform
+    end
+    def self.on_failure_record_failure(exception, history)
+      history << exception.message
+    end
+  end
+
+  test "it does not call on_failure if no failures occur" do
+    result = perform_job(FailureJobThatDoesNotFail, history=[])
+    assert_equal true, result, "perform returned true"
+    assert_equal history, [:perform]
+  end
+
+  class FailureJobThatFails
+    def self.perform(history)
+      history << :perform
+      raise StandardError, "oh no"
+    end
+    def self.on_failure_record_failure(exception, history)
+      history << exception.message
+    end
+  end
+
+  test "it calls on_failure with the exception and then re-raises the exception" do
+    history = []
+    assert_raises StandardError do
+      perform_job(FailureJobThatFails, history)
+    end
+    assert_equal history, [:perform, "oh no"]
+  end
+
+  class FailureJobThatFailsBadly
+    def self.perform(history)
+      history << :perform
+      raise SyntaxError, "oh no"
+    end
+    def self.on_failure_record_failure(exception, history)
+      history << exception.message
+    end
+  end
+
+  test "it calls on_failure even with bad exceptions" do
+    history = []
+    assert_raises SyntaxError do
+      perform_job(FailureJobThatFailsBadly, history)
+    end
+    assert_equal history, [:perform, "oh no"]
+  end
+end
+
+context "Resque::Job all hooks" do
+  include PerformJob
+
+  class VeryHookyJob
+    def self.before_perform_record_history(history)
+      history << :before_perform
+    end
+    def self.around_perform_record_history(history)
+      history << :start_around_perform
+      yield
+      history << :finish_around_perform
+    end
+    def self.perform(history)
+      history << :perform
+    end
+    def self.after_perform_record_history(history)
+      history << :after_perform
+    end
+    def self.on_failure_record_history(exception, history)
+      history << exception.message
+    end
+  end
+
+  test "the complete hook order" do
+    result = perform_job(VeryHookyJob, history=[])
+    assert_equal true, result, "perform returned true"
+    assert_equal history, [
+      :before_perform,
+      :start_around_perform,
+      :perform,
+      :finish_around_perform,
+      :after_perform
+    ]
+  end
+
+  class VeryHookyJobThatFails
+    def self.before_perform_record_history(history)
+      history << :before_perform
+    end
+    def self.around_perform_record_history(history)
+      history << :start_around_perform
+      yield
+      history << :finish_around_perform
+    end
+    def self.perform(history)
+      history << :perform
+    end
+    def self.after_perform_record_history(history)
+      history << :after_perform
+      raise StandardError, "oh no"
+    end
+    def self.on_failure_record_history(exception, history)
+      history << exception.message
+    end
+  end
+
+  test "the complete hook order with a failure at the last minute" do
+    history = []
+    assert_raises StandardError do
+      perform_job(VeryHookyJobThatFails, history)
+    end
+    assert_equal history, [
+      :before_perform,
+      :start_around_perform,
+      :perform,
+      :finish_around_perform,
+      :after_perform,
+      "oh no"
+    ]
+  end
+end
+