delayed_job 2.0.8 → 2.1.0.pre

data/lib/delayed/yaml_ext.rb

@@ -0,0 +1,40 @@
+# These extensions allow properly serializing and autoloading of
+# Classes, Modules and Structs
+
+require 'yaml'
+
+class Module
+  yaml_as "tag:ruby.yaml.org,2002:module"
+
+  def self.yaml_new(klass, tag, val)
+    val.constantize
+  end
+
+  def to_yaml( opts = {} )
+    YAML::quick_emit( nil, opts ) { |out|
+      out.scalar(taguri, self.name, :plain)
+    }
+  end
+  
+  def yaml_tag_read_class(name)
+    # Constantize the object so that ActiveSupport can attempt
+    # its auto loading magic. Will raise LoadError if not successful.
+    name.constantize
+    name
+  end
+  
+end
+
+class Class
+  yaml_as "tag:ruby.yaml.org,2002:class"
+  remove_method :to_yaml # use Module's to_yaml
+end
+
+class Struct
+  def self.yaml_tag_read_class(name)
+    # Constantize the object so that ActiveSupport can attempt
+    # its auto loading magic. Will raise LoadError if not successful.
+    name.constantize
+    "Struct::#{ name }"
+  end
+end

data/lib/delayed_job.rb

@@ -2,9 +2,9 @@ require 'active_support'
 
 require File.dirname(__FILE__) + '/delayed/message_sending'
 require File.dirname(__FILE__) + '/delayed/performable_method'
+require File.dirname(__FILE__) + '/delayed/yaml_ext'
 require File.dirname(__FILE__) + '/delayed/backend/base'
 require File.dirname(__FILE__) + '/delayed/worker'
-require File.dirname(__FILE__) + '/delayed/deserialization_error'
 require File.dirname(__FILE__) + '/delayed/railtie' if defined?(::Rails::Railtie)
 
 Object.send(:include, Delayed::MessageSending)   

data/lib/generators/delayed_job/delayed_job_generator.rb

@@ -0,0 +1,34 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+class DelayedJobGenerator < Rails::Generators::Base
+
+  include Rails::Generators::Migration
+  
+  def self.source_root
+     @source_root ||= File.join(File.dirname(__FILE__), 'templates')
+  end
+
+  # Implement the required interface for Rails::Generators::Migration.
+  #
+  def self.next_migration_number(dirname) #:nodoc:
+    next_migration_number = current_migration_number(dirname) + 1
+    if ActiveRecord::Base.timestamped_migrations
+      [Time.now.utc.strftime("%Y%m%d%H%M%S"), "%.14d" % next_migration_number].max
+    else
+      "%.3d" % next_migration_number
+    end
+  end
+  
+  def create_script_file
+    template 'script', 'script/delayed_job'
+    chmod 'script/delayed_job', 0755
+  end
+  
+  def create_migration_file
+    if defined?(ActiveRecord)
+      migration_template 'migration.rb', 'db/migrate/create_delayed_jobs.rb'
+    end
+  end
+
+end

data/lib/generators/delayed_job/templates/migration.rb

@@ -0,0 +1,21 @@
+class CreateDelayedJobs < ActiveRecord::Migration
+  def self.up
+    create_table :delayed_jobs, :force => true do |table|
+      table.integer  :priority, :default => 0      # Allows some jobs to jump to the front of the queue
+      table.integer  :attempts, :default => 0      # Provides for retries, but still fail eventually.
+      table.text     :handler                      # YAML-encoded string of the object that will do work
+      table.text     :last_error                   # reason for last failure (See Note below)
+      table.datetime :run_at                       # When to run. Could be Time.zone.now for immediately, or sometime in the future.
+      table.datetime :locked_at                    # Set when a client is working on this object
+      table.datetime :failed_at                    # Set when all retries have failed (actually, by default, the record is deleted instead)
+      table.string   :locked_by                    # Who is working on this object (if locked)
+      table.timestamps
+    end
+	
+    add_index :delayed_jobs, [:priority, :run_at], :name => 'delayed_jobs_priority'
+  end
+  
+  def self.down
+    drop_table :delayed_jobs  
+  end
+end

data/lib/generators/delayed_job/templates/script

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'config', 'environment'))
+require 'delayed/command'
+Delayed::Command.new(ARGV).daemonize

data/spec/autoloaded/clazz.rb

@@ -0,0 +1,7 @@
+# Make sure this file does not get required manually
+module Autoloaded
+  class Clazz
+    def perform
+    end
+  end
+end

data/spec/autoloaded/struct.rb

@@ -0,0 +1,7 @@
+# Make sure this file does not get required manually
+module Autoloaded
+  class Struct < ::Struct.new(nil)
+    def perform
+    end
+  end
+end

data/spec/backend/couch_rest_job_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+require 'backend/shared_backend_spec'
+require 'delayed/backend/couch_rest'
+
+describe Delayed::Backend::CouchRest::Job do
+  before(:all) do
+    @backend = Delayed::Backend::CouchRest::Job
+  end
+  
+  before(:each) do
+    @backend.delete_all
+  end
+  
+  it_should_behave_like 'a backend'
+end

data/spec/backend/mongo_mapper_job_spec.rb

@@ -6,11 +6,11 @@ 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
@@ -22,23 +22,23 @@ describe Delayed::Backend::MongoMapper::Job 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.delay.tell
@@ -66,12 +66,12 @@ describe Delayed::Backend::MongoMapper::Job do
       job.payload_object.perform.should == 'Epilog: Once upon a time...'
     end
   end
-
+  
   describe "before_fork" do
     after do
-      MongoMapper.connection.connect
+      MongoMapper.connection.connect_to_master
     end
-
+    
     it "should disconnect" do
       lambda do
         Delayed::Backend::MongoMapper::Job.before_fork
@@ -83,12 +83,12 @@ describe Delayed::Backend::MongoMapper::Job 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

data/spec/backend/shared_backend_spec.rb

@@ -1,3 +1,9 @@
+class NamedJob < Struct.new(:perform)
+  def display_name
+    'named_job'
+  end
+end
+
 shared_examples_for 'a backend' do
   def create_job(opts = {})
     @backend.create(opts.merge(:payload_object => SimpleJob.new))
@@ -6,7 +12,6 @@ shared_examples_for 'a backend' do
   before do
     Delayed::Worker.max_priority = nil
     Delayed::Worker.min_priority = nil
-    Delayed::Worker.default_priority = 99
     SimpleJob.runs = 0
   end
   
@@ -33,11 +38,6 @@ shared_examples_for 'a backend' do
     @job.priority.should == 5
   end
 
-  it "should use default priority when it is not set" do
-    @job = @backend.enqueue SimpleJob.new
-    @job.priority.should == 99
-  end
-
   it "should be able to set run_at when enqueuing items" do
     later = @backend.db_time_now + 5.minutes
     @job = @backend.enqueue SimpleJob.new, 5, later
@@ -49,39 +49,27 @@ shared_examples_for 'a backend' do
     job = @backend.enqueue M::ModuleJob.new
     lambda { job.invoke_job }.should change { M::ModuleJob.runs }.from(0).to(1)
   end
-                   
-  it "should raise an DeserializationError when the job class is totally unknown" do
-    job = @backend.new :handler => "--- !ruby/object:JobThatDoesNotExist {}"
-    lambda { job.payload_object.perform }.should raise_error(Delayed::DeserializationError)
-  end
-
-  it "should raise an DeserializationError when the job is badly encoded" do
-    job = @backend.new :handler => "--- !ruby/object:SimpleJob {"
-    lambda { job.payload_object.perform }.should raise_error(Delayed::DeserializationError)
-  end
-
-  it "should try to load the class when it is unknown at the time of the deserialization" do
-    job = @backend.new :handler => "--- !ruby/object:JobThatDoesNotExist {}"
-    job.should_receive(:attempt_to_load).with('JobThatDoesNotExist').and_return(true)
-    lambda { job.payload_object.perform }.should raise_error(Delayed::DeserializationError)
-  end
-
-  it "should try include the namespace when loading unknown objects" do
-    job = @backend.new :handler => "--- !ruby/object:Delayed::JobThatDoesNotExist {}"
-    job.should_receive(:attempt_to_load).with('Delayed::JobThatDoesNotExist').and_return(true)
-    lambda { job.payload_object.perform }.should raise_error(Delayed::DeserializationError)
-  end
+  
+  describe "payload_object" do
+    it "should raise a DeserializationError when the job class is totally unknown" do
+      job = @backend.new :handler => "--- !ruby/object:JobThatDoesNotExist {}"
+      lambda { job.payload_object }.should raise_error(Delayed::Backend::DeserializationError)
+    end
 
-  it "should also try to load structs when they are unknown (raises TypeError)" do
-    job = @backend.new :handler => "--- !ruby/struct:JobThatDoesNotExist {}"
-    job.should_receive(:attempt_to_load).with('JobThatDoesNotExist').and_return(true)
-    lambda { job.payload_object.perform }.should raise_error(Delayed::DeserializationError)
-  end
+    it "should raise a DeserializationError when the job struct is totally unknown" do
+      job = @backend.new :handler => "--- !ruby/struct:StructThatDoesNotExist {}"
+      lambda { job.payload_object }.should raise_error(Delayed::Backend::DeserializationError)
+    end
+    
+    it "should autoload classes that are unknown at runtime" do
+      job = @backend.new :handler => "--- !ruby/object:Autoloaded::Clazz {}"
+      lambda { job.payload_object }.should_not raise_error(Delayed::Backend::DeserializationError)
+    end
 
-  it "should try include the namespace when loading unknown structs" do
-    job = @backend.new :handler => "--- !ruby/struct:Delayed::JobThatDoesNotExist {}"
-    job.should_receive(:attempt_to_load).with('Delayed::JobThatDoesNotExist').and_return(true)
-    lambda { job.payload_object.perform }.should raise_error(Delayed::DeserializationError)
+    it "should autoload structs that are unknown at runtime" do
+      job = @backend.new :handler => "--- !ruby/struct:Autoloaded::Struct {}"
+      lambda { job.payload_object }.should_not raise_error(Delayed::Backend::DeserializationError)
+    end
   end
   
   describe "find_available" do
@@ -177,55 +165,15 @@ shared_examples_for 'a backend' do
       @job_copy_for_worker_2.lock_exclusively!(4.hours, 'worker2').should == false
     end
   end
-  
-  describe "reserve" do
-    before do
-      Delayed::Worker.max_run_time = 2.minutes
-      @worker = Delayed::Worker.new(:quiet => true)
-    end
-
-    it "should not reserve failed jobs" do
-      create_job :attempts => 50, :failed_at => described_class.db_time_now
-      described_class.reserve(@worker).should be_nil
-    end
 
-    it "should not reserve jobs scheduled for the future" do
-      create_job :run_at => (described_class.db_time_now + 1.minute)
-      described_class.reserve(@worker).should be_nil
-    end
-
-    it "should lock the job so other workers can't reserve it" do
-      job = create_job
-      described_class.reserve(@worker).should == job
-      new_worker = Delayed::Worker.new(:quiet => true)
-      new_worker.name = 'worker2'
-      described_class.reserve(new_worker).should be_nil
-    end
-
-    it "should reserve open jobs" do
-      job = create_job
-      described_class.reserve(@worker).should == job
-    end
-
-    it "should reserve expired jobs" do
-      job = create_job(:locked_by => @worker.name, :locked_at => described_class.db_time_now - 3.minutes)
-      described_class.reserve(@worker).should == job
-    end
-
-    it "should reserve own jobs" do
-      job = create_job(:locked_by => @worker.name, :locked_at => (described_class.db_time_now - 1.minutes))
-      described_class.reserve(@worker).should == job
-    end
-  end
-  
   context "#name" do
     it "should be the class name of the job that was enqueued" do
       @backend.create(:payload_object => ErrorJob.new ).name.should == 'ErrorJob'
     end
-
+    
     it "should be the method that will be called if its a performable method object" do
-      @job = Story.delay.create
-      @job.name.should == "Story.create"
+      job = @backend.new(:payload_object => NamedJob.new)
+      job.name.should == 'named_job'
     end
 
     it "should be the instance method that will be called if its a performable method object" do
@@ -304,38 +252,22 @@ shared_examples_for 'a backend' do
       @job.id.should_not be_nil
     end
   end
-  
-  context "max_attempts" do
-    before(:each) do
-      @job = described_class.enqueue SimpleJob.new
-    end
-    
-    it 'should not be defined' do
-      @job.max_attempts.should be_nil
-    end
-    
-    it 'should use the max_retries value on the payload when defined' do
-      @job.payload_object.stub!(:max_attempts).and_return(99)
-      @job.max_attempts.should == 99
-    end 
-  end
 
-  describe "worker integration" do
-    before do
-      @worker = Delayed::Worker.new(:max_priority => nil, :min_priority => nil, :quiet => true)
+  describe "yaml serialization" do
+    it "should reload changed attributes" do
+      job = @backend.enqueue SimpleJob.new
+      yaml = job.to_yaml
+      job.priority = 99
+      job.save
+      YAML.load(yaml).priority.should == 99
     end
 
-    describe "running a job" do
-
-      context "when the job raises a deserialization error" do
-        it "should mark the job as failed" do
-          Delayed::Worker.destroy_failed_jobs = false
-          job = described_class.create! :handler => "--- !ruby/object:JobThatDoesNotExist {}"
-          @worker.work_off
-          job.reload
-          job.failed_at.should_not be_nil
-        end
-      end
+    it "should ignore destroyed records" do
+      job = @backend.enqueue SimpleJob.new
+      yaml = job.to_yaml
+      job.destroy
+      lambda { YAML.load(yaml).should be_nil }.should_not raise_error
     end
   end
+
 end

data/spec/message_sending_spec.rb

@@ -22,44 +22,6 @@ describe Delayed::MessageSending do
         job.payload_object.args.should    == [1]
       }.should change { Delayed::Job.count }
     end
-
-    describe 'with options' do
-      class Fable
-        class << self
-          attr_accessor :importance
-        end
-        def tell
-        end
-        handle_asynchronously :tell, :priority => Proc.new { self.importance }
-      end
-
-      it 'should set the priority based on the Fable importance' do
-        Fable.importance = 10
-        job = Fable.new.tell
-        job.priority.should == 10
-
-        Fable.importance = 20
-        job = Fable.new.tell
-        job.priority.should == 20
-      end
-
-      describe 'using a proc with parament' do
-        class Yarn
-          attr_accessor :importance
-          def spin
-          end
-          handle_asynchronously :spin, :priority => Proc.new {|y| y.importance }
-        end
-
-        it 'should set the priority based on the Fable importance' do
-          job = Yarn.new.tap {|y| y.importance = 10 }.spin
-          job.priority.should == 10
-
-          job = Yarn.new.tap {|y| y.importance = 20 }.spin
-          job.priority.should == 20
-        end
-      end
-    end
   end
 
   context "delay" do
@@ -71,14 +33,7 @@ describe Delayed::MessageSending do
         job.payload_object.args.should    == ['l']
       }.should change { Delayed::Job.count }.by(1)
     end
-
-    it "should set default priority" do
-      Delayed::Worker.default_priority = 99
-      job = Object.delay.to_s
-      job.priority.should == 99
-      Delayed::Worker.default_priority = 0
-    end
-
+  
     it "should set job options" do
       run_at = Time.parse('2010-05-03 12:55 AM')
       job = Object.delay(:priority => 20, :run_at => run_at).to_s