delayed_job 2.0.8 → 2.1.0.pre

data/lib/delayed/backend/couch_rest.rb

@@ -0,0 +1,109 @@
+require 'couchrest'
+
+#extent couchrest to handle delayed_job serialization.
+class CouchRest::ExtendedDocument
+  yaml_as "tag:ruby.yaml.org,2002:CouchRest"
+  
+  def reload
+    job = self.class.get self['_id']
+    job.each {|k,v| self[k] = v}
+  end
+  def self.find(id)
+    get id
+  end
+  def self.yaml_new(klass, tag, val)
+    klass.get(val['_id'])
+  end  
+  def ==(other)
+    if other.is_a? ::CouchRest::ExtendedDocument
+      self['_id'] == other['_id']
+    else
+      super
+    end
+  end
+end
+
+#couchrest adapter
+module Delayed
+  module Backend
+    module CouchRest
+      class Job < ::CouchRest::ExtendedDocument
+        include Delayed::Backend::Base
+        use_database ::CouchRest::Server.new.database('delayed_job')
+
+        property :handler
+        property :last_error
+        property :locked_by        
+        property :priority, :default => 0
+        property :attempts, :default => 0
+        property :run_at, :cast_as => 'Time'
+        property :locked_at, :cast_as => 'Time'
+        property :failed_at, :cast_as => 'Time'
+        timestamps!
+
+        set_callback :save, :before, :set_default_run_at
+
+        view_by(:failed_at, :locked_by, :run_at,
+                :map => "function(doc){" +
+                "          if(doc['couchrest-type'] == 'Delayed::Backend::CouchRest::Job') {" +
+                "            emit([doc.failed_at || null, doc.locked_by || null, doc.run_at || null], null);}" +
+                "        }")
+        view_by(:failed_at, :locked_at, :run_at,
+                :map => "function(doc){" +
+                "          if(doc['couchrest-type'] == 'Delayed::Backend::CouchRest::Job') {" +
+                "            emit([doc.failed_at || null, doc.locked_at || null, doc.run_at || null], null);}" +
+                "        }")        
+
+        def self.db_time_now; Time.now; end    
+        def self.find_available(worker_name, limit = 5, max_run_time = ::Delayed::Worker.max_run_time)
+          ready = ready_jobs
+          mine = my_jobs worker_name
+          expire = expired_jobs max_run_time
+          jobs = (ready + mine + expire)[0..limit-1].sort_by { |j| j.priority }
+          jobs = jobs.find_all { |j| j.priority >= Worker.min_priority } if Worker.min_priority
+          jobs = jobs.find_all { |j| j.priority <= Worker.max_priority } if Worker.max_priority
+          jobs
+        end
+        def self.clear_locks!(worker_name)
+          jobs = my_jobs worker_name
+          jobs.each { |j| j.locked_by, j.locked_at = nil, nil; }
+          database.bulk_save jobs
+        end
+        def self.delete_all
+          database.bulk_save all.each { |doc| doc['_deleted'] = true }
+        end
+        
+        def lock_exclusively!(max_run_time, worker = worker_name)
+          return false if locked_by_other?(worker) and not expired?(max_run_time)
+          case
+          when locked_by_me?(worker)
+            self.locked_at = self.class.db_time_now
+          when (unlocked? or (locked_by_other?(worker) and expired?(max_run_time)))
+            self.locked_at, self.locked_by = self.class.db_time_now, worker
+          end
+          save
+        rescue RestClient::Conflict
+          false
+        end
+        
+        private
+        def self.ready_jobs
+          options = {:startkey => [nil, nil], :endkey => [nil, nil, db_time_now]}
+          by_failed_at_and_locked_by_and_run_at options
+        end
+        def self.my_jobs(worker_name)
+          options = {:startkey => [nil, worker_name], :endkey => [nil, worker_name, {}]}
+          by_failed_at_and_locked_by_and_run_at options
+        end
+        def self.expired_jobs(max_run_time)
+          options = {:startkey => [nil,'0'], :endkey => [nil, db_time_now - max_run_time, db_time_now]}
+          by_failed_at_and_locked_at_and_run_at options
+        end
+        def unlocked?; locked_by.nil?; end
+        def expired?(time); locked_at < self.class.db_time_now - time; end
+        def locked_by_me?(worker); not locked_by.nil? and locked_by == worker; end        
+        def locked_by_other?(worker); not locked_by.nil? and locked_by != worker; end
+      end
+    end
+  end
+end

data/lib/delayed/backend/data_mapper.rb

@@ -2,19 +2,15 @@ require 'dm-core'
 require 'dm-observer'
 require 'dm-aggregates'
 
-module DataMapper
-  module Resource
-    module ClassMethods
-      def load_for_delayed_job(id)
-        find!(id)
-      end
-    end
+DataMapper::Resource.class_eval do
+  yaml_as "tag:ruby.yaml.org,2002:DataMapper"
 
-    module InstanceMethods
-      def dump_for_delayed_job
-        "#{self.class};#{id}"
-      end
-    end
+  def self.yaml_new(klass, tag, val)
+    klass.find(val['id'])
+  end
+
+  def to_yaml_properties
+    ['@id']
   end
 end
 

data/lib/delayed/backend/mongo_mapper.rb

@@ -1,18 +1,14 @@
 require 'mongo_mapper'
 
-module ::MongoMapper
-  module Document
-    module ClassMethods
-      def load_for_delayed_job(id)
-        find!(id)
-      end
-    end
+MongoMapper::Document.class_eval do
+  yaml_as "tag:ruby.yaml.org,2002:MongoMapper"
+  
+  def self.yaml_new(klass, tag, val)
+    klass.find(val['_id'])
+  end
 
-    module InstanceMethods
-      def dump_for_delayed_job
-        "#{self.class};#{id}"
-      end
-    end
+  def to_yaml_properties
+    ['@_id']
   end
 end
 

data/lib/delayed/command.rb

@@ -44,12 +44,8 @@ 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
-        opts.on('-p', '--prefix NAME', "String to be prefixed to worker process names") do |prefix|
-          @options[:prefix] = prefix
-        end
+        
+
       end
       @args = opts.parse!(args)
     end
@@ -79,7 +75,6 @@ module Delayed
     
     def run_process(process_name, dir)
       Daemons.run_proc(process_name, :dir => dir, :dir_mode => :normal, :monitor => @monitor, :ARGV => @args) do |*args|
-        $0 = File.join @options[:prefix], process_name if @options[:prefix]
         run process_name
       end
     end
@@ -90,7 +85,7 @@ module Delayed
       # Re-open file handles
       @files_to_reopen.each do |file|
         begin
-          file.reopen file.path, "a+"
+          file.reopen file.path
           file.sync = true
         rescue ::Exception
         end

data/lib/delayed/message_sending.rb

@@ -1,18 +1,19 @@
+require 'active_support/basic_object'
+
 module Delayed
   class DelayProxy < ActiveSupport::BasicObject
     def initialize(target, options)
       @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.create @options.merge(
+        :payload_object => PerformableMethod.new(@target, method.to_sym, args)
+      )
     end
   end
-
+  
   module MessageSending
     def delay(options = {})
       DelayProxy.new(self, options)
@@ -30,24 +31,14 @@ module Delayed
     end
     
     module ClassMethods
-      def handle_asynchronously(method, opts = {})
+      def handle_asynchronously(method)
         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|
-          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)
+          delay.__send__(without_method, *args)
         end
         alias_method_chain method, :delay
       end
     end
   end                               
-end
+end

data/lib/delayed/performable_method.rb

@@ -1,62 +1,19 @@
-class Class
-  def load_for_delayed_job(arg)
-    self
-  end
-  
-  def dump_for_delayed_job
-    name
-  end
-end
-
 module Delayed
   class PerformableMethod < Struct.new(:object, :method, :args)
-    STRING_FORMAT = /^LOAD\;([A-Z][\w\:]+)(?:\;(\w+))?$/
-    
-    class LoadError < StandardError
-    end
-
     def initialize(object, method, args)
-      raise NoMethodError, "undefined method `#{method}' for #{object.inspect}" unless object.respond_to?(method, true)
+      raise NoMethodError, "undefined method `#{method}' for #{object.inspect}" unless object.respond_to?(method)
 
-      self.object = dump(object)
-      self.args   = args.map { |a| dump(a) }
+      self.object = object
+      self.args   = args
       self.method = method.to_sym
     end
     
     def display_name
-      if STRING_FORMAT === object
-        "#{$1}#{$2 ? '#' : '.'}#{method}"
-      else
-        "#{object.class}##{method}"
-      end
+      "#{object.class}##{method}"
     end
     
     def perform
-      load(object).send(method, *args.map{|a| load(a)})
-    rescue PerformableMethod::LoadError
-      # We cannot do anything about objects that can't be loaded
-      true
-    end
-
-    private
-
-    def load(obj)
-      if STRING_FORMAT === obj
-        $1.constantize.load_for_delayed_job($2)
-      else
-        obj
-      end
-    rescue => e
-      Delayed::Worker.logger.warn "Could not load object for job: #{e.message}"
-      raise PerformableMethod::LoadError
-    end
-
-    def dump(obj)
-      if obj.respond_to?(:dump_for_delayed_job)
-        "LOAD;#{obj.dump_for_delayed_job}"
-      else
-        obj
-      end
+      object.send(method, *args) if object
     end
   end
 end

data/lib/delayed/railtie.rb

@@ -6,5 +6,9 @@ module Delayed
     initializer :after_initialize do
       Delayed::Worker.guess_backend
     end
+
+    rake_tasks do
+      load 'delayed/tasks.rb'
+    end
   end
 end

data/lib/delayed/recipes.rb

@@ -6,17 +6,6 @@
 #   after "deploy:stop",    "delayed_job:stop"
 #   after "deploy:start",   "delayed_job:start"
 #   after "deploy:restart", "delayed_job:restart"
-#
-# If you want to use command line options, for example to start multiple workers,
-# define a Capistrano variable delayed_job_args:
-#
-#   set :delayed_jobs_args, "-n 2"
-#
-# If you've got delayed_job workers running on a servers, you can also specify
-# which servers have delayed_job running and should be restarted after deploy.
-#
-#   set :delayed_job_server_role, :worker
-#
 
 Capistrano::Configuration.instance.load do
   namespace :delayed_job do
@@ -24,27 +13,19 @@ Capistrano::Configuration.instance.load do
       fetch(:rails_env, false) ? "RAILS_ENV=#{fetch(:rails_env)}" : ''
     end
     
-    def args
-      fetch(:delayed_job_args, "")
-    end
-    
-    def roles
-      fetch(:delayed_job_server_role, :app)
-    end
-    
     desc "Stop the delayed_job process"
-    task :stop, :roles => lambda { roles } do
+    task :stop, :roles => :app do
       run "cd #{current_path};#{rails_env} script/delayed_job stop"
     end
 
     desc "Start the delayed_job process"
-    task :start, :roles => lambda { roles } do
-      run "cd #{current_path};#{rails_env} script/delayed_job start #{args}"
+    task :start, :roles => :app do
+      run "cd #{current_path};#{rails_env} script/delayed_job start"
     end
 
     desc "Restart the delayed_job process"
-    task :restart, :roles => lambda { roles } do
-      run "cd #{current_path};#{rails_env} script/delayed_job restart #{args}"
+    task :restart, :roles => :app do
+      run "cd #{current_path};#{rails_env} script/delayed_job restart"
     end
   end
 end

data/lib/delayed/worker.rb

@@ -1,13 +1,14 @@
 require 'timeout'
 require 'active_support/core_ext/numeric/time'
+require 'active_support/core_ext/class/attribute_accessors'
+require 'active_support/core_ext/kernel'
 
 module Delayed
   class Worker
-    cattr_accessor :min_priority, :max_priority, :max_attempts, :max_run_time, :default_priority, :sleep_delay, :logger
+    cattr_accessor :min_priority, :max_priority, :max_attempts, :max_run_time, :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.
@@ -49,7 +50,6 @@ module Delayed
       @quiet = options[:quiet]
       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
@@ -85,7 +85,7 @@ module Delayed
         break if $exit
 
         if count.zero?
-          sleep(self.class.sleep_delay)
+          sleep(@@sleep_delay)
         else
           say "#{count} jobs processed at %.4f j/s, %d failed ..." % [count / realtime, result.last]
         end
@@ -124,38 +124,29 @@ module Delayed
       end
       say "#{job.name} completed after %.4f" % runtime
       return true  # did work
-    rescue DeserializationError => error
-      job.last_error = "{#{error.message}\n#{error.backtrace.join('\n')}"
-      failed(job)
-    rescue Exception => error
-      handle_failed_job(job, error)
+    rescue Exception => e
+      handle_failed_job(job, e)
       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) < max_attempts(job)
-        job.run_at = time || job.reschedule_at
+      if (job.attempts += 1) < self.class.max_attempts
+        time ||= Job.db_time_now + (job.attempts ** 4) + 5
+        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
 
-    def failed(job)
-      begin
         if job.payload_object.respond_to? :on_permanent_failure
-            say "Running on_permanent_failure hook"
-            job.payload_object.on_permanent_failure
+          say "Running on_permanent_failure hook"
+          job.payload_object.on_permanent_failure
         end
-      rescue DeserializationError
-        # do nothing
+
+        self.class.destroy_failed_jobs ? job.destroy : job.update_attributes(:failed_at => Delayed::Job.db_time_now)
       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)
@@ -164,10 +155,6 @@ module Delayed
       logger.add level, "#{Time.now.strftime('%FT%T%z')}: #{text}" if logger
     end
 
-    def max_attempts(job)
-      job.max_attempts || self.class.max_attempts
-    end
-    
   protected
     
     def handle_failed_job(job, error)
@@ -179,7 +166,19 @@ module Delayed
     # 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
-      job = Delayed::Job.reserve(self)
+
+      # 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
+
       run(job) if job
     end
   end