delayed_job 2.1.0.pre2 → 2.1.1

data/README.textile

@@ -1,6 +1,6 @@
 h1. Delayed::Job
 
-Delated_job (or DJ) encapsulates the common pattern of asynchronously executing longer tasks in the background. 
+Delated_job (or DJ) encapsulates the common pattern of asynchronously executing longer tasks in the background.
 
 It is a direct extraction from Shopify where the job table is responsible for a multitude of core tasks. Amongst those tasks are:
 
@@ -9,31 +9,17 @@ It is a direct extraction from Shopify where the job table is responsible for a
 * http downloads
 * updating smart collections
 * updating solr, our search server, after product changes
-* batch imports 
-* spam checks 
+* batch imports
+* spam checks
 
 h2. Installation
 
-To install as a gem, add the following to @config/environment.rb@:
+delayed_job 2.1 only supports Rails 3.0+. See the "2.0 branch":https://github.com/collectiveidea/delayed_job/tree/v2.0 for Rails 2.
 
-<pre>
-config.gem 'delayed_job'
-</pre>
-
-Rake tasks are not automatically loaded from gems, so you'll need to add the following to your Rakefile:
+To install, add delayed_job to your @Gemfile@ and run `bundle install`:
 
 <pre>
-begin
-  require 'delayed/tasks'
-rescue LoadError
-  STDERR.puts "Run `rake gems:install` to install delayed_job"
-end
-</pre>
-
-To install as a plugin:
-
-<pre>
-script/plugin install git://github.com/collectiveidea/delayed_job.git
+gem 'delayed_job'
 </pre>
 
 After delayed_job is installed, you will need to setup the backend.
@@ -42,12 +28,10 @@ h2. Backends
 
 delayed_job supports multiple backends for storing the job queue. "See the wiki for other backends":http://wiki.github.com/collectiveidea/delayed_job/backends besides Active Record.
 
-h3. Active Record
-
 The default is Active Record, which requires a jobs table.
 
 <pre>
-$ script/generate delayed_job
+$ script/rails generate delayed_job
 $ rake db:migrate
 </pre>
 
@@ -60,7 +44,7 @@ Call @.delay.method(params)@ on any object and it will be processed in the backg
 Notifier.deliver_signup(@user)
 
 # with delayed_job
-Notifier.delay.deliver_signup @user
+Notifier.delay.signup(@user)
 </pre>
 
 If a method should always be run in the background, you can call @#handle_asynchronously@ after the method declaration:
@@ -77,6 +61,39 @@ device = Device.new
 device.deliver
 </pre>
 
+handle_asynchronously can take as options anything you can pass to delay. In addition the values can be Proc objects allowing call time evaluation of the value. For some examples:
+
+<pre>
+class LongTasks
+  def send_mailer
+    # Some other code
+  end
+  handle_asynchronously :send_mailer, :priority => 20
+
+  def in_the_future
+    # Some other code
+  end
+  # 5.minutes.from_now will be evaluated when in_the_future is called
+  handle_asynchronously :in_the_future, :run_at => Proc.new { 5.minutes.from_now }
+
+  def self.when_to_run
+    2.hours.from_now
+  end
+
+  def call_a_class_method
+    # Some other code
+  end
+  handle_asynchronously :call_a_class_method, :run_at => Proc.new { when_to_run }
+
+  attr_reader :how_important
+
+  def call_an_instance_method
+    # Some other code
+  end
+  handle_asynchronously :call_an_instance_method, :priority => Proc.new {|i| i.how_important }
+end
+</pre>
+
 h2. Running Jobs
 
 @script/delayed_job@ can be used to manage a background process which will start working off jobs.  Make sure you've run `script/generate delayed_job`.
@@ -92,39 +109,61 @@ $ RAILS_ENV=production script/delayed_job stop
 
 Workers can be running on any computer, as long as they have access to the database and their clock is in sync. Keep in mind that each worker will check the database at least every 5 seconds.
 
-You can also invoke @rake jobs:work@ which will start working off jobs. You can cancel the rake task with @CTRL-C@. 
+You can also invoke @rake jobs:work@ which will start working off jobs. You can cancel the rake task with @CTRL-C@.
 
 h2. Custom Jobs
 
-Jobs are simple ruby objects with a method called perform. Any object which responds to perform can be stuffed into the jobs table. Job objects are serialized to yaml so that they can later be resurrected by the job runner. 
+Jobs are simple ruby objects with a method called perform. Any object which responds to perform can be stuffed into the jobs table. Job objects are serialized to yaml so that they can later be resurrected by the job runner.
 
 <pre>
 class NewsletterJob < Struct.new(:text, :emails)
   def perform
     emails.each { |e| NewsletterMailer.deliver_text_to_email(text, e) }
-  end    
-end  
-  
+  end
+end
+
 Delayed::Job.enqueue NewsletterJob.new('lorem ipsum...', Customers.find(:all).collect(&:email))
 </pre>
 
-You can also add an optional on_permanent_failure method which will run if the job has failed too many times to be retried:
+h2. Hooks
+
+You can define hooks on your job that will be called at different stages in the process:
 
 <pre>
 class ParanoidNewsletterJob < NewsletterJob
+  def enqueue(job)
+    record_stat 'newsletter_job/enqueue'
+  end
+
   def perform
     emails.each { |e| NewsletterMailer.deliver_text_to_email(text, e) }
-  end    
+  end
+
+  def before(job)
+    record_stat 'newsletter_job/start'
+  end
 
-  def on_permanent_failure
+  def after(job)
+    record_stat 'newsletter_job/after'
+  end
+
+  def success(job)
+    record_stat 'newsletter_job/success'
+  end
+
+  def error(job, exception)
+    notify_hoptoad(exception)
+  end
+
+  def failure
     page_sysadmin_in_the_middle_of_the_night
   end
-end  
+end
 </pre>
 
 h2. Gory Details
 
-The library evolves around a delayed_jobs table which looks as follows: 
+The library evolves around a delayed_jobs table which looks as follows:
 
 <pre>
 create_table :delayed_jobs, :force => true do |table|
@@ -151,6 +190,8 @@ make sure your job doesn't exceed this time. You should set this to the longest
 By default, it will delete failed jobs (and it always deletes successful jobs). If you want to keep failed jobs, set
 Delayed::Worker.destroy_failed_jobs = false. The failed jobs will be marked with non-null failed_at.
 
+By default all jobs are scheduled with priority = 0, which is top priority. You can change this by setting Delayed::Worker.default_priority to something else. Lower numbers have higher priority.
+
 Here is an example of changing job parameters in Rails:
 
 <pre>
@@ -173,19 +214,13 @@ h2. How to contribute
 
 If you find what looks like a bug:
 
-# Check the GitHub issue tracker to see if anyone else has had the same issue.
-   http://github.com/collectiveidea/delayed_job/issues/
+# Search the "mailing list":http://groups.google.com/group/delayed_job to see if anyone else had the same issue.
+# Check the "GitHub issue tracker":http://github.com/collectiveidea/delayed_job/issues/ to see if anyone else has reported issue.
 # If you don't see anything, create an issue with information on how to reproduce it.
 
 If you want to contribute an enhancement or a fix:
 
 # Fork the project on github.
-   http://github.com/collectiveidea/delayed_job/
 # Make your changes with tests.
-# Commit the changes without making changes to the Rakefile, VERSION, or any other files that aren't related to your enhancement or fix
+# Commit the changes without making changes to the Rakefile or any other files that aren't related to your enhancement or fix
 # Send a pull request.
-
-h3. Changelog
-
-See http://wiki.github.com/collectiveidea/delayed_job/changelog for a list of changes.
-

data/lib/delayed/backend/active_record.rb

@@ -1,19 +1,5 @@
 require 'active_record'
 
-class ActiveRecord::Base
-  yaml_as "tag:ruby.yaml.org,2002:ActiveRecord"
-  
-  def self.yaml_new(klass, tag, val)
-    klass.find(val['attributes']['id'])
-  rescue ActiveRecord::RecordNotFound
-    nil
-  end
-
-  def to_yaml_properties
-    ['@attributes']
-  end
-end
-
 module Delayed
   module Backend
     module ActiveRecord
@@ -22,23 +8,20 @@ module Delayed
       class Job < ::ActiveRecord::Base
         include Delayed::Backend::Base
         set_table_name :delayed_jobs
-        
+
         before_save :set_default_run_at
 
-        if ::ActiveRecord::VERSION::MAJOR >= 3
-          scope :ready_to_run, lambda {|worker_name, max_run_time|
-            where(['(run_at <= ? AND (locked_at IS NULL OR locked_at < ?) OR locked_by = ?) AND failed_at IS NULL', db_time_now, db_time_now - max_run_time, worker_name])
-          }
-          scope :by_priority, order('priority ASC, run_at ASC')
-        else
-          named_scope :ready_to_run, lambda {|worker_name, max_run_time|
-            {:conditions => ['(run_at <= ? AND (locked_at IS NULL OR locked_at < ?) OR locked_by = ?) AND failed_at IS NULL', db_time_now, db_time_now - max_run_time, worker_name]}
-          }
-          named_scope :by_priority, :order => 'priority ASC, run_at ASC'
+        scope :ready_to_run, lambda {|worker_name, max_run_time|
+          where(['(run_at <= ? AND (locked_at IS NULL OR locked_at < ?) OR locked_by = ?) AND failed_at IS NULL', db_time_now, db_time_now - max_run_time, worker_name])
+        }
+        scope :by_priority, order('priority ASC, run_at ASC')
+
+        def self.before_fork
+          ::ActiveRecord::Base.clear_all_connections!
         end
 
         def self.after_fork
-          ::ActiveRecord::Base.connection.reconnect!
+          ::ActiveRecord::Base.establish_connection
         end
 
         # When a worker is exiting, make sure we don't have any locked jobs.
@@ -51,7 +34,7 @@ module Delayed
           scope = self.ready_to_run(worker_name, max_run_time)
           scope = scope.scoped(:conditions => ['priority >= ?', Worker.min_priority]) if Worker.min_priority
           scope = scope.scoped(:conditions => ['priority <= ?', Worker.max_priority]) if Worker.max_priority
-      
+
           ::ActiveRecord::Base.silence do
             scope.by_priority.all(:limit => limit)
           end
@@ -70,8 +53,10 @@ module Delayed
             self.class.update_all(["locked_at = ?", now], ["id = ? and locked_by = ?", id, worker])
           end
           if affected_rows == 1
-            self.locked_at    = now
-            self.locked_by    = worker
+            self.locked_at = now
+            self.locked_by = worker
+            self.locked_at_will_change!
+            self.locked_by_will_change!
             return true
           else
             return false

data/lib/delayed/backend/base.rb

@@ -1,91 +1,120 @@
 module Delayed
   module Backend
-    class DeserializationError < StandardError
-    end
-
     module Base
       def self.included(base)
         base.extend ClassMethods
       end
-      
+
       module ClassMethods
         # Add a job to the queue
         def enqueue(*args)
-          object = args.shift
-          unless object.respond_to?(:perform)
+          options = {
+            :priority => Delayed::Worker.default_priority
+          }
+
+          if args.size == 1 && args.first.is_a?(Hash)
+            options.merge!(args.first)
+          else
+            options[:payload_object]  = args.shift
+            options[:priority]        = args.first || options[:priority]
+            options[:run_at]          = args[1]
+          end
+
+          unless options[:payload_object].respond_to?(:perform)
             raise ArgumentError, 'Cannot enqueue items which do not respond to perform'
           end
-    
-          priority = args.first || Delayed::Worker.default_priority
-          run_at   = args[1]
-          self.create(:payload_object => object, :priority => priority.to_i, :run_at => run_at)
+
+          self.create(options).tap do |job|
+            job.hook(:enqueue)
+          end
+        end
+
+        def reserve(worker, max_run_time = Worker.max_run_time)
+          # We get up to 5 jobs from the db. In case we cannot get exclusive access to a job we try the next.
+          # this leads to a more even distribution of jobs across the worker processes
+          find_available(worker.name, 5, max_run_time).detect do |job|
+            job.lock_exclusively!(max_run_time, worker.name)
+          end
         end
-        
+
         # Hook method that is called before a new worker is forked
         def before_fork
         end
-        
+
         # Hook method that is called after a new worker is forked
         def after_fork
         end
-        
+
         def work_off(num = 100)
           warn "[DEPRECATION] `Delayed::Job.work_off` is deprecated. Use `Delayed::Worker.new.work_off instead."
           Delayed::Worker.new.work_off(num)
         end
       end
-      
-      ParseObjectFromYaml = /\!ruby\/\w+\:([^\s]+)/
 
       def failed?
         failed_at
       end
       alias_method :failed, :failed?
 
+      ParseObjectFromYaml = /\!ruby\/\w+\:([^\s]+)/
+
       def name
-        @name ||= begin
-          payload = payload_object
-          payload.respond_to?(:display_name) ? payload.display_name : payload.class.name
-        end
+        @name ||= payload_object.respond_to?(:display_name) ?
+                    payload_object.display_name :
+                    payload_object.class.name
+      rescue DeserializationError
+        ParseObjectFromYaml.match(handler)[1]
       end
 
       def payload_object=(object)
+        @payload_object = object
         self.handler = object.to_yaml
       end
-      
+
       def payload_object
         @payload_object ||= YAML.load(self.handler)
-      rescue TypeError, LoadError, NameError => e
-          raise DeserializationError,
-            "Job failed to load: #{e.message}. Try to manually require the required file. Handler: #{handler.inspect}"
+      rescue TypeError, LoadError, NameError, ArgumentError => e
+        raise DeserializationError,
+          "Job failed to load: #{e.message}. Handler: #{handler.inspect}"
       end
 
-      # Moved into its own method so that new_relic can trace it.
       def invoke_job
-        payload_object.before(self) if payload_object.respond_to?(:before)
-        begin
-          payload_object.perform
-          payload_object.success(self) if payload_object.respond_to?(:success)
-        rescue Exception => e
-          payload_object.failure(self, e) if payload_object.respond_to?(:failure)
-          raise e
-        ensure
-          payload_object.after(self) if payload_object.respond_to?(:after)
-        end
+        hook :before
+        payload_object.perform
+        hook :success
+      rescue Exception => e
+        hook :error, e
+        raise e
+      ensure
+        hook :after
       end
-      
+
       # Unlock this job (note: not saved to DB)
       def unlock
         self.locked_at    = nil
         self.locked_by    = nil
       end
-      
+
+      def hook(name, *args)
+        if payload_object.respond_to?(name)
+          method = payload_object.method(name)
+          method.arity == 0 ? method.call : method.call(self, *args)
+        end
+      rescue DeserializationError
+        # do nothing
+      end
+
+      def reschedule_at
+        payload_object.respond_to?(:reschedule_at) ?
+          payload_object.reschedule_at(self.class.db_time_now, attempts) :
+          self.class.db_time_now + (attempts ** 4) + 5
+      end
+
     protected
 
       def set_default_run_at
         self.run_at ||= self.class.db_time_now
       end
-    
     end
   end
 end

data/lib/delayed/backend/shared_spec.rb

@@ -12,156 +12,168 @@ shared_examples_for 'a delayed_job backend' do
     SimpleJob.runs = 0
     described_class.delete_all
   end
-  
+
   it "should set run_at automatically if not set" do
     described_class.create(:payload_object => ErrorJob.new ).run_at.should_not be_nil
   end
 
   it "should not set run_at automatically if already set" do
     later = described_class.db_time_now + 5.minutes
-    described_class.create(:payload_object => ErrorJob.new, :run_at => later).run_at.should be_close(later, 1)
+    job = described_class.create(:payload_object => ErrorJob.new, :run_at => later)
+    job.run_at.should be_within(1).of(later)
   end
-  
+
   describe "enqueue" do
-    it "should raise ArgumentError when handler doesn't respond_to :perform" do
-      lambda { described_class.enqueue(Object.new) }.should raise_error(ArgumentError)
-    end
+    context "with a hash" do
+      it "should raise ArgumentError when handler doesn't respond_to :perform" do
+        lambda { described_class.enqueue(:payload_object => Object.new) }.should raise_error(ArgumentError)
+      end
 
-    it "should increase count after enqueuing items" do
-      described_class.enqueue SimpleJob.new
-      described_class.count.should == 1
-    end
+      it "should be able to set priority" do
+        job = described_class.enqueue :payload_object => SimpleJob.new, :priority => 5
+        job.priority.should == 5
+      end
 
-    it "should be able to set priority" do
-      @job = described_class.enqueue SimpleJob.new, 5
-      @job.priority.should == 5
-    end
+      it "should use default priority" do
+        job = described_class.enqueue :payload_object => SimpleJob.new
+        job.priority.should == 99
+      end
 
-    it "should use default priority when it is not set" do
-      @job = described_class.enqueue SimpleJob.new
-      @job.priority.should == 99
+      it "should be able to set run_at" do
+        later = described_class.db_time_now + 5.minutes
+        job = described_class.enqueue :payload_object => SimpleJob.new, :run_at => later
+        job.run_at.should be_within(1).of(later)
+      end
     end
 
-    it "should be able to set run_at" do
-      later = described_class.db_time_now + 5.minutes
-      @job = described_class.enqueue SimpleJob.new, 5, later
-      @job.run_at.should be_close(later, 1)
-    end
+    context "with multiple arguments" do
+      it "should raise ArgumentError when handler doesn't respond_to :perform" do
+        lambda { described_class.enqueue(Object.new) }.should raise_error(ArgumentError)
+      end
 
-    it "should work with jobs in modules" do
-      M::ModuleJob.runs = 0
-      job = described_class.enqueue M::ModuleJob.new
-      lambda { job.invoke_job }.should change { M::ModuleJob.runs }.from(0).to(1)
+      it "should increase count after enqueuing items" do
+        described_class.enqueue SimpleJob.new
+        described_class.count.should == 1
+      end
+
+      it "should be able to set priority" do
+        @job = described_class.enqueue SimpleJob.new, 5
+        @job.priority.should == 5
+      end
+
+      it "should use default priority when it is not set" do
+        @job = described_class.enqueue SimpleJob.new
+        @job.priority.should == 99
+      end
+
+      it "should be able to set run_at" do
+        later = described_class.db_time_now + 5.minutes
+        @job = described_class.enqueue SimpleJob.new, 5, later
+        @job.run_at.should be_within(1).of(later)
+      end
+
+      it "should work with jobs in modules" do
+        M::ModuleJob.runs = 0
+        job = described_class.enqueue M::ModuleJob.new
+        lambda { job.invoke_job }.should change { M::ModuleJob.runs }.from(0).to(1)
+      end
     end
   end
-  
+
   describe "callbacks" do
     before(:each) do
-      SuccessfulCallbackJob.messages = []
-      FailureCallbackJob.messages = []
+      CallbackJob.messages = []
     end
-    
+
+    %w(before success after).each do |callback|
+      it "should call #{callback} with job" do
+        job = described_class.enqueue(CallbackJob.new)
+        job.payload_object.should_receive(callback).with(job)
+        job.invoke_job
+      end
+    end
+
     it "should call before and after callbacks" do
-      job = described_class.enqueue(SuccessfulCallbackJob.new)
+      job = described_class.enqueue(CallbackJob.new)
+      CallbackJob.messages.should == ["enqueue"]
       job.invoke_job
-      SuccessfulCallbackJob.messages.should == ["before perform", "perform", "success!", "after perform"]
+      CallbackJob.messages.should == ["enqueue", "before", "perform", "success", "after"]
     end
 
     it "should call the after callback with an error" do
-      job = described_class.enqueue(FailureCallbackJob.new)
-      lambda {job.invoke_job}.should raise_error
-      FailureCallbackJob.messages.should == ["before perform", "error: RuntimeError", "after perform"]
+      job = described_class.enqueue(CallbackJob.new)
+      job.payload_object.should_receive(:perform).and_raise(RuntimeError.new("fail"))
+
+      lambda { job.invoke_job }.should raise_error
+      CallbackJob.messages.should == ["enqueue", "before", "error: RuntimeError", "after"]
+    end
+
+    it "should call error when before raises an error" do
+      job = described_class.enqueue(CallbackJob.new)
+      job.payload_object.should_receive(:before).and_raise(RuntimeError.new("fail"))
+      lambda { job.invoke_job }.should raise_error(RuntimeError)
+      CallbackJob.messages.should == ["enqueue", "error: RuntimeError", "after"]
     end
-    
   end
-  
+
   describe "payload_object" do
     it "should raise a DeserializationError when the job class is totally unknown" do
       job = described_class.new :handler => "--- !ruby/object:JobThatDoesNotExist {}"
-      lambda { job.payload_object }.should raise_error(Delayed::Backend::DeserializationError)
+      lambda { job.payload_object }.should raise_error(Delayed::DeserializationError)
     end
 
     it "should raise a DeserializationError when the job struct is totally unknown" do
       job = described_class.new :handler => "--- !ruby/struct:StructThatDoesNotExist {}"
-      lambda { job.payload_object }.should raise_error(Delayed::Backend::DeserializationError)
+      lambda { job.payload_object }.should raise_error(Delayed::DeserializationError)
     end
-  end
-  
-  describe "find_available" do
-    it "should not find failed jobs" do
-      @job = create_job :attempts => 50, :failed_at => described_class.db_time_now
-      described_class.find_available('worker', 5, 1.second).should_not include(@job)
-    end
-    
-    it "should not find jobs scheduled for the future" do
-      @job = create_job :run_at => (described_class.db_time_now + 1.minute)
-      described_class.find_available('worker', 5, 4.hours).should_not include(@job)
-    end
-    
-    it "should not find jobs locked by another worker" do
-      @job = create_job(:locked_by => 'other_worker', :locked_at => described_class.db_time_now - 1.minute)
-      described_class.find_available('worker', 5, 4.hours).should_not include(@job)
-    end
-    
-    it "should find open jobs" do
-      @job = create_job
-      described_class.find_available('worker', 5, 4.hours).should include(@job)
-    end
-    
-    it "should find expired jobs" do
-      @job = create_job(:locked_by => 'worker', :locked_at => described_class.db_time_now - 2.minutes)
-      described_class.find_available('worker', 5, 1.minute).should include(@job)
-    end
-    
-    it "should find own jobs" do
-      @job = create_job(:locked_by => 'worker', :locked_at => (described_class.db_time_now - 1.minutes))
-      described_class.find_available('worker', 5, 4.hours).should include(@job)
-    end
-
-    it "should find only the right amount of jobs" do
-      10.times { create_job }
-      described_class.find_available('worker', 7, 4.hours).should have(7).jobs
+
+    it "should raise a DeserializationError when the YAML.load raises argument error" do
+      job = described_class.find(create_job.id)
+      YAML.should_receive(:load).and_raise(ArgumentError)
+      lambda { job.payload_object }.should raise_error(Delayed::DeserializationError)
     end
   end
-  
-  context "when another worker is already performing an task, it" do
-    before :each do
-      @job = described_class.create :payload_object => SimpleJob.new, :locked_by => 'worker1', :locked_at => described_class.db_time_now - 5.minutes
+
+  describe "reserve" do
+    before do
+      Delayed::Worker.max_run_time = 2.minutes
+      @worker = Delayed::Worker.new(:quiet => true)
     end
 
-    it "should not allow a second worker to get exclusive access" do
-      @job.lock_exclusively!(4.hours, 'worker2').should == false
+    it "should not reserve failed jobs" do
+      create_job :attempts => 50, :failed_at => described_class.db_time_now
+      described_class.reserve(@worker).should be_nil
     end
 
-    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      
-    
-    it "should be able to get access to the task if it was started more then max_age ago" do
-      @job.locked_at = described_class.db_time_now - 5.hours
-      @job.save
+    it "should not reserve jobs scheduled for the future" do
+      create_job :run_at => (described_class.db_time_now + 1.minute)
+      described_class.reserve(@worker).should be_nil
+    end
 
-      @job.lock_exclusively! 4.hours, 'worker2'
-      @job.reload
-      @job.locked_by.should == 'worker2'
-      @job.locked_at.should > (described_class.db_time_now - 1.minute)
+    it "should lock the job so other workers can't reserve it" do
+      job = create_job
+      described_class.reserve(@worker).should == job
+      new_worker = Delayed::Worker.new(:quiet => true)
+      new_worker.name = 'worker2'
+      described_class.reserve(new_worker).should be_nil
     end
 
-    it "should not be found by another worker" do
-      described_class.find_available('worker2', 1, 6.minutes).length.should == 0
+    it "should reserve open jobs" do
+      job = create_job
+      described_class.reserve(@worker).should == job
     end
 
-    it "should be found by another worker if the time has expired" do
-      described_class.find_available('worker2', 1, 4.minutes).length.should == 1
+    it "should reserve expired jobs" do
+      job = create_job(:locked_by => @worker.name, :locked_at => described_class.db_time_now - 3.minutes)
+      described_class.reserve(@worker).should == job
     end
 
-    it "should be able to get exclusive access again when the worker name is the same" do
-      @job.lock_exclusively!(5.minutes, 'worker1').should be_true
-      @job.lock_exclusively!(5.minutes, 'worker1').should be_true
-      @job.lock_exclusively!(5.minutes, 'worker1').should be_true
-    end                                        
+    it "should reserve own jobs" do
+      job = create_job(:locked_by => @worker.name, :locked_at => (described_class.db_time_now - 1.minutes))
+      described_class.reserve(@worker).should == job
+    end
   end
-  
+
   context "when another worker has worked on a task since the job was found to be available, it" do
 
     before :each do
@@ -184,7 +196,7 @@ shared_examples_for 'a delayed_job backend' do
     it "should be the class name of the job that was enqueued" do
       described_class.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
       job = described_class.new(:payload_object => NamedJob.new)
       job.name.should == 'named_job'
@@ -194,8 +206,15 @@ shared_examples_for 'a delayed_job backend' do
       @job = Story.create(:text => "...").delay.save
       @job.name.should == 'Story#save'
     end
+
+    it "should parse from handler on deserialization error" do
+      job = Story.create(:text => "...").delay.text
+      job.payload_object.object.destroy
+      job = described_class.find(job.id)
+      job.name.should == 'Delayed::PerformableMethod'
+    end
   end
-  
+
   context "worker prioritization" do
     before(:each) do
       Delayed::Worker.max_priority = nil
@@ -206,7 +225,7 @@ shared_examples_for 'a delayed_job backend' do
       10.times { described_class.enqueue SimpleJob.new, rand(10) }
       jobs = described_class.find_available('worker', 10)
       jobs.size.should == 10
-      jobs.each_cons(2) do |a, b| 
+      jobs.each_cons(2) do |a, b|
         a.priority.should <= b.priority
       end
     end
@@ -227,23 +246,23 @@ shared_examples_for 'a delayed_job backend' do
       jobs.each {|job| job.priority.should <= max}
     end
   end
-  
+
   context "clear_locks!" do
     before do
       @job = create_job(:locked_by => 'worker', :locked_at => described_class.db_time_now)
     end
-    
+
     it "should clear locks for the given worker" do
       described_class.clear_locks!('worker')
       described_class.find_available('worker2', 5, 1.minute).should include(@job)
     end
-    
+
     it "should not clear locks for other workers" do
       described_class.clear_locks!('worker1')
       described_class.find_available('worker1', 5, 1.minute).should_not include(@job)
     end
   end
-  
+
   context "unlock" do
     before do
       @job = create_job(:locked_by => 'worker', :locked_at => described_class.db_time_now)
@@ -255,13 +274,13 @@ shared_examples_for 'a delayed_job backend' do
       @job.locked_at.should be_nil
     end
   end
-  
+
   context "large handler" do
     before do
       text = "Lorem ipsum dolor sit amet. " * 1000
       @job = described_class.enqueue Delayed::PerformableMethod.new(text, :length, {})
     end
-    
+
     it "should have an id" do
       @job.id.should_not be_nil
     end
@@ -269,18 +288,19 @@ shared_examples_for 'a delayed_job backend' do
 
   describe "yaml serialization" do
     it "should reload changed attributes" do
-      job = described_class.enqueue SimpleJob.new
-      yaml = job.to_yaml
-      job.priority = 99
-      job.save
-      YAML.load(yaml).priority.should == 99
+      story = Story.create(:text => 'hello')
+      job = story.delay.tell
+      story.update_attributes :text => 'goodbye'
+      described_class.find(job.id).payload_object.object.text.should == 'goodbye'
     end
 
-    it "should ignore destroyed records" do
-      job = described_class.enqueue SimpleJob.new
-      yaml = job.to_yaml
-      job.destroy
-      lambda { YAML.load(yaml).should be_nil }.should_not raise_error
+    it "should raise deserialization error for destroyed records" do
+      story = Story.create(:text => 'hello')
+      job = story.delay.tell
+      story.destroy
+      lambda {
+        described_class.find(job.id).payload_object
+      }.should raise_error(Delayed::DeserializationError)
     end
   end
 
@@ -306,55 +326,15 @@ shared_examples_for 'a delayed_job backend' do
           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
-        create_job(:priority => -10)
-        create_job(:priority => 0)
-        @worker.work_off
-
-        SimpleJob.runs.should == 1
-      end
-
-      it "should only work_off jobs that are <= max_priority" do
-        create_job(:priority => 10)
-        create_job(: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
-        create_job(: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
-        create_job
-        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)
-        create_job(: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
-        create_job(: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)
+      context "when the job raises a deserialization error" do
+        it "should mark the job as failed" do
+          Delayed::Worker.destroy_failed_jobs = false
+          job = described_class.create! :handler => "--- !ruby/object:JobThatDoesNotExist {}"
+          @worker.work_off
+          job.reload
+          job.failed_at.should_not be_nil
+        end
       end
     end
 
@@ -364,7 +344,7 @@ shared_examples_for 'a delayed_job backend' do
         Delayed::Worker.destroy_failed_jobs = true
         Delayed::Worker.max_attempts = 25
 
-        @job = Delayed::Job.enqueue ErrorJob.new
+        @job = Delayed::Job.enqueue(ErrorJob.new)
       end
 
       it "should record last_error when destroy_failed_jobs = false, max_attempts = 1" do
@@ -376,15 +356,32 @@ shared_examples_for 'a delayed_job backend' do
         @job.attempts.should == 1
         @job.failed_at.should_not be_nil
       end
-  
+
       it "should re-schedule jobs after failing" do
-        @worker.run(@job)
+        @worker.work_off
         @job.reload
         @job.last_error.should =~ /did not work/
         @job.last_error.should =~ /sample_jobs.rb:\d+: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
+        @job.locked_by.should be_nil
+        @job.locked_at.should be_nil
+      end
+
+      it 'should re-schedule with handler provided time if present' do
+        @job = Delayed::Job.enqueue(CustomRescheduleJob.new(99.minutes))
+        @worker.run(@job)
+        @job.reload
+
+        (Delayed::Job.db_time_now + 99.minutes - @job.run_at).abs.should < 1
+      end
+
+      it "should not fail when the triggered error doesn't have a message" do
+        error_with_nil_message = StandardError.new
+        error_with_nil_message.stub!(:message).and_return nil
+        @job.stub!(:invoke_job).and_raise error_with_nil_message
+        lambda{@worker.run(@job)}.should_not raise_error
       end
     end
 
@@ -392,35 +389,35 @@ shared_examples_for 'a delayed_job backend' 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
+        context "when the job's payload has a #failure hook" do
           before do
             @job = Delayed::Job.create :payload_object => OnPermanentFailureJob.new
-            @job.payload_object.should respond_to :on_permanent_failure
+            @job.payload_object.should respond_to :failure
           end
 
           it "should run that hook" do
-            @job.payload_object.should_receive :on_permanent_failure
+            @job.payload_object.should_receive :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
+        context "when the job's payload has no #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.failure makes that object
+          # incorrectly return true to
+          # payload_object.respond_to? :failure, which is what
+          # reschedule uses to decide whether to call failure.
+          # So instead, we just make sure that the payload_object as it
+          # already stands doesn't respond_to? 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).
-          
+          # failure method).
+
           before do
-            @job.payload_object.should_not respond_to(:on_permanent_failure)
+            @job.payload_object.should_not respond_to(:failure)
           end
 
           it "should not try to run that hook" do
@@ -442,18 +439,18 @@ shared_examples_for 'a delayed_job backend' 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"
 
         it "should be failed if it failed more than Worker.max_attempts times" do