koombea-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,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,121 @@
+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
+
+    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)
+    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
+
+    def say(text, level = Logger::INFO)
+      puts text unless @quiet
+      logger.add level, text if logger
+    end
+
+    protected
+
+    # 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(max_run_time = job_max_run_time)
+
+      # 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, max_run_time).detect do |job|
+        if job.lock_exclusively!(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
+
+      if job.nil?
+        nil # we didn't do any work, all 5 were not lockable
+      else
+        job.run(max_run_time)
+      end
+    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
+  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