opsb-delayed_job 2.0.3

data/spec/performable_method_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+class StoryReader
+  def read(story)
+    "Epilog: #{story.tell}"
+  end
+end
+
+describe Delayed::PerformableMethod do
+  
+  it "should ignore ActiveRecord::RecordNotFound errors because they are permanent" do
+    story = Story.create :text => 'Once upon...'
+    p = Delayed::PerformableMethod.new(story, :tell, [])
+    story.destroy
+    lambda { p.perform }.should_not raise_error
+  end
+  
+  it "should store the object as string if its an active record" do
+    story = Story.create :text => 'Once upon...'
+    p = Delayed::PerformableMethod.new(story, :tell, [])
+    p.class.should   == Delayed::PerformableMethod
+    p.object.should  == "LOAD;Story;#{story.id}"
+    p.method.should  == :tell
+    p.args.should    == []
+    p.perform.should == 'Once upon...'
+  end
+  
+  it "should allow class methods to be called on ActiveRecord models" do
+    p = Delayed::PerformableMethod.new(Story, :count, [])
+    lambda { p.send(:load, p.object) }.should_not raise_error
+  end
+  
+  it "should store arguments as string if they are active record objects" do
+    story = Story.create :text => 'Once upon...'
+    reader = StoryReader.new
+    p = Delayed::PerformableMethod.new(reader, :read, [story])
+    p.class.should   == Delayed::PerformableMethod
+    p.method.should  == :read
+    p.args.should    == ["LOAD;Story;#{story.id}"]
+    p.perform.should == 'Epilog: Once upon...'
+  end                 
+end

data/spec/sample_jobs.rb

@@ -0,0 +1,25 @@
+class SimpleJob
+  cattr_accessor :runs; self.runs = 0
+  def perform; @@runs += 1; end
+end
+
+class ErrorJob
+  cattr_accessor :runs; self.runs = 0
+  def perform; raise 'did not work'; end
+end             
+
+class LongRunningJob
+  def perform; sleep 250; end
+end
+
+class OnPermanentFailureJob < SimpleJob
+  def on_permanent_failure
+  end
+end
+
+module M
+  class ModuleJob
+    cattr_accessor :runs; self.runs = 0
+    def perform; @@runs += 1; end    
+  end
+end

data/spec/setup/active_record.rb

@@ -0,0 +1,33 @@
+require 'active_record'
+
+ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
+ActiveRecord::Base.logger = Delayed::Worker.logger
+ActiveRecord::Migration.verbose = false
+
+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.text     :last_error
+    table.datetime :run_at
+    table.datetime :locked_at
+    table.datetime :failed_at
+    table.string   :locked_by
+    table.timestamps
+  end
+
+  add_index :delayed_jobs, [:priority, :run_at], :name => 'delayed_jobs_priority'
+
+  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/setup/data_mapper.rb

@@ -0,0 +1,8 @@
+require 'dm-core'
+require 'dm-validations'
+
+require 'delayed/backend/data_mapper'
+
+DataMapper.logger = Delayed::Worker.logger
+DataMapper.setup(:default, "sqlite3::memory:")
+DataMapper.auto_migrate!

data/spec/setup/mongo_mapper.rb

@@ -0,0 +1,17 @@
+require 'mongo_mapper'
+
+MongoMapper.config = {
+  RAILS_ENV => {'database' => 'delayed_job'}
+}
+MongoMapper.connect RAILS_ENV
+
+unless defined?(Story)
+  class Story
+    include ::MongoMapper::Document
+    def tell; text; end       
+    def whatever(n, _); tell*n; end
+    def self.count; end
+  
+    handle_asynchronously :whatever
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'rubygems'
+require 'spec'
+require 'logger'
+
+require 'delayed_job'
+require 'sample_jobs'
+
+Delayed::Worker.logger = Logger.new('/tmp/dj.log')
+RAILS_ENV = 'test'
+
+# determine the available backends
+BACKENDS = []
+Dir.glob("#{File.dirname(__FILE__)}/setup/*.rb") do |backend|
+  begin
+    backend = File.basename(backend, '.rb')
+    require "setup/#{backend}"
+    require "backend/#{backend}_job_spec"
+    BACKENDS << backend.to_sym
+  rescue LoadError
+    puts "Unable to load #{backend} backend! #{$!}"
+  end
+end
+
+Delayed::Worker.backend = BACKENDS.first

data/spec/story_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe "A story" do
+
+  before(:all) do
+    @story = Story.create :text => "Once upon a time..."
+  end
+
+  it "should be shared" do
+    @story.tell.should == 'Once upon a time...'
+  end
+
+  it "should not return its result if it storytelling is delayed" do
+    @story.send_later(:tell).should_not == 'Once upon a time...'
+  end
+
+end

data/spec/worker_spec.rb

@@ -0,0 +1,216 @@
+require 'spec_helper'
+
+describe Delayed::Worker do
+  def job_create(opts = {})
+    Delayed::Job.create(opts.merge(:payload_object => SimpleJob.new))
+  end
+
+  describe "backend=" do
+    it "should set the Delayed::Job constant to the backend" do
+      @clazz = Class.new
+      Delayed::Worker.backend = @clazz
+      Delayed::Job.should == @clazz
+    end
+    
+    it "should set backend with a symbol" do
+      Delayed::Worker.backend = Class.new
+      Delayed::Worker.backend = :active_record
+      Delayed::Worker.backend.should == Delayed::Backend::ActiveRecord::Job
+    end
+  end
+  
+  BACKENDS.each do |backend|
+    describe "with the #{backend} backend" do
+      before do
+        Delayed::Worker.backend = backend
+        Delayed::Job.delete_all
+
+        @worker = Delayed::Worker.new(:max_priority => nil, :min_priority => nil, :quiet => true)
+
+        SimpleJob.runs = 0
+      end
+  
+      describe "running a job" do
+        it "should fail after Worker.max_run_time" do
+          begin
+            old_max_run_time = Delayed::Worker.max_run_time
+            Delayed::Worker.max_run_time = 1.second
+            @job = Delayed::Job.create :payload_object => LongRunningJob.new
+            @worker.run(@job)
+            @job.reload.last_error.should =~ /expired/
+            @job.attempts.should == 1
+          ensure
+            Delayed::Worker.max_run_time = old_max_run_time
+          end
+        end
+      end
+  
+      context "worker prioritization" do
+        before(:each) do
+          @worker = Delayed::Worker.new(:max_priority => 5, :min_priority => -5, :quiet => true)
+        end
+
+        it "should only work_off jobs that are >= min_priority" do
+          SimpleJob.runs.should == 0
+
+          job_create(:priority => -10)
+          job_create(:priority => 0)
+          @worker.work_off
+
+          SimpleJob.runs.should == 1
+        end
+
+        it "should only work_off jobs that are <= max_priority" do
+          SimpleJob.runs.should == 0
+
+          job_create(:priority => 10)
+          job_create(:priority => 0)
+
+          @worker.work_off
+
+          SimpleJob.runs.should == 1
+        end
+      end
+
+      context "while running with locked and expired jobs" do
+        before(:each) do
+          @worker.name = 'worker1'
+        end
+    
+        it "should not run jobs locked by another worker" do
+          job_create(:locked_by => 'other_worker', :locked_at => (Delayed::Job.db_time_now - 1.minutes))
+          lambda { @worker.work_off }.should_not change { SimpleJob.runs }
+        end
+    
+        it "should run open jobs" do
+          job_create
+          lambda { @worker.work_off }.should change { SimpleJob.runs }.from(0).to(1)
+        end
+    
+        it "should run expired jobs" do
+          expired_time = Delayed::Job.db_time_now - (1.minutes + Delayed::Worker.max_run_time)
+          job_create(:locked_by => 'other_worker', :locked_at => expired_time)
+          lambda { @worker.work_off }.should change { SimpleJob.runs }.from(0).to(1)
+        end
+    
+        it "should run own jobs" do
+          job_create(:locked_by => @worker.name, :locked_at => (Delayed::Job.db_time_now - 1.minutes))
+          lambda { @worker.work_off }.should change { SimpleJob.runs }.from(0).to(1)
+        end
+      end
+  
+      describe "failed jobs" do
+        before do
+          # reset defaults
+          Delayed::Worker.destroy_failed_jobs = true
+          Delayed::Worker.max_attempts = 25
+
+          @job = Delayed::Job.enqueue ErrorJob.new
+        end
+
+        it "should record last_error when destroy_failed_jobs = false, max_attempts = 1" do
+          Delayed::Worker.destroy_failed_jobs = false
+          Delayed::Worker.max_attempts = 1
+          @worker.run(@job)
+          @job.reload
+          @job.last_error.should =~ /did not work/
+          @job.last_error.should =~ /worker_spec.rb/
+          @job.attempts.should == 1
+          @job.failed_at.should_not be_nil
+        end
+    
+        it "should re-schedule jobs after failing" do
+          @worker.run(@job)
+          @job.reload
+          @job.last_error.should =~ /did not work/
+          @job.last_error.should =~ /sample_jobs.rb:8:in `perform'/
+          @job.attempts.should == 1
+          @job.run_at.should > Delayed::Job.db_time_now - 10.minutes
+          @job.run_at.should < Delayed::Job.db_time_now + 10.minutes
+        end
+      end
+  
+      context "reschedule" do
+        before do
+          @job = Delayed::Job.create :payload_object => SimpleJob.new
+        end
+   
+        share_examples_for "any failure more than Worker.max_attempts times" do
+          context "when the job's payload has an #on_permanent_failure hook" do
+            before do
+              @job = Delayed::Job.create :payload_object => OnPermanentFailureJob.new
+              @job.payload_object.should respond_to :on_permanent_failure
+            end
+
+            it "should run that hook" do
+              @job.payload_object.should_receive :on_permanent_failure
+              Delayed::Worker.max_attempts.times { @worker.reschedule(@job) }
+            end
+          end
+
+          context "when the job's payload has no #on_permanent_failure hook" do
+            # It's a little tricky to test this in a straightforward way, 
+            # because putting a should_not_receive expectation on 
+            # @job.payload_object.on_permanent_failure makes that object
+            # incorrectly return true to 
+            # payload_object.respond_to? :on_permanent_failure, which is what
+            # reschedule uses to decide whether to call on_permanent_failure.  
+            # So instead, we just make sure that the payload_object as it 
+            # already stands doesn't respond_to? on_permanent_failure, then
+            # shove it through the iterated reschedule loop and make sure we
+            # don't get a NoMethodError (caused by calling that nonexistent
+            # on_permanent_failure method).
+            
+            before do
+              @job.payload_object.should_not respond_to(:on_permanent_failure)
+            end
+
+            it "should not try to run that hook" do
+              lambda do
+                Delayed::Worker.max_attempts.times { @worker.reschedule(@job) }
+              end.should_not raise_exception(NoMethodError)
+            end
+          end
+        end
+
+        context "and we want to destroy jobs" do
+          before do
+            Delayed::Worker.destroy_failed_jobs = true
+          end
+
+          it_should_behave_like "any failure more than Worker.max_attempts times"
+
+          it "should be destroyed if it failed more than Worker.max_attempts times" do
+            @job.should_receive(:destroy)
+            Delayed::Worker.max_attempts.times { @worker.reschedule(@job) }
+          end
+      
+          it "should not be destroyed if failed fewer than Worker.max_attempts times" do
+            @job.should_not_receive(:destroy)
+            (Delayed::Worker.max_attempts - 1).times { @worker.reschedule(@job) }
+          end
+        end
+    
+        context "and we don't want to destroy jobs" do
+          before do
+            Delayed::Worker.destroy_failed_jobs = false
+          end
+      
+          it_should_behave_like "any failure more than Worker.max_attempts times"
+
+          it "should be failed if it failed more than Worker.max_attempts times" do
+            @job.reload.failed_at.should == nil
+            Delayed::Worker.max_attempts.times { @worker.reschedule(@job) }
+            @job.reload.failed_at.should_not == nil
+          end
+
+          it "should not be failed if it failed fewer than Worker.max_attempts times" do
+            (Delayed::Worker.max_attempts - 1).times { @worker.reschedule(@job) }
+            @job.reload.failed_at.should == nil
+          end
+        end
+      end
+    end
+  end
+  
+end

data/tasks/jobs.rake

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

metadata

@@ -0,0 +1,256 @@
+--- !ruby/object:Gem::Specification 
+name: opsb-delayed_job
+version: !ruby/object:Gem::Version 
+  hash: 9
+  prerelease: false
+  segments: 
+  - 2
+  - 0
+  - 3
+  version: 2.0.3
+platform: ruby
+authors: 
+- Brandon Keepers
+- "Tobias L\xC3\xBCtke"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-16 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: daemons
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: sqlite3-ruby
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: mongo_mapper
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: dm-core
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: dm-observer
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: dm-aggregates
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: dm-validations
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id008
+- !ruby/object:Gem::Dependency 
+  name: do_sqlite3
+  prerelease: false
+  requirement: &id009 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id009
+- !ruby/object:Gem::Dependency 
+  name: database_cleaner
+  prerelease: false
+  requirement: &id010 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id010
+description: |-
+  Delayed_job (or DJ) encapsulates the common pattern of asynchronously executing longer tasks in the background. It is a direct extraction from Shopify where the job table is responsible for a multitude of core tasks.
+  
+  This gem is collectiveidea's fork (http://github.com/collectiveidea/delayed_job).
+email: tobi@leetsoft.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.textile
+files: 
+- .gitignore
+- MIT-LICENSE
+- README.textile
+- Rakefile
+- VERSION
+- benchmarks.rb
+- contrib/delayed_job.monitrc
+- contrib/delayed_job_multiple.monitrc
+- delayed_job.gemspec
+- generators/delayed_job/delayed_job_generator.rb
+- generators/delayed_job/templates/migration.rb
+- generators/delayed_job/templates/script
+- init.rb
+- lib/delayed/backend/active_record.rb
+- lib/delayed/backend/base.rb
+- lib/delayed/backend/data_mapper.rb
+- lib/delayed/backend/mongo_mapper.rb
+- lib/delayed/command.rb
+- lib/delayed/message_sending.rb
+- lib/delayed/performable_method.rb
+- lib/delayed/railtie.rb
+- lib/delayed/recipes.rb
+- lib/delayed/tasks.rb
+- lib/delayed/worker.rb
+- lib/delayed_job.rb
+- rails/init.rb
+- recipes/delayed_job.rb
+- spec/backend/active_record_job_spec.rb
+- spec/backend/data_mapper_job_spec.rb
+- spec/backend/mongo_mapper_job_spec.rb
+- spec/backend/shared_backend_spec.rb
+- spec/delayed_method_spec.rb
+- spec/performable_method_spec.rb
+- spec/sample_jobs.rb
+- spec/setup/active_record.rb
+- spec/setup/data_mapper.rb
+- spec/setup/mongo_mapper.rb
+- spec/spec_helper.rb
+- spec/story_spec.rb
+- spec/worker_spec.rb
+- tasks/jobs.rake
+has_rdoc: true
+homepage: http://github.com/collectiveidea/delayed_job
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.textile
+- --inline-source
+- --line-numbers
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Database-backed asynchronous priority queue system -- Extracted from Shopify
+test_files: 
+- spec/delayed_method_spec.rb
+- spec/performable_method_spec.rb
+- spec/story_spec.rb
+- spec/worker_spec.rb