delayed_job_on_steroids 1.7.5 → 2.0.0

data/lib/delayed_on_steroids/job_deprecations.rb

@@ -0,0 +1,19 @@
+module Delayed
+  module JobDeprecations
+    def self.move_methods_to_worker(*old_methods)
+      old_methods.each do |old_method|
+        new_method = old_method.to_s.gsub("worker_", "").to_sym
+        define_method(old_method) do |*args|
+          warn "#{caller[0]}: Job's #{old_method} is deprecated. Use Worker.#{new_method} instead."
+          Worker.send(new_method, *args)
+        end
+      end
+    end
+
+    move_methods_to_worker :min_priority,        :min_priority=
+    move_methods_to_worker :max_priority,        :max_priority=
+    move_methods_to_worker :job_types,           :job_types=
+    move_methods_to_worker :destroy_failed_jobs, :destroy_failed_jobs=
+    move_methods_to_worker :worker_name,         :worker_name=
+  end
+end

data/lib/{delayed → delayed_on_steroids}/message_sending.rb

@@ -1,7 +1,11 @@
 module Delayed
   module MessageSending
     def send_later(method, *args)
-      Delayed::Job.enqueue Delayed::PerformableMethod.new(self, method.to_sym, args)
+      Delayed::Job.enqueue(Delayed::PerformableMethod.new(self, method.to_sym, args))
+    end
+
+    def send_at(time, method, *args)
+      Delayed::Job.enqueue(Delayed::PerformableMethod.new(self, method.to_sym, args), 0, time)
     end
     
     module ClassMethods

data/lib/delayed_on_steroids/tasks.rb

@@ -0,0 +1,28 @@
+# Re-definitions are appended to existing tasks
+task :environment
+
+namespace :jobs do
+
+  namespace :clear do
+    desc "Remove failed jobs from delayed_job queue"
+    task :failed => [:environment] do
+      Delayed::Job.delete_all("failed_at IS NOT NULL")
+    end
+
+    desc "Clear entire delayed_job queue"
+    task :all => [:environment] do
+      Delayed::Job.delete_all
+    end
+  end
+
+  # Deprecated synonim
+  task :clear => ['clear:all']
+
+  desc "Report delayed_job statistics"
+  task :stats => [:environment] do
+    jobs = Delayed::Job.all
+    puts "Active jobs        : #{ jobs.count{ |job| job.locked? } }"
+    puts "Scheduled jobs     : #{ jobs.count{ |job| not (job.locked? or job.failed?) } }"
+    puts "Failed stored jobs : #{ jobs.count{ |job| job.failed? } }"
+  end
+end

data/lib/delayed_on_steroids/worker.rb

@@ -0,0 +1,56 @@
+module Delayed
+  class Worker
+    include Singleton
+
+    SLEEP = 5
+
+    cattr_accessor :logger
+    @@logger = Rails.logger if defined?(Rails)
+
+    cattr_accessor :min_priority, :max_priority
+    cattr_accessor :job_types
+
+    # Every worker should has a unique name. If you start worker via +delayed_job+ script, name will be generated
+    # automatically based on the hostname and the pid of the process.
+    # There is advantage to assign name manually:
+    # workers can safely resume working on tasks which are locked by themselves (the worker will assume that it crashed before).
+    cattr_accessor :name
+
+    # 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
+    @@destroy_failed_jobs = true
+
+    # Starts worker
+    def start
+      @@logger.info("* [#{@@name}] Starting job worker...")
+
+      trap('TERM') { @@logger.info("* [#{@@name}] Exiting..."); $exit = true }
+      trap('INT')  { @@logger.info("* [#{@@name}] Exiting..."); $exit = true }
+
+      loop do
+        result = nil
+
+        realtime = Benchmark.realtime do
+          result = Delayed::Job.work_off
+        end
+
+        count = result.sum
+
+        break if $exit
+
+        if count.zero?
+          sleep(SLEEP)
+        else
+          @@logger.info("* [#{@@name}] #{count} jobs processed at %.4f j/s, %d failed..." % [count / realtime, result.last])
+        end
+
+        break if $exit
+      end
+
+    ensure
+      # When a worker is exiting, make sure we don't have any locked jobs.
+      Delayed::Job.update_all("locked_by = null, locked_at = null", ["locked_by = ?", @@name])
+    end
+  end
+end

data/spec/database.rb

@@ -7,26 +7,35 @@ gem 'sqlite3-ruby'
 
 require File.dirname(__FILE__) + '/../init'
 require 'spec'
-  
-ActiveRecord::Base.logger = Logger.new('/tmp/dj.log')
+
+Delayed::Worker.logger = Logger.new('/tmp/dj.log')
 ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => '/tmp/jobs.sqlite')
 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.string   :job_type
+    table.integer  :priority,  :null => false, :default => 0
+    table.integer  :attempts,  :null => false, :default => 0
+    table.text     :handler,   :null => false
+    table.string   :job_type,  :null => false
+    table.string   :job_tag
     table.string   :last_error
-    table.datetime :run_at
+    table.datetime :run_at,    :null => false
     table.datetime :locked_at
     table.string   :locked_by
     table.datetime :failed_at
     table.timestamps
   end
 
+  add_index :delayed_jobs, [:priority, :run_at]
+  add_index :delayed_jobs, :job_type
+  add_index :delayed_jobs, :job_tag
+  add_index :delayed_jobs, :run_at
+  add_index :delayed_jobs, :locked_at
+  add_index :delayed_jobs, :locked_by
+  add_index :delayed_jobs, :failed_at
+
   create_table :stories, :force => true do |table|
     table.string :text
   end
@@ -36,8 +45,8 @@ end
 
 # Purely useful for test cases...
 class Story < ActiveRecord::Base
-  def tell; text; end       
+  def tell; text; end
   def whatever(n, _); tell*n; end
-  
+
   handle_asynchronously :whatever
 end

data/spec/delayed_method_spec.rb

@@ -37,7 +37,10 @@ class StoryReader
 end
 
 describe 'random ruby objects' do
-  before       { Delayed::Job.delete_all }
+  before do
+    Delayed::Worker.name = 'worker'
+    Delayed::Job.delete_all
+  end
 
   it "should respond_to :send_later method" do
 
@@ -78,7 +81,7 @@ describe 'random ruby objects' do
 
     Delayed::Job.count.should == 1
 
-    Delayed::Job.reserve_and_run_one_job
+    Delayed::Job.reserve_and_run_one_job.should == true
 
     Delayed::Job.count.should == 0
 
@@ -125,4 +128,26 @@ describe 'random ruby objects' do
     job.payload_object.perform.should == 'Once upon...'
   end
 
+  context "send_at" do
+    it "should queue a new job" do
+      lambda do
+        "string".send_at(1.hour.from_now, :length)
+      end.should change { Delayed::Job.count }.by(1)
+    end
+    
+    it "should schedule the job in the future" do
+      time = 1.hour.from_now
+      job = "string".send_at(time, :length)
+      job.run_at.should == time
+    end
+    
+    it "should store payload as PerformableMethod" do
+      job = "string".send_at(1.hour.from_now, :count, 'r')
+      job.payload_object.class.should   == Delayed::PerformableMethod
+      job.payload_object.method.should  == :count
+      job.payload_object.args.should    == ['r']
+      job.payload_object.perform.should == 1
+    end
+  end
+
 end

data/spec/job_spec.rb

@@ -8,28 +8,38 @@ end
 class ErrorJob
   cattr_accessor :runs; self.runs = 0
   def perform; raise 'did not work'; end
-end             
+end
+
+class LongRunningJob
+  def perform; sleep 250; end
+end
 
 module M
   class ModuleJob
     cattr_accessor :runs; self.runs = 0
-    def perform; @@runs += 1; end    
+    def perform; @@runs += 1; end
   end
-  
 end
 
 describe Delayed::Job do
-  before  do               
-    Delayed::Job.max_priority = nil
-    Delayed::Job.min_priority = nil      
-    
+  before  do
+    Delayed::Worker.max_priority = nil
+    Delayed::Worker.min_priority = nil
+
     Delayed::Job.delete_all
   end
-  
+
   before(:each) do
     SimpleJob.runs = 0
   end
 
+  it "responds to deprecated methods moved to Worker" do
+    Delayed::JobDeprecations.instance_methods.each do |m|
+      Delayed::Job.respond_to?(m).should == true
+      silence_warnings { Delayed::Job.send(m) } unless m.to_s =~ /=$/
+    end
+  end
+
   it "should set run_at automatically if not set" do
     Delayed::Job.create(:payload_object => ErrorJob.new ).run_at.should_not == nil
   end
@@ -73,25 +83,29 @@ describe Delayed::Job do
   it "should work on specified job types" do
     SimpleJob.runs.should == 0
 
-    Delayed::Job.job_types = "SimpleJob"
+    Delayed::Worker.job_types = "SimpleJob"
     Delayed::Job.enqueue SimpleJob.new
     Delayed::Job.work_off
 
     SimpleJob.runs.should == 1
 
-    Delayed::Job.job_types = nil
+    Delayed::Worker.job_types = nil
   end
 
   it "should not work on unspecified job types" do
     SimpleJob.runs.should == 0
 
-    Delayed::Job.job_types = "AnotherJob"
+    Delayed::Worker.job_types = "AnotherJob"
     Delayed::Job.enqueue SimpleJob.new
     Delayed::Job.work_off
 
     SimpleJob.runs.should == 0
 
-    Delayed::Job.job_types = nil
+    Delayed::Worker.job_types = nil
+  end
+
+  it "should allow to specify job tag" do
+    Delayed::Job.create(:payload_object => ErrorJob.new, :job_tag => 'my tag' ).job_tag.should == 'my tag'
   end
 
   it "should work with eval jobs" do
@@ -106,7 +120,7 @@ describe Delayed::Job do
 
     $eval_job_ran.should == true
   end
-                   
+
   it "should work with jobs in modules" do
     M::ModuleJob.runs.should == 0
 
@@ -115,7 +129,7 @@ describe Delayed::Job do
 
     M::ModuleJob.runs.should == 1
   end
-                   
+
   it "should re-schedule by about 1 second at first and increment this more and more minutes when it fails to execute properly" do
     Delayed::Job.enqueue ErrorJob.new
     Delayed::Job.work_off(1)
@@ -170,28 +184,52 @@ describe Delayed::Job do
     job.should_receive(:attempt_to_load).with('Delayed::JobThatDoesNotExist').and_return(true)
     lambda { job.payload_object.perform }.should raise_error(Delayed::DeserializationError)
   end
-  
-  it "should be failed if it failed more than MAX_ATTEMPTS times and we don't want to destroy jobs" do
-    default = Delayed::Job.destroy_failed_jobs
-    Delayed::Job.destroy_failed_jobs = false
 
-    @job = Delayed::Job.create :payload_object => SimpleJob.new, :attempts => 50
-    @job.reload.failed_at.should == nil
-    @job.reschedule 'FAIL'
-    @job.reload.failed_at.should_not == nil
+  context "reschedule" do
+    before do
+      @job = Delayed::Job.create :payload_object => SimpleJob.new
+    end
 
-    Delayed::Job.destroy_failed_jobs = default
-  end
+    context "and we want to destroy jobs" do
+      before do
+        Delayed::Worker.destroy_failed_jobs = true
+      end
 
-  it "should be destroyed if it failed more than MAX_ATTEMPTS times and we want to destroy jobs" do
-    default = Delayed::Job.destroy_failed_jobs
-    Delayed::Job.destroy_failed_jobs = true
+      it "should be destroyed if it failed more than MAX_ATTEMPTS times" do
+        @job.should_receive(:destroy)
+        Delayed::Job::MAX_ATTEMPTS.times { @job.reschedule 'FAIL' }
+      end
+
+      it "should not be destroyed if failed fewer than MAX_ATTEMPTS times" do
+        @job.should_not_receive(:destroy)
+        (Delayed::Job::MAX_ATTEMPTS - 1).times { @job.reschedule 'FAIL' }
+      end
+    end
 
-    @job = Delayed::Job.create :payload_object => SimpleJob.new, :attempts => 50
-    @job.should_receive(:destroy)
-    @job.reschedule 'FAIL'
+    context "and we don't want to destroy jobs" do
+      before do
+        Delayed::Worker.destroy_failed_jobs = false
+      end
+
+      it "should be failed if it failed more than MAX_ATTEMPTS times" do
+        @job.reload.failed_at.should == nil
+        Delayed::Job::MAX_ATTEMPTS.times { @job.reschedule 'FAIL' }
+        @job.reload.failed?.should == true
+      end
 
-    Delayed::Job.destroy_failed_jobs = default
+      it "should not be failed if it failed fewer than MAX_ATTEMPTS times" do
+        (Delayed::Job::MAX_ATTEMPTS - 1).times { @job.reschedule 'FAIL' }
+        @job.reload.failed?.should == false
+      end
+
+    end
+  end
+
+  it "should fail after MAX_RUN_TIME" do
+    @job = Delayed::Job.create :payload_object => LongRunningJob.new
+    Delayed::Job.reserve_and_run_one_job(1.second)
+    @job.reload.last_error.should =~ /expired/
+    @job.attempts.should == 1
   end
 
   it "should never find failed jobs" do
@@ -202,7 +240,7 @@ describe Delayed::Job do
   context "when another worker is already performing an task, it" do
 
     before :each do
-      Delayed::Job.worker_name = 'worker1'
+      Delayed::Worker.name = 'worker1'
       @job = Delayed::Job.create :payload_object => SimpleJob.new, :locked_by => 'worker1', :locked_at => Delayed::Job.db_time_now - 5.minutes
     end
 
@@ -212,26 +250,27 @@ describe Delayed::Job do
 
     it "should allow a second worker to get exclusive access if the timeout has passed" do
       @job.lock_exclusively!(1.minute, 'worker2').should == true
-    end      
-    
+    end
+
     it "should be able to get access to the task if it was started more then MAX_RUN_TIME ago" do
       @job.locked_at = Delayed::Job.db_time_now - 5.hours
       @job.save
 
       @job.lock_exclusively!(4.hours, 'worker2').should == true
       @job.reload
+      @job.locked?.should == true
       @job.locked_by.should == 'worker2'
       @job.locked_at.should > 1.minute.ago
     end
 
     it "should not be found by another worker" do
-      Delayed::Job.worker_name = 'worker2'
+      Delayed::Worker.name = 'worker2'
 
       Delayed::Job.find_available(1, 6.minutes).length.should == 0
     end
 
     it "should be found by another worker if the time has expired" do
-      Delayed::Job.worker_name = 'worker2'
+      Delayed::Worker.name = 'worker2'
 
       Delayed::Job.find_available(1, 4.minutes).length.should == 1
     end
@@ -240,52 +279,71 @@ describe Delayed::Job do
       @job.lock_exclusively! 5.minutes, 'worker1'
       @job.lock_exclusively! 5.minutes, 'worker1'
       @job.lock_exclusively! 5.minutes, 'worker1'
-    end                                        
-  end            
-  
+    end
+  end
+
+  context "when another worker has worked on a task since the job was found to be available, it" do
+
+    before :each do
+      Delayed::Worker.name = 'worker1'
+      @job = Delayed::Job.create :payload_object => SimpleJob.new
+      @job_copy_for_worker_2 = Delayed::Job.find(@job.id)
+    end
+
+    it "should not allow a second worker to get exclusive access if already successfully processed by worker1" do
+      @job.delete
+      @job_copy_for_worker_2.lock_exclusively!(4.hours, 'worker2').should == false
+    end
+
+    it "should not allow a second worker to get exclusive access if failed to be processed by worker1 and run_at time is now in future (due to backing off behaviour)" do
+      @job.update_attributes(:attempts => 1, :run_at => Delayed::Job.db_time_now + 1.day)
+      @job_copy_for_worker_2.lock_exclusively!(4.hours, 'worker2').should == false
+    end
+  end
+
   context "#name" do
     it "should be the class name of the job that was enqueued" do
       Delayed::Job.create(:payload_object => ErrorJob.new ).name.should == 'ErrorJob'
     end
 
     it "should be the method that will be called if its a performable method object" do
-      Delayed::Job.send_later(:clear_locks!)
-      Delayed::Job.last.name.should == 'Delayed::Job.clear_locks!'
+      Delayed::Job.send_later(:db_time_now)
+      Delayed::Job.last.name.should == 'Delayed::Job.db_time_now'
 
     end
     it "should be the instance method that will be called if its a performable method object" do
-      story = Story.create :text => "..."                 
-      
+      story = Story.create :text => "..."
+
       story.send_later(:save)
-      
+
       Delayed::Job.last.name.should == 'Story#save'
     end
   end
-  
+
   context "worker prioritization" do
-    
+
     before(:each) do
-      Delayed::Job.max_priority = nil
-      Delayed::Job.min_priority = nil      
+      Delayed::Worker.max_priority = nil
+      Delayed::Worker.min_priority = nil
     end
-  
+
     it "should only work_off jobs that are >= min_priority" do
-      Delayed::Job.min_priority = -5
-      Delayed::Job.max_priority = 5
+      Delayed::Worker.min_priority = -5
+      Delayed::Worker.max_priority = 5
       SimpleJob.runs.should == 0
-    
+
       Delayed::Job.enqueue SimpleJob.new, -10
       Delayed::Job.enqueue SimpleJob.new, 0
       Delayed::Job.work_off
-    
+
       SimpleJob.runs.should == 1
     end
-  
+
     it "should only work_off jobs that are <= max_priority" do
-      Delayed::Job.min_priority = -5
-      Delayed::Job.max_priority = 5
+      Delayed::Worker.min_priority = -5
+      Delayed::Worker.max_priority = 5
       SimpleJob.runs.should == 0
-    
+
       Delayed::Job.enqueue SimpleJob.new, 10
       Delayed::Job.enqueue SimpleJob.new, 0
 
@@ -293,44 +351,37 @@ describe Delayed::Job do
 
       SimpleJob.runs.should == 1
     end
-    
+
     it "should fetch jobs ordered by priority" do
       NUM = 10
       NUM.times { Delayed::Job.enqueue SimpleJob.new, rand(NUM) }
       jobs = Delayed::Job.find_available(NUM)
-      ordered = true
-      jobs[0..-2].each_index do |i|
-        if (jobs[i].priority < jobs[i+1].priority)
-          ordered = false
-          break
-        end
-      end
-      ordered.should == true
+      jobs[0..-2].each_index { |i| (jobs[i].priority <= jobs[i+1].priority).should == true }
     end
-   
+
   end
-  
+
   context "when pulling jobs off the queue for processing, it" do
     before(:each) do
       @job = Delayed::Job.create(
-        :payload_object => SimpleJob.new, 
-        :locked_by => 'worker1', 
+        :payload_object => SimpleJob.new,
+        :locked_by => 'worker1',
         :locked_at => Delayed::Job.db_time_now - 5.minutes)
     end
 
     it "should leave the queue in a consistent state and not run the job if locking fails" do
-      SimpleJob.runs.should == 0     
+      SimpleJob.runs.should == 0
       @job.stub!(:lock_exclusively!).with(any_args).once.and_return(false)
       Delayed::Job.should_receive(:find_available).once.and_return([@job])
       Delayed::Job.work_off(1)
       SimpleJob.runs.should == 0
     end
-  
+
   end
-  
+
   context "while running alongside other workers that locked jobs, it" do
     before(:each) do
-      Delayed::Job.worker_name = 'worker1'
+      Delayed::Worker.name = 'worker1'
       Delayed::Job.create(:payload_object => SimpleJob.new, :locked_by => 'worker1', :locked_at => (Delayed::Job.db_time_now - 1.minutes))
       Delayed::Job.create(:payload_object => SimpleJob.new, :locked_by => 'worker2', :locked_at => (Delayed::Job.db_time_now - 1.minutes))
       Delayed::Job.create(:payload_object => SimpleJob.new)
@@ -338,14 +389,14 @@ describe Delayed::Job do
     end
 
     it "should ingore locked jobs from other workers" do
-      Delayed::Job.worker_name = 'worker3'
+      Delayed::Worker.name = 'worker3'
       SimpleJob.runs.should == 0
       Delayed::Job.work_off
       SimpleJob.runs.should == 1 # runs the one open job
     end
 
     it "should find our own jobs regardless of locks" do
-      Delayed::Job.worker_name = 'worker1'
+      Delayed::Worker.name = 'worker1'
       SimpleJob.runs.should == 0
       Delayed::Job.work_off
       SimpleJob.runs.should == 3 # runs open job plus worker1 jobs that were already locked
@@ -354,7 +405,7 @@ describe Delayed::Job do
 
   context "while running with locked and expired jobs, it" do
     before(:each) do
-      Delayed::Job.worker_name = 'worker1'
+      Delayed::Worker.name = 'worker1'
       exp_time = Delayed::Job.db_time_now - (1.minutes + Delayed::Job::MAX_RUN_TIME)
       Delayed::Job.create(:payload_object => SimpleJob.new, :locked_by => 'worker1', :locked_at => exp_time)
       Delayed::Job.create(:payload_object => SimpleJob.new, :locked_by => 'worker2', :locked_at => (Delayed::Job.db_time_now - 1.minutes))
@@ -363,14 +414,14 @@ describe Delayed::Job do
     end
 
     it "should only find unlocked and expired jobs" do
-      Delayed::Job.worker_name = 'worker3'
+      Delayed::Worker.name = 'worker3'
       SimpleJob.runs.should == 0
       Delayed::Job.work_off
       SimpleJob.runs.should == 2 # runs the one open job and one expired job
     end
 
     it "should ignore locks when finding our own jobs" do
-      Delayed::Job.worker_name = 'worker1'
+      Delayed::Worker.name = 'worker1'
       SimpleJob.runs.should == 0
       Delayed::Job.work_off
       SimpleJob.runs.should == 3 # runs open job plus worker1 jobs
@@ -382,9 +433,9 @@ describe Delayed::Job do
   context "db_time_now" do
     it "should return time in current time zone if set" do
       Time.zone = 'Eastern Time (US & Canada)'
-      Delayed::Job.db_time_now.zone.should match /EST|EDT/
+      Delayed::Job.db_time_now.zone.should match(/EST|EDT/)
     end
-    
+
     it "should return UTC time if that is the AR default" do
       Time.zone = nil
       ActiveRecord::Base.default_timezone = :utc
@@ -397,5 +448,5 @@ describe Delayed::Job do
       Delayed::Job.db_time_now.zone.should_not == 'UTC'
     end
   end
-  
+
 end