moneypools-delayed_job 1.8.4

data/lib/delayed/backend/base.rb

@@ -0,0 +1,98 @@
+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)
+            raise ArgumentError, 'Cannot enqueue items which do not respond to perform'
+          end
+    
+          priority = args.first || 0
+          run_at   = args[1]
+          self.create(:payload_object => object, :priority => priority.to_i, :run_at => run_at)
+        end
+      end
+      
+      ParseObjectFromYaml = /\!ruby\/\w+\:([^\s]+)/
+
+      def failed?
+        failed_at
+      end
+      alias_method :failed, :failed?
+
+      def payload_object
+        @payload_object ||= deserialize(self['handler'])
+      end
+
+      def name
+        @name ||= begin
+          payload = payload_object
+          if payload.respond_to?(:display_name)
+            payload.display_name
+          else
+            payload.class.name
+          end
+        end
+      end
+
+      def payload_object=(object)
+        self['handler'] = object.to_yaml
+      end
+      
+      # Moved into its own method so that new_relic can trace it.
+      def invoke_job
+        payload_object.perform
+      end
+      
+      # Unlock this job (note: not saved to DB)
+      def unlock
+        self.locked_at    = nil
+        self.locked_by    = nil
+      end
+      
+    private
+
+      def deserialize(source)
+        handler = YAML.load(source) rescue nil
+
+        unless handler.respond_to?(:perform)
+          if handler.nil? && source =~ ParseObjectFromYaml
+            handler_class = $1
+          end
+          attempt_to_load(handler_class || handler.class)
+          handler = YAML.load(source)
+        end
+
+        return handler if handler.respond_to?(:perform)
+
+        raise DeserializationError,
+          'Job failed to load: Unknown handler. Try to manually require the appropriate file.'
+      rescue TypeError, LoadError, NameError => e
+        raise DeserializationError,
+          "Job failed to load: #{e.message}. Try to manually require the required file."
+      end
+
+      # Constantize the object so that ActiveSupport can attempt
+      # its auto loading magic. Will raise LoadError if not successful.
+      def attempt_to_load(klass)
+         klass.constantize
+      end
+
+    protected
+
+      def before_save
+        self.run_at ||= self.class.db_time_now
+      end
+    
+    end
+  end
+end

data/lib/delayed/backend/mongo_mapper.rb

@@ -0,0 +1,104 @@
+require 'mongo_mapper'
+
+module ::MongoMapper
+  module Document
+    module ClassMethods
+      def load_for_delayed_job(id)
+        find!(id)
+      end
+    end
+
+    module InstanceMethods
+      def dump_for_delayed_job
+        "#{self.class};#{id}"
+      end
+    end
+  end
+end
+
+module Delayed
+  module Backend
+    module MongoMapper
+      class Job
+        include ::MongoMapper::Document
+        include Delayed::Backend::Base
+        set_collection_name 'delayed_jobs'
+        
+        key :priority,    Integer, :default => 0
+        key :attempts,    Integer, :default => 0
+        key :handler,     String
+        key :run_at,      Time
+        key :locked_at,   Time
+        key :locked_by,   String
+        key :failed_at,   Time
+        key :last_error,  String
+        timestamps!
+        
+        before_save :set_default_run_at
+        
+        def self.db_time_now
+          ::MongoMapper.time_class.now.utc
+        end
+        
+        def self.find_available(worker_name, limit = 5, max_run_time = Worker.max_run_time)
+          right_now = db_time_now
+
+          conditions = {
+            :run_at => {"$lte" => right_now},
+            :limit => limit,
+            :failed_at => nil,
+            :sort => [['priority', 1], ['run_at', 1]]
+          }
+
+          where = "this.locked_at == null || this.locked_at < #{make_date(right_now - max_run_time)}"
+          
+          (conditions[:priority] ||= {})['$gte'] = Worker.min_priority if Worker.min_priority
+          (conditions[:priority] ||= {})['$lte'] = Worker.max_priority if Worker.max_priority
+
+          results = all(conditions.merge(:locked_by => worker_name))
+          results += all(conditions.merge('$where' => where)) if results.size < limit
+          results
+        end
+        
+        # When a worker is exiting, make sure we don't have any locked jobs.
+        def self.clear_locks!(worker_name)
+          collection.update({:locked_by => worker_name}, {"$set" => {:locked_at => nil, :locked_by => nil}}, :multi => true)
+        end
+        
+        # Lock this job for this worker.
+        # Returns true if we have the lock, false otherwise.
+        def lock_exclusively!(max_run_time, worker = worker_name)
+          right_now = self.class.db_time_now
+          overtime = right_now - max_run_time.to_i
+          
+          query = "this.locked_at == null || this.locked_at < #{make_date(overtime)} || this.locked_by == #{worker.to_json}"
+          conditions = {:_id => id, :run_at => {"$lte" => right_now}, "$where" => query}
+
+          collection.update(conditions, {"$set" => {:locked_at => right_now, :locked_by => worker}})
+          affected_rows = collection.find({:_id => id, :locked_by => worker}).count
+          if affected_rows == 1
+            self.locked_at = right_now
+            self.locked_by = worker
+            return true
+          else
+            return false
+          end
+        end
+        
+      private
+      
+        def self.make_date(date_or_seconds)
+          "new Date(#{date_or_seconds.to_f * 1000})"
+        end
+
+        def make_date(date)
+          self.class.make_date(date)
+        end
+        
+        def set_default_run_at
+          self.run_at ||= self.class.db_time_now
+        end
+      end
+    end
+  end
+end

data/lib/delayed/command.rb

@@ -0,0 +1,77 @@
+require 'rubygems'
+require 'daemons'
+require 'optparse'
+
+module Delayed
+  class Command
+    attr_accessor :worker_count
+    
+    def initialize(args)
+      @files_to_reopen = []
+      @options = {:quiet => true}
+      
+      @worker_count = 1
+      
+      opts = OptionParser.new do |opts|
+        opts.banner = "Usage: #{File.basename($0)} [options] start|stop|restart|run"
+
+        opts.on('-h', '--help', 'Show this message') do
+          puts opts
+          exit 1
+        end
+        opts.on('-e', '--environment=NAME', 'Specifies the environment to run this delayed jobs under (test/development/production).') do |e|
+          STDERR.puts "The -e/--environment option has been deprecated and has no effect. Use RAILS_ENV and see http://github.com/collectiveidea/delayed_job/issues/#issue/7"
+        end
+        opts.on('--min-priority N', 'Minimum priority of jobs to run.') do |n|
+          @options[:min_priority] = n
+        end
+        opts.on('--max-priority N', 'Maximum priority of jobs to run.') do |n|
+          @options[:max_priority] = n
+        end
+        opts.on('-n', '--number_of_workers=workers', "Number of unique workers to spawn") do |worker_count|
+          @worker_count = worker_count.to_i rescue 1
+        end
+      end
+      @args = opts.parse!(args)
+    end
+  
+    def daemonize
+      ObjectSpace.each_object(File) do |file|
+        @files_to_reopen << file unless file.closed?
+      end
+      
+      worker_count.times do |worker_index|
+        process_name = worker_count == 1 ? "delayed_job" : "delayed_job.#{worker_index}"
+        Daemons.run_proc(process_name, :dir => "#{RAILS_ROOT}/tmp/pids", :dir_mode => :normal, :ARGV => @args) do |*args|
+          run process_name
+        end
+      end
+    end
+    
+    def run(worker_name = nil)
+      Dir.chdir(RAILS_ROOT)
+      
+      # Re-open file handles
+      @files_to_reopen.each do |file|
+        begin
+          file.reopen File.join(RAILS_ROOT, 'log', 'delayed_job.log'), 'a+'
+          file.sync = true
+        rescue ::Exception
+        end
+      end
+      
+      Delayed::Worker.logger = Rails.logger
+      Delayed::Worker.logger.auto_flushing = true
+      ActiveRecord::Base.connection.reconnect!
+      
+      worker = Delayed::Worker.new(@options)
+      worker.name_prefix = "#{worker_name} "
+      worker.start
+    rescue => e
+      Rails.logger.fatal e
+      STDERR.puts e.message
+      exit 1
+    end
+    
+  end
+end

data/lib/delayed/message_sending.rb

@@ -0,0 +1,22 @@
+module Delayed
+  module MessageSending
+    def send_later(method, *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
+      def handle_asynchronously(method)
+        aliased_method, punctuation = method.to_s.sub(/([?!=])$/, ''), $1
+        with_method, without_method = "#{aliased_method}_with_send_later#{punctuation}", "#{aliased_method}_without_send_later#{punctuation}"
+        define_method(with_method) do |*args|
+          send_later(without_method, *args)
+        end
+        alias_method_chain method, :send_later
+      end
+    end
+  end                               
+end

data/lib/delayed/performable_method.rb

@@ -0,0 +1,62 @@
+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)
+
+      self.object = dump(object)
+      self.args   = args.map { |a| dump(a) }
+      self.method = method.to_sym
+    end
+    
+    def display_name
+      if STRING_FORMAT === object
+        "#{$1}#{$2 ? '#' : '.'}#{method}"
+      else
+        "#{object.class}##{method}"
+      end
+    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
+    end
+  end
+end

data/lib/delayed/recipes.rb

@@ -0,0 +1,31 @@
+# Capistrano Recipes for managing delayed_job
+#
+# Add these callbacks to have the delayed_job process restart when the server
+# is restarted:
+#
+#   after "deploy:stop",    "delayed_job:stop"
+#   after "deploy:start",   "delayed_job:start"
+#   after "deploy:restart", "delayed_job:restart"
+
+Capistrano::Configuration.instance.load do
+  namespace :delayed_job do
+    def rails_env
+      fetch(:rails_env, false) ? "RAILS_ENV=#{fetch(:rails_env)}" : ''
+    end
+    
+    desc "Stop the delayed_job process"
+    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 => :app do
+      run "cd #{current_path};#{rails_env} script/delayed_job start"
+    end
+
+    desc "Restart the delayed_job process"
+    task :restart, :roles => :app do
+      run "cd #{current_path};#{rails_env} script/delayed_job restart"
+    end
+  end
+end

data/lib/delayed/tasks.rb

@@ -0,0 +1,15 @@
+# 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
+    Delayed::Job.delete_all
+  end
+
+  desc "Start a delayed_job worker."
+  task :work => [:merb_env, :environment] do
+    Delayed::Worker.new(:min_priority => ENV['MIN_PRIORITY'], :max_priority => ENV['MAX_PRIORITY']).start
+  end
+end

data/lib/delayed/worker.rb

@@ -0,0 +1,165 @@
+require 'timeout'
+
+module Delayed
+  class Worker
+    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
+    
+    # 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
+    elsif defined?(RAILS_DEFAULT_LOGGER)
+      RAILS_DEFAULT_LOGGER
+    end
+
+    # 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/backend/#{backend}"
+        backend = "Delayed::Backend::#{backend.to_s.classify}::Job".constantize
+      end
+      @@backend = backend
+      silence_warnings { ::Delayed.const_set(:Job, backend) }
+    end
+
+    def initialize(options={})
+      @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)
+    end
+
+    # Every worker has a unique name which by default is the pid of the process. There are some
+    # advantages to overriding this with something which survives worker retarts:  Workers can#
+    # safely resume working on tasks which are locked by themselves. The worker will assume that
+    # it crashed before.
+    def name
+      return @name unless @name.nil?
+      "#{@name_prefix}host:#{Socket.gethostname} pid:#{Process.pid}" rescue "#{@name_prefix}pid:#{Process.pid}"
+    end
+
+    # Sets the name of the worker.
+    # Setting the name to nil will reset the default worker name
+    def name=(val)
+      @name = val
+    end
+
+    def start
+      say "*** Starting job worker #{name}"
+
+      trap('TERM') { say 'Exiting...'; $exit = true }
+      trap('INT')  { say 'Exiting...'; $exit = true }
+
+      loop do
+        result = nil
+
+        realtime = Benchmark.realtime do
+          result = work_off
+        end
+
+        count = result.sum
+
+        break if $exit
+
+        if count.zero?
+          sleep(@@sleep_delay)
+        else
+          say "#{count} jobs processed at %.4f j/s, %d failed ..." % [count / realtime, result.last]
+        end
+
+        break if $exit
+      end
+
+    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)
+      success, failure = 0, 0
+
+      num.times do
+        case reserve_and_run_one_job
+        when true
+            success += 1
+        when false
+            failure += 1
+        else
+          break  # leave if no work could be done
+        end
+        break if $exit # leave if we're exiting
+      end
+
+      return [success, failure]
+    end
+    
+    def run(job)
+      runtime =  Benchmark.realtime do
+        Timeout.timeout(self.class.max_run_time.to_i) { job.invoke_job }
+        job.destroy
+      end
+      # TODO: warn if runtime > max_run_time ?
+      say "* [JOB] #{name} completed after %.4f" % runtime
+      return true  # did work
+    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) < self.class.max_attempts
+        time ||= Job.db_time_now + (job.attempts ** 4) + 5
+        job.run_at = time
+        job.unlock
+        job.save!
+      else
+        say "* [JOB] PERMANENTLY removing #{job.name} because of #{job.attempts} consecutive failures.", Logger::INFO
+        self.class.destroy_failed_jobs ? job.destroy : job.update_attribute(:failed_at, Delayed::Job.db_time_now)
+      end
+    end
+
+    def say(text, level = Logger::INFO)
+      puts text unless @quiet
+      logger.add level, "#{Time.now.strftime('%FT%T%z')}: #{text}" if logger
+    end
+
+  protected
+    
+    def handle_failed_job(job, error)
+      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 "* [Worker(#{name})] acquired lock on #{job.name}"
+          true
+        else
+          say "* [Worker(#{name})] failed to acquire exclusive lock for #{job.name}", Logger::WARN
+          false
+        end
+      end
+
+      run(job) if job
+    end
+  end
+end