jmcnevin-delayed_job 2.0.4

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/railtie.rb

@@ -0,0 +1,10 @@
+require 'delayed_job'
+require 'rails'
+
+module Delayed
+  class Railtie < Rails::Railtie
+    initializer :after_initialize do
+      Delayed::Worker.guess_backend
+    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,199 @@
+require 'timeout'
+require 'active_support/core_ext/numeric/time'
+
+module Delayed
+  class Worker
+    cattr_accessor :min_priority,
+                   :max_priority,
+                   :max_attempts,
+                   :max_run_time,
+                   :default_priority,
+                   :sleep_delay,
+                   :logger,
+                   :trap_signals,
+                   :destroy_failed_jobs
+
+    cattr_reader :backend
+
+    # name_prefix is ignored if name is set directly
+    attr_accessor :name_prefix
+
+    # default worker settings
+    self.sleep_delay         = 5
+    self.max_attempts        = 25
+    self.max_run_time        = 4.hours
+    self.default_priority    = 0
+    self.trap_signals        = true
+    self.destroy_failed_jobs = true
+
+    self.logger = if defined?(Merb::Logger)
+      Merb.logger
+    elsif defined?(RAILS_DEFAULT_LOGGER)
+      RAILS_DEFAULT_LOGGER
+    end
+
+    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 self.guess_backend
+      self.backend ||= if defined?(ActiveRecord)
+        :active_record
+      elsif defined?(MongoMapper)
+        :mongo_mapper
+      else
+        logger.warn "Could not decide on a backend, defaulting to active_record"
+        :active_record
+      end
+    end
+
+    def initialize(options={})
+      @quiet = !!options.delete[:quiet]
+
+      options.each do |k,v|
+        method_name = :"#{k}="
+        if self.class.respond_to?(method_name)
+          self.class.send(method_name, v)
+        end
+      end
+    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}"
+
+      if self.trap_signals
+        trap('TERM') { say 'Exiting...'; $exit = true }
+        trap('INT')  { say 'Exiting...'; $exit = true }
+      end
+
+      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 # rescuing Exception can have some strange downsides in my experience
+    rescue => 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
+
+        if job.payload_object.respond_to? :on_permanent_failure
+          say "* [JOB] Running on_permanent_failure hook"
+          job.payload_object.on_permanent_failure
+          end
+
+        self.class.destroy_failed_jobs ? job.destroy : job.update_attributes(: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

data/lib/delayed_job.rb

@@ -0,0 +1,14 @@
+require 'active_support'
+
+require File.dirname(__FILE__) + '/delayed/message_sending'
+require File.dirname(__FILE__) + '/delayed/performable_method'
+require File.dirname(__FILE__) + '/delayed/backend/base'
+require File.dirname(__FILE__) + '/delayed/worker'
+require File.dirname(__FILE__) + '/delayed/railtie' if defined?(::Rails::Railtie)
+
+Object.send(:include, Delayed::MessageSending)   
+Module.send(:include, Delayed::MessageSending::ClassMethods)
+
+if defined?(Merb::Plugins)
+  Merb::Plugins.add_rakefiles File.dirname(__FILE__) / 'delayed' / 'tasks'
+end

data/rails/init.rb

@@ -0,0 +1,5 @@
+require 'delayed_job'
+
+config.after_initialize do
+  Delayed::Worker.guess_backend
+end

data/recipes/delayed_job.rb

@@ -0,0 +1 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'delayed', 'recipes'))

data/spec/backend/active_record_job_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'backend/shared_backend_spec'
+require 'delayed/backend/active_record'
+
+describe Delayed::Backend::ActiveRecord::Job do
+  before(:all) do
+    @backend = Delayed::Backend::ActiveRecord::Job
+  end
+  
+  before(:each) do
+    Delayed::Backend::ActiveRecord::Job.delete_all
+    SimpleJob.runs = 0
+  end
+  
+  after do
+    Time.zone = nil
+  end
+  
+  it_should_behave_like 'a backend'
+
+  context "db_time_now" do
+    it "should return time in current time zone if set" 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
+      Delayed::Backend::ActiveRecord::Job.db_time_now.zone.should == 'UTC'
+    end
+
+    it "should return local time if that is the AR default" do
+      Time.zone = 'Central Time (US & Canada)'
+      ActiveRecord::Base.default_timezone = :local
+      %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!)
+      Delayed::Backend::ActiveRecord::Job.after_fork
+    end
+  end
+end

data/spec/backend/data_mapper_job_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+require 'backend/shared_backend_spec'
+require 'delayed/backend/data_mapper'
+
+describe Delayed::Backend::DataMapper::Job do
+  before(:all) do
+    @backend = Delayed::Backend::DataMapper::Job
+  end
+  
+  before(:each) do
+    # reset database before each example is run
+    DataMapper.auto_migrate!
+  end
+  
+  it_should_behave_like 'a backend'
+end

data/spec/backend/mongo_mapper_job_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+require 'backend/shared_backend_spec'
+require 'delayed/backend/mongo_mapper'
+
+describe Delayed::Backend::MongoMapper::Job do
+  before(:all) do
+    @backend = Delayed::Backend::MongoMapper::Job
+  end
+  
+  before(:each) do
+    MongoMapper.database.collections.each(&:remove)
+  end
+  
+  it_should_behave_like 'a backend'
+
+  describe "indexes" do
+    it "should have combo index on priority and run_at" do
+      @backend.collection.index_information.detect { |index| index[0] == 'priority_1_run_at_1' }.should_not be_nil
+    end
+
+    it "should have index on locked_by" do
+      @backend.collection.index_information.detect { |index| index[0] == 'locked_by_1' }.should_not be_nil
+    end
+  end
+  
+  describe "delayed method" do
+    class MongoStoryReader
+      def read(story)
+        "Epilog: #{story.tell}"
+      end
+    end
+    
+    class MongoStory
+      include ::MongoMapper::Document
+      key :text, String
+      
+      def tell
+        text
+      end
+    end
+    
+    it "should ignore not found errors because they are permanent" do
+      story = MongoStory.create :text => 'Once upon a time...'
+      job = story.send_later(:tell)
+      story.destroy
+      lambda { job.invoke_job }.should_not raise_error
+    end
+
+    it "should store the object as string" do
+      story = MongoStory.create :text => 'Once upon a time...'
+      job = story.send_later(:tell)
+
+      job.payload_object.class.should   == Delayed::PerformableMethod
+      job.payload_object.object.should  == "LOAD;MongoStory;#{story.id}"
+      job.payload_object.method.should  == :tell
+      job.payload_object.args.should    == []
+      job.payload_object.perform.should == 'Once upon a time...'
+    end
+
+    it "should store arguments as string" do
+      story = MongoStory.create :text => 'Once upon a time...'
+      job = MongoStoryReader.new.send_later(:read, story)
+      job.payload_object.class.should   == Delayed::PerformableMethod
+      job.payload_object.method.should  == :read
+      job.payload_object.args.should    == ["LOAD;MongoStory;#{story.id}"]
+      job.payload_object.perform.should == 'Epilog: Once upon a time...'
+    end
+  end
+  
+  describe "before_fork" do
+    after do
+      MongoMapper.connection.connect_to_master
+    end
+    
+    it "should disconnect" do
+      lambda do
+        Delayed::Backend::MongoMapper::Job.before_fork
+      end.should change { !!MongoMapper.connection.connected? }.from(true).to(false)
+    end
+  end
+
+  describe "after_fork" do
+    before do
+      MongoMapper.connection.close
+    end
+    
+    it "should call reconnect" do
+      lambda do
+        Delayed::Backend::MongoMapper::Job.after_fork
+      end.should change { !!MongoMapper.connection.connected? }.from(false).to(true)
+    end
+  end
+  
+end