delayed_job 2.1.0.pre2 → 2.1.1

data/lib/delayed/command.rb

@@ -44,8 +44,9 @@ module Delayed
         opts.on('-m', '--monitor', 'Start monitor process.') do
           @monitor = true
         end
-        
-
+        opts.on('--sleep-delay N', "Amount of time to sleep when no jobs are found") do |n|
+          @options[:sleep_delay] = n
+        end
       end
       @args = opts.parse!(args)
     end

data/lib/delayed/deserialization_error.rb

@@ -0,0 +1,4 @@
+module Delayed
+  class DeserializationError < StandardError
+  end
+end

data/lib/delayed/message_sending.rb

@@ -3,25 +3,23 @@ require 'active_support/core_ext/module/aliasing'
 
 module Delayed
   class DelayProxy < ActiveSupport::BasicObject
-    def initialize(target, options)
+    def initialize(payload_class, target, options)
+      @payload_class = payload_class
       @target = target
       @options = options
     end
 
     def method_missing(method, *args)
-      Job.create({
-        :payload_object => PerformableMethod.new(@target, method.to_sym, args),
-        :priority       => ::Delayed::Worker.default_priority
-      }.merge(@options))
+      Job.enqueue({:payload_object => @payload_class.new(@target, method.to_sym, args)}.merge(@options))
     end
   end
 
   module MessageSending
     def delay(options = {})
-      DelayProxy.new(self, options)
+      DelayProxy.new(PerformableMethod, self, options)
     end
     alias __delay__ delay
-    
+
     def send_later(method, *args)
       warn "[DEPRECATION] `object.send_later(:method)` is deprecated. Use `object.delay.method"
       __delay__.__send__(method, *args)
@@ -31,16 +29,26 @@ module Delayed
       warn "[DEPRECATION] `object.send_at(time, :method)` is deprecated. Use `object.delay(:run_at => time).method"
       __delay__(:run_at => time).__send__(method, *args)
     end
-    
+
     module ClassMethods
-      def handle_asynchronously(method)
+      def handle_asynchronously(method, opts = {})
         aliased_method, punctuation = method.to_s.sub(/([?!=])$/, ''), $1
         with_method, without_method = "#{aliased_method}_with_delay#{punctuation}", "#{aliased_method}_without_delay#{punctuation}"
         define_method(with_method) do |*args|
-          delay.__send__(without_method, *args)
+          curr_opts = opts.clone
+          curr_opts.each_key do |key|
+            if (val = curr_opts[key]).is_a?(Proc)
+              curr_opts[key] = if val.arity == 1
+                val.call(self)
+              else
+                val.call
+              end
+            end
+          end
+          delay(curr_opts).__send__(without_method, *args)
         end
         alias_method_chain method, :delay
       end
     end
-  end                               
+  end
 end

data/lib/delayed/performable_mailer.rb

@@ -0,0 +1,21 @@
+require 'action_mailer'
+
+module Delayed
+  class PerformableMailer < PerformableMethod
+    def perform
+      object.send(method_name, *args).deliver
+    end
+  end
+end
+
+ActionMailer::Base.class_eval do
+  def self.delay(options = {})
+    Delayed::DelayProxy.new(Delayed::PerformableMailer, self, options)
+  end
+end
+
+Mail::Message.class_eval do
+  def delay(*args)
+    raise RuntimeError, "Use MyMailer.delay.mailer_action(args) to delay sending of emails."
+  end
+end

data/lib/delayed/performable_method.rb

@@ -1,27 +1,31 @@
+require 'active_support/core_ext/module/delegation'
+
 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, true)
+  class PerformableMethod < Struct.new(:object, :method_name, :args)
+    delegate :method, :to => :object
+
+    def initialize(object, method_name, args)
+      raise NoMethodError, "undefined method `#{method_name}' for #{object.inspect}" unless object.respond_to?(method_name, true)
 
-      self.object = object
-      self.args   = args
-      self.method = method.to_sym
+      self.object       = object
+      self.args         = args
+      self.method_name  = method_name.to_sym
     end
-    
+
     def display_name
-      "#{object.class}##{method}"
+      "#{object.class}##{method_name}"
     end
-    
+
     def perform
-      object.send(method, *args) if object
+      object.send(method_name, *args) if object
     end
-    
+
     def method_missing(symbol, *args)
-      object.respond_to?(symbol) ? object.send(symbol, *args) : super
+      object.send(symbol, *args)
     end
-       
+
     def respond_to?(symbol, include_private=false)
-      object.respond_to?(symbol, include_private) || super
-    end    
+      super || object.respond_to?(symbol, include_private)
+    end
   end
 end

data/lib/delayed/recipes.rb

@@ -13,6 +13,10 @@ Capistrano::Configuration.instance.load do
       fetch(:rails_env, false) ? "RAILS_ENV=#{fetch(:rails_env)}" : ''
     end
     
+    def args
+      fetch(:delayed_job_args, "")
+    end
+    
     desc "Stop the delayed_job process"
     task :stop, :roles => :app do
       run "cd #{current_path};#{rails_env} script/delayed_job stop"
@@ -20,12 +24,12 @@ Capistrano::Configuration.instance.load do
 
     desc "Start the delayed_job process"
     task :start, :roles => :app do
-      run "cd #{current_path};#{rails_env} script/delayed_job start"
+      run "cd #{current_path};#{rails_env} script/delayed_job start #{args}"
     end
 
     desc "Restart the delayed_job process"
     task :restart, :roles => :app do
-      run "cd #{current_path};#{rails_env} script/delayed_job restart"
+      run "cd #{current_path};#{rails_env} script/delayed_job restart #{args}"
     end
   end
 end

data/lib/delayed/serialization/active_record.rb

@@ -0,0 +1,13 @@
+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
+    raise Delayed::DeserializationError
+  end
+
+  def to_yaml_properties
+    ['@attributes']
+  end
+end

data/lib/delayed/worker.rb

@@ -11,12 +11,12 @@ module Delayed
     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?(Rails)
       Rails.logger
     elsif defined?(RAILS_DEFAULT_LOGGER)
@@ -25,26 +25,28 @@ module Delayed
 
     # name_prefix is ignored if name is set directly
     attr_accessor :name_prefix
-    
+
     cattr_reader :backend
-    
+
     def self.backend=(backend)
       if backend.is_a? Symbol
+        require "delayed/serialization/#{backend}"
         require "delayed/backend/#{backend}"
         backend = "Delayed::Backend::#{backend.to_s.classify}::Job".constantize
       end
       @@backend = backend
       silence_warnings { ::Delayed.const_set(:Job, backend) }
     end
-    
+
     def self.guess_backend
       self.backend ||= :active_record if defined?(ActiveRecord)
     end
 
     def initialize(options={})
-      @quiet = options[:quiet]
+      @quiet = options.has_key?(:quiet) ? options[:quiet] : true
       self.class.min_priority = options[:min_priority] if options.has_key?(:min_priority)
       self.class.max_priority = options[:max_priority] if options.has_key?(:max_priority)
+      self.class.sleep_delay = options[:sleep_delay] if options.has_key?(:sleep_delay)
     end
 
     # Every worker has a unique name which by default is the pid of the process. There are some
@@ -80,7 +82,7 @@ module Delayed
         break if $exit
 
         if count.zero?
-          sleep(@@sleep_delay)
+          sleep(self.class.sleep_delay)
         else
           say "#{count} jobs processed at %.4f j/s, %d failed ..." % [count / realtime, result.last]
         end
@@ -91,7 +93,7 @@ module Delayed
     ensure
       Delayed::Job.clear_locks!(name)
     end
-    
+
     # Do num jobs and return stats on success/failure.
     # Exit early if interrupted.
     def work_off(num = 100)
@@ -111,7 +113,7 @@ module Delayed
 
       return [success, failure]
     end
-    
+
     def run(job)
       runtime =  Benchmark.realtime do
         Timeout.timeout(self.class.max_run_time.to_i) { job.invoke_job }
@@ -119,34 +121,34 @@ module Delayed
       end
       say "#{job.name} completed after %.4f" % runtime
       return true  # did work
-    rescue Exception => e
-      handle_failed_job(job, e)
+    rescue DeserializationError => error
+      job.last_error = "{#{error.message}\n#{error.backtrace.join('\n')}"
+      failed(job)
+    rescue Exception => error
+      handle_failed_job(job, error)
       return false  # work failed
     end
-    
+
     # Reschedule the job in the future (when a job fails).
     # Uses an exponential scale depending on the number of failed attempts.
     def reschedule(job, time = nil)
       if (job.attempts += 1) < self.class.max_attempts
-        time ||= Job.db_time_now + (job.attempts ** 4) + 5
+        time ||= job.reschedule_at
         job.run_at = time
         job.unlock
         job.save!
       else
         say "PERMANENTLY removing #{job.name} because of #{job.attempts} consecutive failures.", Logger::INFO
+        failed(job)
+      end
+    end
 
-        if job.payload_object.respond_to? :on_permanent_failure
-          say "Running on_permanent_failure hook"
-          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)
+    def failed(job)
+      job.hook(:failure)
+      if job.respond_to?(:on_permanent_failure)
+        warn "[DEPRECATION] The #on_permanent_failure hook has been renamed to #failure."
       end
+      self.class.destroy_failed_jobs ? job.destroy : job.update_attributes(:failed_at => Delayed::Job.db_time_now)
     end
 
     def say(text, level = Logger::INFO)
@@ -156,30 +158,19 @@ module Delayed
     end
 
   protected
-    
+
     def handle_failed_job(job, error)
-      job.last_error = error.message + "\n" + error.backtrace.join("\n")
+      job.last_error = "{#{error.message}\n#{error.backtrace.join('\n')}"
       say "#{job.name} failed with #{error.class.name}: #{error.message} - #{job.attempts} failed attempts", Logger::ERROR
       reschedule(job)
     end
-    
+
     # Run the next job we can get an exclusive lock on.
     # If no jobs are left we return nil
     def reserve_and_run_one_job
-
-      # 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
-      job = Delayed::Job.find_available(name, 5, self.class.max_run_time).detect do |job|
-        if job.lock_exclusively!(self.class.max_run_time, name)
-          say "acquired lock on #{job.name}"
-          true
-        else
-          say "failed to acquire exclusive lock for #{job.name}", Logger::WARN
-          false
-        end
-      end
-
+      job = Delayed::Job.reserve(self)
       run(job) if job
     end
   end
+
 end

data/lib/delayed_job.rb

@@ -2,10 +2,12 @@ require 'active_support'
 
 require File.dirname(__FILE__) + '/delayed/message_sending'
 require File.dirname(__FILE__) + '/delayed/performable_method'
+require File.dirname(__FILE__) + '/delayed/performable_mailer' if defined?(ActionMailer)
 require File.dirname(__FILE__) + '/delayed/yaml_ext'
 require File.dirname(__FILE__) + '/delayed/backend/base'
 require File.dirname(__FILE__) + '/delayed/worker'
-require File.dirname(__FILE__) + '/delayed/railtie' if defined?(::Rails::Railtie)
+require File.dirname(__FILE__) + '/delayed/deserialization_error'
+require File.dirname(__FILE__) + '/delayed/railtie' if defined?(Rails::Railtie)
 
-Object.send(:include, Delayed::MessageSending)   
+Object.send(:include, Delayed::MessageSending)
 Module.send(:include, Delayed::MessageSending::ClassMethods)

data/spec/active_record_job_spec.rb

@@ -5,7 +5,7 @@ describe Delayed::Backend::ActiveRecord::Job do
   after do
     Time.zone = nil
   end
-  
+
   it_should_behave_like 'a delayed_job backend'
 
   context "db_time_now" do
@@ -13,7 +13,7 @@ describe Delayed::Backend::ActiveRecord::Job do
       Time.zone = 'Eastern Time (US & Canada)'
       %w(EST EDT).should include(Delayed::Job.db_time_now.zone)
     end
-    
+
     it "should return UTC time if that is the AR default" do
       Time.zone = nil
       ActiveRecord::Base.default_timezone = :utc
@@ -26,10 +26,10 @@ describe Delayed::Backend::ActiveRecord::Job do
       %w(CST CDT).should include(Delayed::Backend::ActiveRecord::Job.db_time_now.zone)
     end
   end
-  
+
   describe "after_fork" do
     it "should call reconnect on the connection" do
-      ActiveRecord::Base.connection.should_receive(:reconnect!)
+      ActiveRecord::Base.should_receive(:establish_connection)
       Delayed::Backend::ActiveRecord::Job.after_fork
     end
   end

data/spec/database.yml

@@ -0,0 +1,4 @@
+mysql:
+  adapter: mysql
+  database: delayed_job
+  username: root

data/spec/message_sending_spec.rb

@@ -7,21 +7,59 @@ describe Delayed::MessageSending do
       end
       handle_asynchronously :tell!
     end
-    
+
     it "should alias original method" do
       Story.new.should respond_to(:tell_without_delay!)
       Story.new.should respond_to(:tell_with_delay!)
     end
-    
+
     it "should create a PerformableMethod" do
       story = Story.create!
       lambda {
         job = story.tell!(1)
         job.payload_object.class.should   == Delayed::PerformableMethod
-        job.payload_object.method.should  == :tell_without_delay!
+        job.payload_object.method_name.should  == :tell_without_delay!
         job.payload_object.args.should    == [1]
       }.should change { Delayed::Job.count }
     end
+
+    describe 'with options' do
+      class Fable
+        class << self
+          attr_accessor :importance
+        end
+        def tell
+        end
+        handle_asynchronously :tell, :priority => Proc.new { self.importance }
+      end
+
+      it 'should set the priority based on the Fable importance' do
+        Fable.importance = 10
+        job = Fable.new.tell
+        job.priority.should == 10
+
+        Fable.importance = 20
+        job = Fable.new.tell
+        job.priority.should == 20
+      end
+
+      describe 'using a proc with parament' do
+        class Yarn
+          attr_accessor :importance
+          def spin
+          end
+          handle_asynchronously :spin, :priority => Proc.new {|y| y.importance }
+        end
+
+        it 'should set the priority based on the Fable importance' do
+          job = Yarn.new.tap {|y| y.importance = 10 }.spin
+          job.priority.should == 10
+
+          job = Yarn.new.tap {|y| y.importance = 20 }.spin
+          job.priority.should == 20
+        end
+      end
+    end
   end
 
   context "delay" do
@@ -29,7 +67,7 @@ describe Delayed::MessageSending do
       lambda {
         job = "hello".delay.count('l')
         job.payload_object.class.should   == Delayed::PerformableMethod
-        job.payload_object.method.should  == :count
+        job.payload_object.method_name.should  == :count
         job.payload_object.args.should    == ['l']
       }.should change { Delayed::Job.count }.by(1)
     end