delayed_job 2.1.0.pre → 2.1.0.pre2

data/lib/delayed/command.rb

@@ -10,7 +10,7 @@ module Delayed
       @files_to_reopen = []
       @options = {
         :quiet => true,
-        :pid_dir => "#{RAILS_ROOT}/tmp/pids"
+        :pid_dir => "#{Rails.root}/tmp/pids"
       }
       
       @worker_count = 1
@@ -80,18 +80,18 @@ module Delayed
     end
     
     def run(worker_name = nil)
-      Dir.chdir(RAILS_ROOT)
+      Dir.chdir(Rails.root)
       
       # Re-open file handles
       @files_to_reopen.each do |file|
         begin
-          file.reopen file.path
+          file.reopen file.path, "a+"
           file.sync = true
         rescue ::Exception
         end
       end
       
-      Delayed::Worker.logger = Logger.new(File.join(RAILS_ROOT, 'log', 'delayed_job.log'))
+      Delayed::Worker.logger = Logger.new(File.join(Rails.root, 'log', 'delayed_job.log'))
       Delayed::Worker.backend.after_fork
       
       worker = Delayed::Worker.new(@options)

data/lib/delayed/message_sending.rb

@@ -1,4 +1,5 @@
 require 'active_support/basic_object'
+require 'active_support/core_ext/module/aliasing'
 
 module Delayed
   class DelayProxy < ActiveSupport::BasicObject
@@ -6,14 +7,15 @@ module Delayed
       @target = target
       @options = options
     end
-    
+
     def method_missing(method, *args)
-      Job.create @options.merge(
-        :payload_object => PerformableMethod.new(@target, method.to_sym, args)
-      )
+      Job.create({
+        :payload_object => PerformableMethod.new(@target, method.to_sym, args),
+        :priority       => ::Delayed::Worker.default_priority
+      }.merge(@options))
     end
   end
-  
+
   module MessageSending
     def delay(options = {})
       DelayProxy.new(self, options)
@@ -41,4 +43,4 @@ module Delayed
       end
     end
   end                               
-end
+end

data/lib/delayed/performable_method.rb

@@ -1,7 +1,7 @@
 module Delayed
   class PerformableMethod < Struct.new(:object, :method, :args)
     def initialize(object, method, args)
-      raise NoMethodError, "undefined method `#{method}' for #{object.inspect}" unless object.respond_to?(method)
+      raise NoMethodError, "undefined method `#{method}' for #{object.inspect}" unless object.respond_to?(method, true)
 
       self.object = object
       self.args   = args
@@ -15,5 +15,13 @@ module Delayed
     def perform
       object.send(method, *args) if object
     end
+    
+    def method_missing(symbol, *args)
+      object.respond_to?(symbol) ? object.send(symbol, *args) : super
+    end
+       
+    def respond_to?(symbol, include_private=false)
+      object.respond_to?(symbol, include_private) || super
+    end    
   end
 end

data/lib/delayed/tasks.rb

@@ -1,15 +1,11 @@
-# Re-definitions are appended to existing tasks
-task :environment
-task :merb_env
-
 namespace :jobs do
   desc "Clear the delayed_job queue."
-  task :clear => [:merb_env, :environment] do
+  task :clear => :environment do
     Delayed::Job.delete_all
   end
 
   desc "Start a delayed_job worker."
-  task :work => [:merb_env, :environment] do
+  task :work => :environment do
     Delayed::Worker.new(:min_priority => ENV['MIN_PRIORITY'], :max_priority => ENV['MAX_PRIORITY']).start
   end
 end

data/lib/delayed/worker.rb

@@ -2,21 +2,23 @@ require 'timeout'
 require 'active_support/core_ext/numeric/time'
 require 'active_support/core_ext/class/attribute_accessors'
 require 'active_support/core_ext/kernel'
+require 'logger'
 
 module Delayed
   class Worker
-    cattr_accessor :min_priority, :max_priority, :max_attempts, :max_run_time, :sleep_delay, :logger
+    cattr_accessor :min_priority, :max_priority, :max_attempts, :max_run_time, :default_priority, :sleep_delay, :logger
     self.sleep_delay = 5
     self.max_attempts = 25
     self.max_run_time = 4.hours
+    self.default_priority = 0
     
     # By default failed jobs are destroyed after too many attempts. If you want to keep them around
     # (perhaps to inspect the reason for the failure), set this to false.
     cattr_accessor :destroy_failed_jobs
     self.destroy_failed_jobs = true
     
-    self.logger = if defined?(Merb::Logger)
-      Merb.logger
+    self.logger = if defined?(Rails)
+      Rails.logger
     elsif defined?(RAILS_DEFAULT_LOGGER)
       RAILS_DEFAULT_LOGGER
     end
@@ -36,14 +38,7 @@ module Delayed
     end
     
     def self.guess_backend
-      self.backend ||= if defined?(ActiveRecord)
-        :active_record
-      elsif defined?(MongoMapper)
-        :mongo_mapper
-      else
-        logger.warn "Could not decide on a backend, defaulting to active_record"
-        :active_record
-      end
+      self.backend ||= :active_record if defined?(ActiveRecord)
     end
 
     def initialize(options={})
@@ -142,7 +137,12 @@ module Delayed
 
         if job.payload_object.respond_to? :on_permanent_failure
           say "Running on_permanent_failure hook"
-          job.payload_object.on_permanent_failure
+          failure_method = job.payload_object.method(:on_permanent_failure)
+          if failure_method.arity == 1
+            failure_method.call(job)
+          else
+            failure_method.call
+          end
         end
 
         self.class.destroy_failed_jobs ? job.destroy : job.update_attributes(:failed_at => Delayed::Job.db_time_now)

data/lib/delayed_job.rb

@@ -9,7 +9,3 @@ require File.dirname(__FILE__) + '/delayed/railtie' if defined?(::Rails::Railtie
 
 Object.send(:include, Delayed::MessageSending)   
 Module.send(:include, Delayed::MessageSending::ClassMethods)
-
-if defined?(Merb::Plugins)
-  Merb::Plugins.add_rakefiles File.dirname(__FILE__) / 'delayed' / 'tasks'
-end

data/spec/{backend/active_record_job_spec.rb → active_record_job_spec.rb}

@@ -1,22 +1,12 @@
 require 'spec_helper'
-require 'backend/shared_backend_spec'
 require 'delayed/backend/active_record'
 
 describe Delayed::Backend::ActiveRecord::Job do
-  before(:all) do
-    @backend = Delayed::Backend::ActiveRecord::Job
-  end
-  
-  before(:each) do
-    Delayed::Backend::ActiveRecord::Job.delete_all
-    SimpleJob.runs = 0
-  end
-  
   after do
     Time.zone = nil
   end
   
-  it_should_behave_like 'a backend'
+  it_should_behave_like 'a delayed_job backend'
 
   context "db_time_now" do
     it "should return time in current time zone if set" do

data/spec/message_sending_spec.rb

@@ -33,7 +33,14 @@ describe Delayed::MessageSending do
         job.payload_object.args.should    == ['l']
       }.should change { Delayed::Job.count }.by(1)
     end
-  
+
+    it "should set default priority" do
+      Delayed::Worker.default_priority = 99
+      job = Object.delay.to_s
+      job.priority.should == 99
+      Delayed::Worker.default_priority = 0
+    end
+
     it "should set job options" do
       run_at = Time.parse('2010-05-03 12:55 AM')
       job = Object.delay(:priority => 20, :run_at => run_at).to_s

data/spec/performable_method_spec.rb

@@ -20,11 +20,29 @@ describe Delayed::PerformableMethod do
       @method.object.should_receive(:count).with('o')
       @method.perform
     end
+    
+    it "should respond to on_permanent_failure when implemented and target object is called via object.delay.do_something" do
+      @method = Delayed::PerformableMethod.new(OnPermanentFailureJob.new, :perform, [])
+      @method.respond_to?(:on_permanent_failure).should be_true
+      @method.object.should_receive(:on_permanent_failure)
+      @method.on_permanent_failure
+    end    
   end
 
-  it "should raise a ArgumentError if target method doesn't exist" do
+  it "should raise a NoMethodError if target method doesn't exist" do
     lambda {
       Delayed::PerformableMethod.new(Object, :method_that_does_not_exist, [])
     }.should raise_error(NoMethodError)
   end
+  
+  it "should not raise NoMethodError if target method is private" do
+    clazz = Class.new do
+      def private_method
+      end
+      private :private_method
+    end
+    lambda {
+      Delayed::PerformableMethod.new(clazz.new, :private_method, [])
+    }.should_not raise_error(NoMethodError)
+  end
 end

data/spec/sample_jobs.rb

@@ -1,3 +1,9 @@
+class NamedJob < Struct.new(:perform)
+  def display_name
+    'named_job'
+  end
+end
+
 class SimpleJob
   cattr_accessor :runs; self.runs = 0
   def perform; @@runs += 1; end
@@ -23,3 +29,33 @@ module M
     def perform; @@runs += 1; end    
   end
 end
+
+class SuccessfulCallbackJob
+  cattr_accessor :messages
+
+  def before(job)
+    SuccessfulCallbackJob.messages << 'before perform'
+  end
+  
+  def perform
+    SuccessfulCallbackJob.messages << 'perform'
+  end
+  
+  def after(job, error = nil)
+    SuccessfulCallbackJob.messages << 'after perform'
+  end
+  
+  def success(job)
+    SuccessfulCallbackJob.messages << 'success!'
+  end
+  
+  def failure(job, error)
+    SuccessfulCallbackJob.messages << "error: #{error.class}"
+  end
+end
+
+class FailureCallbackJob < SuccessfulCallbackJob
+  def perform
+     raise "failure job"
+  end
+end

data/spec/spec_helper.rb

@@ -1,31 +1,53 @@
 $:.unshift(File.dirname(__FILE__) + '/../lib')
 
 require 'rubygems'
+require 'bundler/setup'
 require 'spec'
 require 'logger'
 
 gem 'activerecord', ENV['RAILS_VERSION'] if ENV['RAILS_VERSION']
 
 require 'delayed_job'
-require 'sample_jobs'
+require 'delayed/backend/shared_spec'
 
 Delayed::Worker.logger = Logger.new('/tmp/dj.log')
 RAILS_ENV = 'test'
 
-# determine the available backends
-BACKENDS = []
-Dir.glob("#{File.dirname(__FILE__)}/setup/*.rb") do |backend|
-  begin
-    backend = File.basename(backend, '.rb')
-    require "setup/#{backend}"
-    require "backend/#{backend}_job_spec"
-    BACKENDS << backend.to_sym
-  rescue Exception
-    puts "Unable to load #{backend} backend: #{$!}"
+require 'active_record'
+
+ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
+ActiveRecord::Base.logger = Delayed::Worker.logger
+ActiveRecord::Migration.verbose = false
+
+ActiveRecord::Schema.define do
+  create_table :delayed_jobs, :force => true do |table|
+    table.integer  :priority, :default => 0
+    table.integer  :attempts, :default => 0
+    table.text     :handler
+    table.text     :last_error
+    table.datetime :run_at
+    table.datetime :locked_at
+    table.datetime :failed_at
+    table.string   :locked_by
+    table.timestamps
   end
+
+  add_index :delayed_jobs, [:priority, :run_at], :name => 'delayed_jobs_priority'
+
+  create_table :stories, :force => true do |table|
+    table.string :text
+  end
+end
+
+# Purely useful for test cases...
+class Story < ActiveRecord::Base
+  def tell; text; end       
+  def whatever(n, _); tell*n; end
+  
+  handle_asynchronously :whatever
 end
 
-Delayed::Worker.backend = BACKENDS.first
+Delayed::Worker.backend = :active_record
 
 # Add this directory so the ActiveSupport autoloading works
-ActiveSupport::Dependencies.load_paths << File.dirname(__FILE__)
+ActiveSupport::Dependencies.autoload_paths << File.dirname(__FILE__)

data/spec/worker_spec.rb

@@ -1,10 +1,6 @@
 require 'spec_helper'
 
 describe Delayed::Worker do
-  def job_create(opts = {})
-    Delayed::Job.create(opts.merge(:payload_object => SimpleJob.new))
-  end
-
   describe "backend=" do
     before do
       @clazz = Class.new
@@ -14,201 +10,28 @@ describe Delayed::Worker do
     it "should set the Delayed::Job constant to the backend" do
       Delayed::Job.should == @clazz
     end
-    
+
     it "should set backend with a symbol" do
       Delayed::Worker.backend = :active_record
       Delayed::Worker.backend.should == Delayed::Backend::ActiveRecord::Job
     end
   end
-  
-  BACKENDS.each do |backend|
-    describe "with the #{backend} backend" do
-      before do
-        Delayed::Worker.backend = backend
-        Delayed::Job.delete_all
-
-        @worker = Delayed::Worker.new(:max_priority => nil, :min_priority => nil, :quiet => true)
-
-        SimpleJob.runs = 0
-      end
-  
-      describe "running a job" do
-        it "should fail after Worker.max_run_time" do
-          begin
-            old_max_run_time = Delayed::Worker.max_run_time
-            Delayed::Worker.max_run_time = 1.second
-            @job = Delayed::Job.create :payload_object => LongRunningJob.new
-            @worker.run(@job)
-            @job.reload.last_error.should =~ /expired/
-            @job.attempts.should == 1
-          ensure
-            Delayed::Worker.max_run_time = old_max_run_time
-          end
-        end
-      end
-  
-      context "worker prioritization" do
-        before(:each) do
-          @worker = Delayed::Worker.new(:max_priority => 5, :min_priority => -5, :quiet => true)
-        end
-
-        it "should only work_off jobs that are >= min_priority" do
-          job_create(:priority => -10)
-          job_create(:priority => 0)
-          @worker.work_off
-
-          SimpleJob.runs.should == 1
-        end
-
-        it "should only work_off jobs that are <= max_priority" do
-          job_create(:priority => 10)
-          job_create(:priority => 0)
-
-          @worker.work_off
-
-          SimpleJob.runs.should == 1
-        end
-      end
-
-      context "while running with locked and expired jobs" do
-        before(:each) do
-          @worker.name = 'worker1'
-        end
-    
-        it "should not run jobs locked by another worker" do
-          job_create(:locked_by => 'other_worker', :locked_at => (Delayed::Job.db_time_now - 1.minutes))
-          lambda { @worker.work_off }.should_not change { SimpleJob.runs }
-        end
-    
-        it "should run open jobs" do
-          job_create
-          lambda { @worker.work_off }.should change { SimpleJob.runs }.from(0).to(1)
-        end
-    
-        it "should run expired jobs" do
-          expired_time = Delayed::Job.db_time_now - (1.minutes + Delayed::Worker.max_run_time)
-          job_create(:locked_by => 'other_worker', :locked_at => expired_time)
-          lambda { @worker.work_off }.should change { SimpleJob.runs }.from(0).to(1)
-        end
-    
-        it "should run own jobs" do
-          job_create(:locked_by => @worker.name, :locked_at => (Delayed::Job.db_time_now - 1.minutes))
-          lambda { @worker.work_off }.should change { SimpleJob.runs }.from(0).to(1)
-        end
-      end
-  
-      describe "failed jobs" do
-        before do
-          # reset defaults
-          Delayed::Worker.destroy_failed_jobs = true
-          Delayed::Worker.max_attempts = 25
 
-          @job = Delayed::Job.enqueue ErrorJob.new
-        end
-
-        it "should record last_error when destroy_failed_jobs = false, max_attempts = 1" do
-          Delayed::Worker.destroy_failed_jobs = false
-          Delayed::Worker.max_attempts = 1
-          @worker.run(@job)
-          @job.reload
-          @job.last_error.should =~ /did not work/
-          @job.last_error.should =~ /worker_spec.rb/
-          @job.attempts.should == 1
-          @job.failed_at.should_not be_nil
-        end
-    
-        it "should re-schedule jobs after failing" do
-          @worker.run(@job)
-          @job.reload
-          @job.last_error.should =~ /did not work/
-          @job.last_error.should =~ /sample_jobs.rb:8:in `perform'/
-          @job.attempts.should == 1
-          @job.run_at.should > Delayed::Job.db_time_now - 10.minutes
-          @job.run_at.should < Delayed::Job.db_time_now + 10.minutes
-        end
-      end
-  
-      context "reschedule" do
-        before do
-          @job = Delayed::Job.create :payload_object => SimpleJob.new
-        end
-   
-        share_examples_for "any failure more than Worker.max_attempts times" do
-          context "when the job's payload has an #on_permanent_failure hook" do
-            before do
-              @job = Delayed::Job.create :payload_object => OnPermanentFailureJob.new
-              @job.payload_object.should respond_to :on_permanent_failure
-            end
-
-            it "should run that hook" do
-              @job.payload_object.should_receive :on_permanent_failure
-              Delayed::Worker.max_attempts.times { @worker.reschedule(@job) }
-            end
-          end
-
-          context "when the job's payload has no #on_permanent_failure hook" do
-            # It's a little tricky to test this in a straightforward way, 
-            # because putting a should_not_receive expectation on 
-            # @job.payload_object.on_permanent_failure makes that object
-            # incorrectly return true to 
-            # payload_object.respond_to? :on_permanent_failure, which is what
-            # reschedule uses to decide whether to call on_permanent_failure.  
-            # So instead, we just make sure that the payload_object as it 
-            # already stands doesn't respond_to? on_permanent_failure, then
-            # shove it through the iterated reschedule loop and make sure we
-            # don't get a NoMethodError (caused by calling that nonexistent
-            # on_permanent_failure method).
-            
-            before do
-              @job.payload_object.should_not respond_to(:on_permanent_failure)
-            end
-
-            it "should not try to run that hook" do
-              lambda do
-                Delayed::Worker.max_attempts.times { @worker.reschedule(@job) }
-              end.should_not raise_exception(NoMethodError)
-            end
-          end
-        end
-
-        context "and we want to destroy jobs" do
-          before do
-            Delayed::Worker.destroy_failed_jobs = true
-          end
-
-          it_should_behave_like "any failure more than Worker.max_attempts times"
-
-          it "should be destroyed if it failed more than Worker.max_attempts times" do
-            @job.should_receive(:destroy)
-            Delayed::Worker.max_attempts.times { @worker.reschedule(@job) }
-          end
-      
-          it "should not be destroyed if failed fewer than Worker.max_attempts times" do
-            @job.should_not_receive(:destroy)
-            (Delayed::Worker.max_attempts - 1).times { @worker.reschedule(@job) }
-          end
-        end
-    
-        context "and we don't want to destroy jobs" do
-          before do
-            Delayed::Worker.destroy_failed_jobs = false
-          end
-      
-          it_should_behave_like "any failure more than Worker.max_attempts times"
+  describe "guess_backend" do
+    after do
+      Delayed::Worker.backend = :active_record
+    end
 
-          it "should be failed if it failed more than Worker.max_attempts times" do
-            @job.reload.failed_at.should == nil
-            Delayed::Worker.max_attempts.times { @worker.reschedule(@job) }
-            @job.reload.failed_at.should_not == nil
-          end
+    it "should set to active_record if nil" do
+      Delayed::Worker.backend = nil
+      lambda {
+        Delayed::Worker.guess_backend
+      }.should change { Delayed::Worker.backend }.to(Delayed::Backend::ActiveRecord::Job)
+    end
 
-          it "should not be failed if it failed fewer than Worker.max_attempts times" do
-            (Delayed::Worker.max_attempts - 1).times { @worker.reschedule(@job) }
-            @job.reload.failed_at.should == nil
-          end
-        end
-      end
+    it "should not override the existing backend" do
+      Delayed::Worker.backend = Class.new
+      lambda { Delayed::Worker.guess_backend }.should_not change { Delayed::Worker.backend }
     end
   end
-  
 end