tr_resque 1.20.1

data/lib/tasks/redis.rake

@@ -0,0 +1,161 @@
+# 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.redis_dir
+    @redis_dir ||= if ENV['PREFIX']
+                     Pathname.new(ENV['PREFIX'])
+                   else
+                     Pathname.new(`which redis-server`) + '..' + '..'
+                   end
+  end
+
+  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
+    '/tmp/redis.dtach'
+  end
+
+  # Just check for existance of dtach socket
+  def self.running?
+    File.exists? dtach_socket
+  end
+
+  def self.start
+    puts 'Detach with Ctrl+\  Re-attach with rake redis:attach'
+    sleep 1
+    command = "#{bin_dir}/dtach -A #{dtach_socket} #{bin_dir}/redis-server #{config}"
+    sh command
+  end
+
+  def self.attach
+    exec "#{bin_dir}/dtach -a #{dtach_socket}"
+  end
+
+  def self.stop
+    sh 'echo "SHUTDOWN" | nc localhost 6379'
+  end
+end
+
+INSTALL_DIR = ENV['INSTALL_DIR'] || '/tmp/redis'
+
+namespace :redis do
+  desc 'About redis'
+  task :about do
+    puts "\nSee http://code.google.com/p/redis/ for information about redis.\n\n"
+  end
+
+  desc 'Start redis'
+  task :start do
+    RedisRunner.start
+  end
+
+  desc 'Stop redis'
+  task :stop do
+    RedisRunner.stop
+  end
+
+  desc 'Restart redis'
+  task :restart do
+    RedisRunner.stop
+    RedisRunner.start
+  end
+
+  desc 'Attach to redis dtach socket'
+  task :attach do
+    RedisRunner.attach
+  end
+
+  desc <<-DOC
+  Install the latest verison of Redis from Github (requires git, duh).
+    Use INSTALL_DIR env var like "rake redis:install INSTALL_DIR=~/tmp"
+    in order to get an alternate location for your install files.
+  DOC
+
+  task :install => [:about, :download, :make] do
+    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 #{INSTALL_DIR}/src/#{bin} #{bin_dir}"
+    end
+
+    puts "Installed redis-benchmark, redis-cli and redis-server to #{bin_dir}"
+
+    unless File.exists?("#{conf_dir}/redis.conf")
+      sh "cp #{INSTALL_DIR}/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 #{INSTALL_DIR}/src && make clean"
+    sh "cd #{INSTALL_DIR}/src && make"
+  end
+
+  desc "Download package"
+  task :download do
+    sh "rm -rf #{INSTALL_DIR}/" if File.exists?("#{INSTALL_DIR}/.svn")
+    sh "git clone git://github.com/antirez/redis.git #{INSTALL_DIR}" unless File.exists?(INSTALL_DIR)
+    sh "cd #{INSTALL_DIR} && git pull" if File.exists?("#{INSTALL_DIR}/.git")
+  end
+end
+
+namespace :dtach do
+  desc 'About dtach'
+  task :about do
+    puts "\nSee http://dtach.sourceforge.net/ for information about dtach.\n\n"
+  end
+
+  desc 'Install dtach 0.8 from source'
+  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 #{INSTALL_DIR}/dtach-0.8/dtach #{bin_dir}"
+  end
+
+  task :make do
+    sh "cd #{INSTALL_DIR}/dtach-0.8/ && ./configure && make"
+  end
+
+  desc "Download package"
+  task :download do
+    unless File.exists?("#{INSTALL_DIR}/dtach-0.8.tar.gz")
+      require 'net/http'
+
+      url = 'http://downloads.sourceforge.net/project/dtach/dtach/0.8/dtach-0.8.tar.gz'
+      open("#{INSTALL_DIR}/dtach-0.8.tar.gz", 'wb') do |file| file.write(open(url).read) end
+    end
+
+    unless File.directory?("#{INSTALL_DIR}/dtach-0.8")
+      sh "cd #{INSTALL_DIR} && tar xzf dtach-0.8.tar.gz"
+    end
+  end
+end

data/lib/tasks/resque.rake

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../../lib'
+require 'resque/tasks'

data/test/airbrake_test.rb

@@ -0,0 +1,27 @@
+
+require 'test_helper'
+
+begin
+  require 'airbrake'
+rescue LoadError
+  warn "Install airbrake gem to run Airbrake tests."
+end
+
+if defined? Airbrake
+  require 'resque/failure/airbrake'
+  context "Airbrake" do
+    test "should be notified of an error" do
+      exception = StandardError.new("BOOM")
+      worker = Resque::Worker.new(:test)
+      queue = "test"
+      payload = {'class' => Object, 'args' => 66}
+
+      Airbrake.expects(:notify_or_ignore).with(
+        exception,
+        :parameters => {:payload_class => 'Object', :payload_args => '66'})
+
+      backend = Resque::Failure::Airbrake.new(exception, worker, queue, payload)
+      backend.save
+    end
+  end
+end

data/test/hoptoad_test.rb

@@ -0,0 +1,26 @@
+require 'test_helper'
+
+begin
+  require 'hoptoad_notifier'
+rescue LoadError
+  warn "Install hoptoad_notifier gem to run Hoptoad tests."
+end
+
+if defined? HoptoadNotifier
+  require 'resque/failure/hoptoad'
+  context "Hoptoad" do
+    test "should be notified of an error" do
+      exception = StandardError.new("BOOM")
+      worker = Resque::Worker.new(:test)
+      queue = "test"
+      payload = {'class' => Object, 'args' => 66}
+
+      HoptoadNotifier.expects(:notify_or_ignore).with(
+        exception,
+        :parameters => {:payload_class => 'Object', :payload_args => '66'})
+
+      backend = Resque::Failure::Hoptoad.new(exception, worker, queue, payload)
+      backend.save
+    end
+  end
+end

data/test/job_hooks_test.rb

@@ -0,0 +1,423 @@
+require '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 after_enqueue" do
+  include PerformJob
+
+  class ::AfterEnqueueJob
+    @queue = :jobs
+    def self.after_enqueue_record_history(history)
+      history << :after_enqueue
+    end
+
+    def self.perform(history)
+    end
+  end
+
+  test "the after enqueue hook should run" do
+    history = []
+    @worker = Resque::Worker.new(:jobs)
+    Resque.enqueue(AfterEnqueueJob, history)
+    @worker.work(0)
+    assert_equal history, [:after_enqueue], "after_enqueue was not run"
+  end
+end
+
+
+context "Resque::Job before_enqueue" do
+  include PerformJob
+
+  class ::BeforeEnqueueJob
+    @queue = :jobs
+    def self.before_enqueue_record_history(history)
+      history << :before_enqueue
+    end
+
+    def self.perform(history)
+    end
+  end
+
+  class ::BeforeEnqueueJobAbort
+    @queue = :jobs
+    def self.before_enqueue_abort(history)
+      false
+    end
+
+    def self.perform(history)
+    end
+  end
+
+  test "the before enqueue hook should run" do
+    history = []
+    @worker = Resque::Worker.new(:jobs)
+    assert Resque.enqueue(BeforeEnqueueJob, history)
+    @worker.work(0)
+    assert_equal history, [:before_enqueue], "before_enqueue was not run"
+  end
+
+  test "a before enqueue hook that returns false should prevent the job from getting queued" do
+    history = []
+    @worker = Resque::Worker.new(:jobs)
+    assert_nil Resque.enqueue(BeforeEnqueueJobAbort, history)
+    assert_equal 0, Resque.size(:jobs)
+  end
+end
+
+context "Resque::Job after_dequeue" do
+  include PerformJob
+
+  class ::AfterDequeueJob
+    @queue = :jobs
+    def self.after_dequeue_record_history(history)
+      history << :after_dequeue
+    end
+
+    def self.perform(history)
+    end
+  end
+
+  test "the after dequeue hook should run" do
+    history = []
+    @worker = Resque::Worker.new(:jobs)
+    Resque.dequeue(AfterDequeueJob, history)
+    @worker.work(0)
+    assert_equal history, [:after_dequeue], "after_dequeue was not run"
+  end
+end
+
+
+context "Resque::Job before_dequeue" do
+  include PerformJob
+
+  class ::BeforeDequeueJob
+    @queue = :jobs
+    def self.before_dequeue_record_history(history)
+      history << :before_dequeue
+    end
+
+    def self.perform(history)
+    end
+  end
+
+  class ::BeforeDequeueJobAbort
+    @queue = :jobs
+    def self.before_dequeue_abort(history)
+      false
+    end
+
+    def self.perform(history)
+    end
+  end
+
+  test "the before dequeue hook should run" do
+    history = []
+    @worker = Resque::Worker.new(:jobs)
+    Resque.dequeue(BeforeDequeueJob, history)
+    @worker.work(0)
+    assert_equal history, [:before_dequeue], "before_dequeue was not run"
+  end
+
+  test "a before dequeue hook that returns false should prevent the job from getting dequeued" do
+    history = []
+    assert_equal nil, Resque.dequeue(BeforeDequeueJobAbort, history)
+  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