opengotham_resque 1.8.2

data/tasks/redis.rake

@@ -0,0 +1,159 @@
+# 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
+
+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 'Install the latest verison of Redis from Github (requires git, duh)'
+  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 /tmp/redis/#{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 /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 /tmp/redis && make clean"
+    sh "cd /tmp/redis && make"
+  end
+
+  desc "Download package"
+  task :download do
+    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
+
+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 /tmp/dtach-0.8/dtach #{bin_dir}"
+  end
+
+  task :make do
+    sh 'cd /tmp/dtach-0.8/ && ./configure && make'
+  end
+
+  desc "Download package"
+  task :download do
+    unless File.exists?('/tmp/dtach-0.8.tar.gz')
+      require 'net/http'
+
+      url = 'http://downloads.sourceforge.net/project/dtach/dtach/0.8/dtach-0.8.tar.gz'
+      open('/tmp/dtach-0.8.tar.gz', 'wb') do |file| file.write(open(url).read) end
+    end
+
+    unless File.directory?('/tmp/dtach-0.8')
+      sh 'cd /tmp && tar xzf dtach-0.8.tar.gz'
+    end
+  end
+end
+

data/tasks/resque.rake

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

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
+