xspond-delayed_job 1.8.5

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,55 @@
+module Delayed
+  class PerformableMethod < Struct.new(:object, :method, :args)
+    CLASS_STRING_FORMAT = /^CLASS\:([A-Z][\w\:]+)$/
+    AR_STRING_FORMAT    = /^AR\:([A-Z][\w\:]+)\:(\d+)$/
+
+    def initialize(object, method, args)
+      raise NoMethodError, "undefined method `#{method}' for #{self.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  
+      case self.object
+      when CLASS_STRING_FORMAT then "#{$1}.#{method}"
+      when AR_STRING_FORMAT    then "#{$1}##{method}"
+      else "Unknown##{method}"
+      end      
+    end    
+
+    def perform
+      load(object).send(method, *args.map{|a| load(a)})
+    rescue ActiveRecord::RecordNotFound
+      # We cannot do anything about objects which were deleted in the meantime
+      true
+    end
+
+    private
+
+    def load(arg)
+      case arg
+      when CLASS_STRING_FORMAT then $1.constantize
+      when AR_STRING_FORMAT    then $1.constantize.find($2)
+      else arg
+      end
+    end
+
+    def dump(arg)
+      case arg
+      when Class              then class_to_string(arg)
+      when ActiveRecord::Base then ar_to_string(arg)
+      else arg
+      end
+    end
+
+    def ar_to_string(obj)
+      "AR:#{obj.class}:#{obj.id}"
+    end
+
+    def class_to_string(obj)
+      "CLASS:#{obj.name}"
+    end
+  end
+end

data/lib/delayed/recipes.rb

@@ -0,0 +1,27 @@
+# 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
+    desc "Stop the delayed_job process"
+    task :stop, :roles => :app do
+      run "cd #{current_path}; RAILS_ENV=#{rails_env} script/delayed_job stop"
+    end
+
+    desc "Start the delayed_job process"
+    task :start, :roles => :app do
+      run "cd #{current_path}; RAILS_ENV=#{rails_env} script/delayed_job start"
+    end
+
+    desc "Restart the delayed_job process"
+    task :restart, :roles => :app do
+      run "cd #{current_path}; RAILS_ENV=#{rails_env} script/delayed_job restart"
+    end
+  end
+end

data/lib/delayed/tasks.rb

@@ -0,0 +1,17 @@
+# 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
+    worker_count = ENV['WORKER_COUNT'].to_i rescue 1
+    worker_count = 1 if worker_count < 1
+    Delayed::Worker.new(:min_priority => ENV['MIN_PRIORITY'], :max_priority => ENV['MAX_PRIORITY'], :worker_count => worker_count).start
+  end
+end

data/lib/delayed/worker.rb

@@ -0,0 +1,256 @@
+module Delayed
+  class Worker
+    @@sleep_delay = 5
+
+    cattr_accessor :sleep_delay
+
+    cattr_accessor :logger
+    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
+    attr_accessor :worker_count
+
+    def job_max_run_time
+      Delayed::Job.max_run_time
+    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 initialize(options={})
+      @quiet = options[:quiet]
+      Delayed::Job.min_priority = options[:min_priority] if options.has_key?(:min_priority)
+      Delayed::Job.max_priority = options[:max_priority] if options.has_key?(:max_priority)
+      self.worker_count = options[:worker_count] || 1
+
+      @ready_queue = SizedQueue.new(1)
+      @work_queue = Queue.new
+      @results_queue = Queue.new
+    end
+
+    def start
+      say "*** Starting job worker #{name}"
+
+      trap('TERM') { say 'Exiting...'; $exit = true }
+      trap('INT')  { say 'Exiting...'; $exit = true }
+
+      consumers = []
+      1.upto(worker_count) {|i| consumers << start_consumer(i) }
+
+      monitor = Thread.new { monitor_consumers(consumers) }
+
+      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
+
+      worker_count.times {|i| @work_queue << nil }
+      @ready_queue.pop while !@ready_queue.empty?
+      monitor.run if monitor.status
+      monitor.value
+      consumers.each do |c|
+        begin
+          c.value
+        rescue Exception => e
+          say e, Logger::ERROR
+        end
+      end
+
+    ensure
+      1.upto(worker_count) do |i|
+        Delayed::Job.clear_locks!("#{name} #{i}")
+      end
+    end
+
+    def say(text, level = Logger::INFO)
+      puts text unless @quiet
+      logger.add level, text if logger
+    end
+
+    protected
+
+    # After the worker has returned, this is used to
+    # determine if the job succeeded.
+    def check_result(job)
+      job.reload
+
+      if !job.locked_by.nil?
+        say "* Worker process died without processing job (#{job.name}).", Logger::ERROR
+        job.unlock
+        job.save
+      end
+
+      false
+    rescue ActiveRecord::RecordNotFound
+      true
+    end
+
+    # A small helper method which resets the connections pools
+    # so that database connections are not reused. Called after
+    # fork in the child process
+    def clear_connection_handler
+      pools = Delayed::Job.connection_handler.connection_pools
+      pools.each_pair {|k,v| pools[k] = v.class.new(v.spec) }
+      true
+    end
+
+    # A method which checks each of the consumer threads
+    # restarting them if they fail.
+    def monitor_consumers(consumers)
+      while !$exit
+        consumers.each_with_index do |c,i|
+          if c.status.nil?
+            begin
+              c.value
+            rescue Exception => e
+              say e, Logger::ERROR
+            end
+            consumers[i] = start_consumer(i)
+          elsif c.status == false
+            say "Thread exitted but should not have", Logger::ERROR
+            consumers[i] = start_consumer(i)
+          end
+        end
+        sleep(5)
+      end
+    end
+
+    # Queue up the next job we can get an exclusive lock on.
+    # If no jobs are left we return nil
+    def reserve_and_queue_one_job(num, max_run_time = job_max_run_time)
+      lock_name = "#{name} #{num}"
+
+      # 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(lock_name, 5, max_run_time).detect do |job|
+        if job.lock_exclusively!(max_run_time, lock_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
+
+      if job.nil?
+        @work_queue << true
+        nil # we didn't do any work, all 5 were not lockable
+      else
+        @work_queue << job
+        true
+      end
+    end
+
+    # Forks the process retrying on failure and reconnecting
+    # the database within the child process.
+    def safe_fork
+      begin
+        if block_given?
+          fork do
+            clear_connection_handler
+            yield
+          end
+        else
+          pid = fork
+          clear_connection_handler unless pid
+          pid
+        end
+      rescue Errno::EWOULDBLOCK
+        sleep 5
+        retry
+      end
+    end
+
+    # Generates a consumer thread that queues itself up
+    # to receive work.
+    def start_consumer(num)
+      Thread.new do
+        while !$exit
+          @ready_queue << num
+          job = @work_queue.pop
+          break if job.nil?
+          next if job == true
+
+          if job.locked_by != "#{name} #{num}"
+            say "* #{job.name} acquired for incorrect worker thread.", Logger::ERROR
+            next
+          end
+
+          pid = safe_fork do
+            $0 = "#{$0} #{job.name}"
+            job.run(job_max_run_time)
+            exit! # Prevents rails from closing parent database connections
+          end
+
+          Process.wait(pid)
+          @results_queue << job
+        end
+      end
+    end
+
+    # Generates a thread to collect and process the results from the workers.
+    def start_status_collector
+      Thread.new do
+        while job = @results_queue.pop
+          check_result(job) ? (@success += 1) : (@failure += 1)
+        end
+        Delayed::Job.connection_pool.release_connection
+      end
+    end
+
+    # Do num jobs and return stats on success/failure.
+    # Exit early if interrupted.
+    def work_off(num = 100)
+      @success, @failure = 0, 0
+
+      status_thread = start_status_collector
+
+      num.times do
+        sleep(0.5) while @ready_queue.empty? && !$exit
+        break if $exit
+
+        num = @ready_queue.pop
+        break if reserve_and_queue_one_job(num).nil? # leave if no work could be done
+
+        break if $exit # leave if we're exiting
+      end
+
+      # Stop status collector
+      @results_queue << nil
+      status_thread.value
+
+      return [@success, @failure]
+    end
+  end
+end

data/lib/delayed_job.rb

@@ -0,0 +1,13 @@
+autoload :ActiveRecord, 'activerecord'
+
+require File.dirname(__FILE__) + '/delayed/message_sending'
+require File.dirname(__FILE__) + '/delayed/performable_method'
+require File.dirname(__FILE__) + '/delayed/job'
+require File.dirname(__FILE__) + '/delayed/worker'
+
+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/recipes/delayed_job.rb

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

data/spec/database.rb

@@ -0,0 +1,43 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+$:.unshift(File.dirname(__FILE__) + '/../../rspec/lib')
+
+require 'rubygems'
+require 'active_record'
+gem 'sqlite3-ruby'
+
+require File.dirname(__FILE__) + '/../init'
+require 'spec'
+  
+ActiveRecord::Base.logger = Logger.new('/tmp/dj.log')
+ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => '/tmp/jobs.sqlite')
+ActiveRecord::Migration.verbose = false
+ActiveRecord::Base.default_timezone = :utc if Time.zone.nil?
+
+ActiveRecord::Schema.define do
+
+  create_table :delayed_jobs, :force => true do |table|
+    table.integer  :priority, :default => 0
+    table.integer  :attempts, :default => 0
+    table.text     :handler
+    table.string   :last_error
+    table.datetime :run_at
+    table.datetime :locked_at
+    table.string   :locked_by
+    table.datetime :failed_at
+    table.timestamps
+  end
+
+  create_table :stories, :force => true do |table|
+    table.string :text
+  end
+
+end
+
+
+# Purely useful for test cases...
+class Story < ActiveRecord::Base
+  def tell; text; end       
+  def whatever(n, _); tell*n; end
+  
+  handle_asynchronously :whatever
+end

data/spec/delayed_method_spec.rb

@@ -0,0 +1,150 @@
+require File.dirname(__FILE__) + '/database'
+
+class SimpleJob
+  cattr_accessor :runs; self.runs = 0
+  def perform; @@runs += 1; end
+end
+
+class RandomRubyObject  
+  def say_hello
+    'hello'
+  end
+end
+
+class ErrorObject
+
+  def throw
+    raise ActiveRecord::RecordNotFound, '...'
+    false
+  end
+
+end
+
+class StoryReader
+
+  def read(story)
+    "Epilog: #{story.tell}"
+  end
+
+end
+
+class StoryReader
+
+  def read(story)
+    "Epilog: #{story.tell}"
+  end
+
+end
+
+describe 'random ruby objects' do
+  before       { Delayed::Job.delete_all }
+
+  it "should respond_to :send_later method" do
+
+    RandomRubyObject.new.respond_to?(:send_later)
+
+  end
+
+  it "should raise a ArgumentError if send_later is called but the target method doesn't exist" do
+    lambda { RandomRubyObject.new.send_later(:method_that_deos_not_exist) }.should raise_error(NoMethodError)
+  end
+
+  it "should add a new entry to the job table when send_later is called on it" do
+    Delayed::Job.count.should == 0
+
+    RandomRubyObject.new.send_later(:to_s)
+
+    Delayed::Job.count.should == 1
+  end
+
+  it "should add a new entry to the job table when send_later is called on the class" do
+    Delayed::Job.count.should == 0
+
+    RandomRubyObject.send_later(:to_s)
+
+    Delayed::Job.count.should == 1
+  end
+
+  it "should run get the original method executed when the job is performed" do
+
+    RandomRubyObject.new.send_later(:say_hello)
+
+    Delayed::Job.count.should == 1
+  end
+
+  it "should ignore ActiveRecord::RecordNotFound errors because they are permanent" do
+
+    job = ErrorObject.new.send_later(:throw)
+
+    Delayed::Job.count.should == 1
+
+    job.run_with_lock(Delayed::Job.max_run_time, 'worker')
+
+    Delayed::Job.count.should == 0
+
+  end
+
+  it "should store the object as string if its an active record" do
+    story = Story.create :text => 'Once upon...'
+    story.send_later(:tell)
+
+    job =  Delayed::Job.find(:first)
+    job.payload_object.class.should   == Delayed::PerformableMethod
+    job.payload_object.object.should  == "AR:Story:#{story.id}"
+    job.payload_object.method.should  == :tell
+    job.payload_object.args.should    == []
+    job.payload_object.perform.should == 'Once upon...'
+  end
+
+  it "should store arguments as string if they an active record" do
+
+    story = Story.create :text => 'Once upon...'
+
+    reader = StoryReader.new
+    reader.send_later(:read, story)
+
+    job =  Delayed::Job.find(:first)
+    job.payload_object.class.should   == Delayed::PerformableMethod
+    job.payload_object.method.should  == :read
+    job.payload_object.args.should    == ["AR:Story:#{story.id}"]
+    job.payload_object.perform.should == 'Epilog: Once upon...'
+  end                 
+  
+  it "should call send later on methods which are wrapped with handle_asynchronously" do
+    story = Story.create :text => 'Once upon...'
+  
+    Delayed::Job.count.should == 0
+  
+    story.whatever(1, 5)
+  
+    Delayed::Job.count.should == 1
+    job =  Delayed::Job.find(:first)
+    job.payload_object.class.should   == Delayed::PerformableMethod
+    job.payload_object.method.should  == :whatever_without_send_later
+    job.payload_object.args.should    == [1, 5]
+    job.payload_object.perform.should == 'Once upon...'
+  end
+
+  context "send_at" do
+    it "should queue a new job" do
+      lambda do
+        "string".send_at(1.hour.from_now, :length)
+      end.should change { Delayed::Job.count }.by(1)
+    end
+    
+    it "should schedule the job in the future" do
+      time = 1.hour.from_now
+      job = "string".send_at(time, :length)
+      job.run_at.should == time
+    end
+    
+    it "should store payload as PerformableMethod" do
+      job = "string".send_at(1.hour.from_now, :count, 'r')
+      job.payload_object.class.should   == Delayed::PerformableMethod
+      job.payload_object.method.should  == :count
+      job.payload_object.args.should    == ['r']
+      job.payload_object.perform.should == 1
+    end
+  end
+
+end