delayed_job 1.9.0pre → 2.0.0

data/README.textile

@@ -40,30 +40,32 @@ After delayed_job is installed, you will need to setup the backend.
 
 h2. Backends
 
-delayed_job supports multiple backends for storing the job queue. The default is Active Record, which requires a jobs table.
+delayed_job supports multiple backends for storing the job queue. There are currently implementations for Active Record, MongoMapper, and DataMapper.
+
+h3. Active Record
+
+The default is Active Record, which requires a jobs table.
 
 <pre>
-script/generate delayed_job
-rake db:migrate
+$ script/generate delayed_job
+$ rake db:migrate
 </pre>
 
-You can change the backend in an initializer:
+h3. MongoMapper
 
 <pre>
 # config/initializers/delayed_job.rb
 Delayed::Worker.backend = :mongo_mapper
 </pre>
 
-h2. Upgrading to 1.8
-
-If you are upgrading from a previous release, you will need to generate the new @script/delayed_job@:
+h3. DataMapper
 
 <pre>
-script/generate delayed_job --skip-migration
+# config/initializers/delayed_job.rb
+Delayed::Worker.backend = :data_mapper
+Delayed::Worker.backend.auto_upgrade!
 </pre>
 
-Known Issues: script/delayed_job does not work properly with anything besides the Active Record backend.  That will be resolved before the next gem release.
-
 h2. Queuing Jobs
 
 Call @#send_later(method, params)@ on any object and it will be processed in the background.
@@ -92,7 +94,7 @@ device.deliver
 
 h2. Running Jobs
 
-@script/delayed_job@ can be used to manage a background process which will start working off jobs.
+@script/delayed_job@ can be used to manage a background process which will start working off jobs.  Make sure you've run `script/generate delayed_job`.
 
 <pre>
 $ RAILS_ENV=production script/delayed_job start

data/Rakefile

@@ -18,11 +18,17 @@ Jeweler::Tasks.new do |s|
   s.rdoc_options = ["--main", "README.textile", "--inline-source", "--line-numbers"]
   s.extra_rdoc_files = ["README.textile"]
   
-  s.test_files = Dir['spec/**/*']
+  s.test_files = Dir['spec/*_spec.rb']
   
   s.add_dependency "daemons"
   s.add_development_dependency "rspec"
   s.add_development_dependency "sqlite3-ruby"
+  s.add_development_dependency "mongo_mapper"
+  s.add_development_dependency "dm-core"
+  s.add_development_dependency "dm-observer"
+  s.add_development_dependency "dm-aggregates"
+  s.add_development_dependency "do_sqlite3"
+  s.add_development_dependency "database_cleaner"
 end
 
 require 'spec/rake/spectask'

data/VERSION

@@ -1 +1 @@
-1.9.0pre
+2.0.0

data/benchmarks.rb

@@ -0,0 +1,19 @@
+$:.unshift(File.dirname(__FILE__) + '/lib')
+require 'rubygems'
+require 'logger'
+require 'delayed_job'
+require 'benchmark'
+
+Delayed::Worker.logger = Logger.new('/dev/null')
+
+Benchmark.bm(10) do |x|
+  [:active_record, :mongo_mapper, :data_mapper].each do |backend|
+    require "spec/setup/#{backend}"
+    Delayed::Worker.backend = backend
+  
+    n = 10000
+    n.times { "foo".send_later :length }
+
+    x.report(backend.to_s) { Delayed::Worker.new(:quiet => true).work_off(n) }
+  end  
+end

data/delayed_job.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{delayed_job}
-  s.version = "1.9.0pre"
+  s.version = "2.0.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Brandon Keepers", "Tobias L\303\274tke"]
-  s.date = %q{2010-03-26}
+  s.date = %q{2010-04-03}
   s.description = %q{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).}
@@ -23,6 +23,7 @@ This gem is collectiveidea's fork (http://github.com/collectiveidea/delayed_job)
      "README.textile",
      "Rakefile",
      "VERSION",
+     "benchmarks.rb",
      "contrib/delayed_job.monitrc",
      "delayed_job.gemspec",
      "generators/delayed_job/delayed_job_generator.rb",
@@ -30,6 +31,7 @@ This gem is collectiveidea's fork (http://github.com/collectiveidea/delayed_job)
      "generators/delayed_job/templates/script",
      "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",
@@ -41,12 +43,14 @@ This gem is collectiveidea's fork (http://github.com/collectiveidea/delayed_job)
      "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",
@@ -56,20 +60,11 @@ This gem is collectiveidea's fork (http://github.com/collectiveidea/delayed_job)
   s.homepage = %q{http://github.com/collectiveidea/delayed_job}
   s.rdoc_options = ["--main", "README.textile", "--inline-source", "--line-numbers"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.5}
+  s.rubygems_version = %q{1.3.6}
   s.summary = %q{Database-backed asynchronous priority queue system -- Extracted from Shopify}
   s.test_files = [
-    "spec/backend",
-     "spec/backend/active_record_job_spec.rb",
-     "spec/backend/mongo_mapper_job_spec.rb",
-     "spec/backend/shared_backend_spec.rb",
-     "spec/delayed_method_spec.rb",
+    "spec/delayed_method_spec.rb",
      "spec/performable_method_spec.rb",
-     "spec/sample_jobs.rb",
-     "spec/setup",
-     "spec/setup/active_record.rb",
-     "spec/setup/mongo_mapper.rb",
-     "spec/spec_helper.rb",
      "spec/story_spec.rb",
      "spec/worker_spec.rb"
   ]
@@ -82,15 +77,33 @@ This gem is collectiveidea's fork (http://github.com/collectiveidea/delayed_job)
       s.add_runtime_dependency(%q<daemons>, [">= 0"])
       s.add_development_dependency(%q<rspec>, [">= 0"])
       s.add_development_dependency(%q<sqlite3-ruby>, [">= 0"])
+      s.add_development_dependency(%q<mongo_mapper>, [">= 0"])
+      s.add_development_dependency(%q<dm-core>, [">= 0"])
+      s.add_development_dependency(%q<dm-observer>, [">= 0"])
+      s.add_development_dependency(%q<dm-aggregates>, [">= 0"])
+      s.add_development_dependency(%q<do_sqlite3>, [">= 0"])
+      s.add_development_dependency(%q<database_cleaner>, [">= 0"])
     else
       s.add_dependency(%q<daemons>, [">= 0"])
       s.add_dependency(%q<rspec>, [">= 0"])
       s.add_dependency(%q<sqlite3-ruby>, [">= 0"])
+      s.add_dependency(%q<mongo_mapper>, [">= 0"])
+      s.add_dependency(%q<dm-core>, [">= 0"])
+      s.add_dependency(%q<dm-observer>, [">= 0"])
+      s.add_dependency(%q<dm-aggregates>, [">= 0"])
+      s.add_dependency(%q<do_sqlite3>, [">= 0"])
+      s.add_dependency(%q<database_cleaner>, [">= 0"])
     end
   else
     s.add_dependency(%q<daemons>, [">= 0"])
     s.add_dependency(%q<rspec>, [">= 0"])
     s.add_dependency(%q<sqlite3-ruby>, [">= 0"])
+    s.add_dependency(%q<mongo_mapper>, [">= 0"])
+    s.add_dependency(%q<dm-core>, [">= 0"])
+    s.add_dependency(%q<dm-observer>, [">= 0"])
+    s.add_dependency(%q<dm-aggregates>, [">= 0"])
+    s.add_dependency(%q<do_sqlite3>, [">= 0"])
+    s.add_dependency(%q<database_cleaner>, [">= 0"])
   end
 end
 

data/lib/delayed/backend/base.rb

@@ -28,6 +28,11 @@ module Delayed
         # Hook method that is called after a new worker is forked
         def after_fork
         end
+        
+        def work_off(num = 100)
+          warn "[DEPRECATION] `Delayed::Job.work_off` is deprecated. Use `Delayed::Worker.new.work_off instead."
+          Delayed::Worker.new.work_off(num)
+        end
       end
       
       ParseObjectFromYaml = /\!ruby\/\w+\:([^\s]+)/

data/lib/delayed/backend/data_mapper.rb

@@ -0,0 +1,124 @@
+require 'dm-core'
+require 'dm-observer'
+require 'dm-aggregates'
+
+module DataMapper
+  module Resource
+    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 DataMapper
+      class Job
+        include ::DataMapper::Resource
+        include Delayed::Backend::Base
+        
+        storage_names[:default] = 'delayed_jobs'
+        
+        property :id,          Serial
+        property :priority,    Integer, :default => 0
+        property :attempts,    Integer, :default => 0
+        property :handler,     String
+        property :run_at,      Time
+        property :locked_at,   Time
+        property :locked_by,   String
+        property :failed_at,   Time
+        property :last_error,  String
+                
+        def self.db_time_now
+          Time.now
+        end
+                
+        def self.find_available(worker_name, limit = 5, max_run_time = Worker.max_run_time)
+          
+          simple_conditions = { :run_at.lte => db_time_now, :limit => limit, :failed_at => nil, :order => [:priority.asc, :run_at.asc]  }
+
+          # respect priorities
+          simple_conditions[:priority.gte] = Worker.min_priority if Worker.min_priority
+          simple_conditions[:priority.lte] = Worker.max_priority if Worker.max_priority
+          
+          # lockable 
+          lockable = (
+            # not locked or past the max time
+            ( all(:locked_at => nil ) | all(:locked_at.lt => db_time_now - max_run_time)) |
+
+            # OR locked by our worker
+            all(:locked_by => worker_name))
+            
+          # plus some other boring junk 
+          (lockable).all( simple_conditions )
+        end
+        
+        # When a worker is exiting, make sure we don't have any locked jobs.
+        def self.clear_locks!(worker_name)
+          all(:locked_by => worker_name).update(:locked_at => nil, :locked_by => nil)
+        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)
+          now = self.class.db_time_now
+          overtime = now - max_run_time
+          
+          # FIXME - this is a bit gross
+          # DM doesn't give us the number of rows affected by a collection update
+          # so we have to circumvent some niceness in DM::Collection here
+          collection = locked_by != worker ?
+            (self.class.all(:id => id, :run_at.lte => now) & ( self.class.all(:locked_at => nil) | self.class.all(:locked_at.lt => overtime) ) ) :
+            self.class.all(:id => id, :locked_by => worker)
+          
+          attributes = collection.model.new(:locked_at => now, :locked_by => worker).dirty_attributes
+          affected_rows = self.repository.update(attributes, collection)
+            
+          if affected_rows == 1
+            self.locked_at = now
+            self.locked_by = worker
+            return true
+          else
+            return false
+          end
+        end
+        
+        # these are common to the other backends, so we provide an implementation
+        def self.delete_all
+          Delayed::Job.auto_migrate!
+        end
+        
+        def self.find id
+          get id
+        end
+        
+        def update_attributes(attributes)
+          attributes.each do |k,v|
+            self[k] = v
+          end
+          self.save
+        end
+        
+        
+      end
+      
+      class JobObserver
+        include ::DataMapper::Observer
+
+        observe Job
+
+        before :save do
+          self.run_at ||= self.class.db_time_now
+        end  
+      end
+    end
+  end
+end

data/spec/backend/active_record_job_spec.rb

@@ -1,15 +1,14 @@
 require 'spec_helper'
+require 'backend/shared_backend_spec'
 require 'delayed/backend/active_record'
 
-describe Delayed::Job do
+describe Delayed::Backend::ActiveRecord::Job do
   before(:all) do
-    @backend = Delayed::Job
+    @backend = Delayed::Backend::ActiveRecord::Job
   end
   
   before(:each) do
-    Delayed::Worker.max_priority = nil
-    Delayed::Worker.min_priority = nil
-    Delayed::Job.delete_all
+    Delayed::Backend::ActiveRecord::Job.delete_all
     SimpleJob.runs = 0
   end
   
@@ -28,14 +27,13 @@ describe Delayed::Job do
     it "should return UTC time if that is the AR default" do
       Time.zone = nil
       ActiveRecord::Base.default_timezone = :utc
-      Delayed::Job.db_time_now.zone.should == '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::Job.db_time_now.zone)
+      %w(CST CDT).should include(Delayed::Backend::ActiveRecord::Job.db_time_now.zone)
     end
-  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

@@ -1,5 +1,5 @@
 require 'spec_helper'
-
+require 'backend/shared_backend_spec'
 require 'delayed/backend/mongo_mapper'
 
 describe Delayed::Backend::MongoMapper::Job do

data/spec/backend/shared_backend_spec.rb

@@ -4,6 +4,8 @@ shared_examples_for 'a backend' do
   end
 
   before do
+    Delayed::Worker.max_priority = nil
+    Delayed::Worker.min_priority = nil
     SimpleJob.runs = 0
   end
   

data/spec/setup/active_record.rb

@@ -1,27 +1,27 @@
 require 'active_record'
 
 ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
-ActiveRecord::Base.logger = DELAYED_JOB_LOGGER
+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.string   :last_error
+    table.text     :last_error
     table.datetime :run_at
     table.datetime :locked_at
-    table.string   :locked_by
     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...

data/spec/setup/data_mapper.rb

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

data/spec/setup/mongo_mapper.rb

@@ -1,4 +1,6 @@
-MongoMapper.connection = Mongo::Connection.new nil, nil, :logger => DELAYED_JOB_LOGGER
+require 'mongo_mapper'
+
+MongoMapper.connection = Mongo::Connection.new nil, nil, :logger => Delayed::Worker.logger
 MongoMapper.database = 'delayed_job'
 
 unless defined?(Story)
@@ -7,7 +9,7 @@ unless defined?(Story)
     def tell; text; end       
     def whatever(n, _); tell*n; end
     def self.count; end
-    
+  
     handle_asynchronously :whatever
   end
 end

data/spec/spec_helper.rb

@@ -4,32 +4,22 @@ require 'rubygems'
 require 'spec'
 require 'logger'
 
-backends_available = []
-%w(active_record mongo_mapper).each do |backend|
-  begin
-    require backend
-    backends_available << backend
-  rescue LoadError => e
-    $stderr.puts "The backend '#{backend}' is not available. Skipping tests"
-  end
-end
-
-if backends_available.empty?
-  raise LoadError, "Cannot run delayed_job specs. No backends available"
-end
-
 require 'delayed_job'
 require 'sample_jobs'
-require 'backend/shared_backend_spec'
 
-DELAYED_JOB_LOGGER = Logger.new('/tmp/dj.log')
-Delayed::Worker.logger = DELAYED_JOB_LOGGER
+Delayed::Worker.logger = Logger.new('/tmp/dj.log')
 
-DEFAULT_BACKEND = backends_available.first.to_sym
-
-Delayed::Worker.backend = DEFAULT_BACKEND
-
-backends_available.each do |backend|
-  require "setup/#{backend}"
-  require "backend/#{backend}_job_spec"
+# 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/worker_spec.rb

@@ -5,21 +5,6 @@ describe Delayed::Worker do
     Delayed::Job.create(opts.merge(:payload_object => SimpleJob.new))
   end
 
-  before(:all) do
-    Delayed::Worker.send :public, :work_off
-  end
-
-  before(:each) do
-    # Make sure backend is set to active record
-    Delayed::Worker.backend = DEFAULT_BACKEND
-    
-    @worker = Delayed::Worker.new(:max_priority => nil, :min_priority => nil, :quiet => true)
-
-    Delayed::Job.delete_all
-    
-    SimpleJob.runs = 0
-  end
-  
   describe "backend=" do
     it "should set the Delayed::Job constant to the backend" do
       @clazz = Class.new
@@ -34,145 +19,157 @@ describe Delayed::Worker do
     end
   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
+  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
-    end
-  end
   
-  context "worker prioritization" do
-    before(:each) do
-      @worker = Delayed::Worker.new(:max_priority => 5, :min_priority => -5, :quiet => true)
-    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
+        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
+          job_create(:priority => -10)
+          job_create(:priority => 0)
+          @worker.work_off
 
-      SimpleJob.runs.should == 1
-    end
+          SimpleJob.runs.should == 1
+        end
 
-    it "should only work_off jobs that are <= max_priority" do
-      SimpleJob.runs.should == 0
+        it "should only work_off jobs that are <= max_priority" do
+          SimpleJob.runs.should == 0
 
-      job_create(:priority => 10)
-      job_create(:priority => 0)
+          job_create(:priority => 10)
+          job_create(:priority => 0)
 
-      @worker.work_off
+          @worker.work_off
 
-      SimpleJob.runs.should == 1
-    end
-  end
+          SimpleJob.runs.should == 1
+        end
+      end
 
-  context "while running with locked and expired jobs" do
-    before(:each) do
-      @worker.name = 'worker1'
-    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 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 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 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
+        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
+      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
+          @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 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
+        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
+      context "reschedule" do
+        before do
+          @job = Delayed::Job.create :payload_object => SimpleJob.new
+        end
     
-    context "and we want to destroy jobs" do
-      before do
-        Delayed::Worker.destroy_failed_jobs = true
-      end
+        context "and we want to destroy jobs" do
+          before do
+            Delayed::Worker.destroy_failed_jobs = true
+          end
       
-      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 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
+          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
+        context "and we don't want to destroy jobs" do
+          before do
+            Delayed::Worker.destroy_failed_jobs = false
+          end
       
-      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 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
+          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

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: delayed_job
 version: !ruby/object:Gem::Version 
-  version: 1.9.0pre
+  prerelease: false
+  segments: 
+  - 2
+  - 0
+  - 0
+  version: 2.0.0
 platform: ruby
 authors: 
 - Brandon Keepers
@@ -10,39 +15,117 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-26 00:00:00 -04:00
+date: 2010-04-03 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: daemons
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
         version: "0"
-    version: 
+  type: :runtime
+  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: rspec
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
         version: "0"
-    version: 
+  type: :development
+  version_requirements: *id002
 - !ruby/object:Gem::Dependency 
   name: sqlite3-ruby
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: mongo_mapper
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: dm-core
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
   type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: dm-observer
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
         version: "0"
-    version: 
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: dm-aggregates
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: do_sqlite3
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id008
+- !ruby/object:Gem::Dependency 
+  name: database_cleaner
+  prerelease: false
+  requirement: &id009 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id009
 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.
   
@@ -60,6 +143,7 @@ files:
 - README.textile
 - Rakefile
 - VERSION
+- benchmarks.rb
 - contrib/delayed_job.monitrc
 - delayed_job.gemspec
 - generators/delayed_job/delayed_job_generator.rb
@@ -67,6 +151,7 @@ files:
 - generators/delayed_job/templates/script
 - 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
@@ -78,12 +163,14 @@ files:
 - 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
@@ -105,30 +192,25 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: Database-backed asynchronous priority queue system -- Extracted from Shopify
 test_files: 
-- spec/backend/active_record_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/mongo_mapper.rb
-- spec/spec_helper.rb
 - spec/story_spec.rb
 - spec/worker_spec.rb