delayed_job 2.1.0.pre → 2.1.0.pre2

data/lib/delayed/backend/couch_rest.rb

@@ -1,109 +0,0 @@
-require 'couchrest'
-
-#extent couchrest to handle delayed_job serialization.
-class CouchRest::ExtendedDocument
-  yaml_as "tag:ruby.yaml.org,2002:CouchRest"
-  
-  def reload
-    job = self.class.get self['_id']
-    job.each {|k,v| self[k] = v}
-  end
-  def self.find(id)
-    get id
-  end
-  def self.yaml_new(klass, tag, val)
-    klass.get(val['_id'])
-  end  
-  def ==(other)
-    if other.is_a? ::CouchRest::ExtendedDocument
-      self['_id'] == other['_id']
-    else
-      super
-    end
-  end
-end
-
-#couchrest adapter
-module Delayed
-  module Backend
-    module CouchRest
-      class Job < ::CouchRest::ExtendedDocument
-        include Delayed::Backend::Base
-        use_database ::CouchRest::Server.new.database('delayed_job')
-
-        property :handler
-        property :last_error
-        property :locked_by        
-        property :priority, :default => 0
-        property :attempts, :default => 0
-        property :run_at, :cast_as => 'Time'
-        property :locked_at, :cast_as => 'Time'
-        property :failed_at, :cast_as => 'Time'
-        timestamps!
-
-        set_callback :save, :before, :set_default_run_at
-
-        view_by(:failed_at, :locked_by, :run_at,
-                :map => "function(doc){" +
-                "          if(doc['couchrest-type'] == 'Delayed::Backend::CouchRest::Job') {" +
-                "            emit([doc.failed_at || null, doc.locked_by || null, doc.run_at || null], null);}" +
-                "        }")
-        view_by(:failed_at, :locked_at, :run_at,
-                :map => "function(doc){" +
-                "          if(doc['couchrest-type'] == 'Delayed::Backend::CouchRest::Job') {" +
-                "            emit([doc.failed_at || null, doc.locked_at || null, doc.run_at || null], null);}" +
-                "        }")        
-
-        def self.db_time_now; Time.now; end    
-        def self.find_available(worker_name, limit = 5, max_run_time = ::Delayed::Worker.max_run_time)
-          ready = ready_jobs
-          mine = my_jobs worker_name
-          expire = expired_jobs max_run_time
-          jobs = (ready + mine + expire)[0..limit-1].sort_by { |j| j.priority }
-          jobs = jobs.find_all { |j| j.priority >= Worker.min_priority } if Worker.min_priority
-          jobs = jobs.find_all { |j| j.priority <= Worker.max_priority } if Worker.max_priority
-          jobs
-        end
-        def self.clear_locks!(worker_name)
-          jobs = my_jobs worker_name
-          jobs.each { |j| j.locked_by, j.locked_at = nil, nil; }
-          database.bulk_save jobs
-        end
-        def self.delete_all
-          database.bulk_save all.each { |doc| doc['_deleted'] = true }
-        end
-        
-        def lock_exclusively!(max_run_time, worker = worker_name)
-          return false if locked_by_other?(worker) and not expired?(max_run_time)
-          case
-          when locked_by_me?(worker)
-            self.locked_at = self.class.db_time_now
-          when (unlocked? or (locked_by_other?(worker) and expired?(max_run_time)))
-            self.locked_at, self.locked_by = self.class.db_time_now, worker
-          end
-          save
-        rescue RestClient::Conflict
-          false
-        end
-        
-        private
-        def self.ready_jobs
-          options = {:startkey => [nil, nil], :endkey => [nil, nil, db_time_now]}
-          by_failed_at_and_locked_by_and_run_at options
-        end
-        def self.my_jobs(worker_name)
-          options = {:startkey => [nil, worker_name], :endkey => [nil, worker_name, {}]}
-          by_failed_at_and_locked_by_and_run_at options
-        end
-        def self.expired_jobs(max_run_time)
-          options = {:startkey => [nil,'0'], :endkey => [nil, db_time_now - max_run_time, db_time_now]}
-          by_failed_at_and_locked_at_and_run_at options
-        end
-        def unlocked?; locked_by.nil?; end
-        def expired?(time); locked_at < self.class.db_time_now - time; end
-        def locked_by_me?(worker); not locked_by.nil? and locked_by == worker; end        
-        def locked_by_other?(worker); not locked_by.nil? and locked_by != worker; end
-      end
-    end
-  end
-end

data/lib/delayed/backend/data_mapper.rb

@@ -1,121 +0,0 @@
-require 'dm-core'
-require 'dm-observer'
-require 'dm-aggregates'
-
-DataMapper::Resource.class_eval do
-  yaml_as "tag:ruby.yaml.org,2002:DataMapper"
-
-  def self.yaml_new(klass, tag, val)
-    klass.find(val['id'])
-  end
-
-  def to_yaml_properties
-    ['@id']
-  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, :index => :run_at_priority
-        property :attempts,    Integer, :default => 0
-        property :handler,     Text, :lazy => false
-        property :run_at,      Time, :index => :run_at_priority
-        property :locked_at,   Time, :index => true
-        property :locked_by,   String
-        property :failed_at,   Time
-        property :last_error,  Text
-                
-        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/lib/delayed/backend/mongo_mapper.rb

@@ -1,106 +0,0 @@
-require 'mongo_mapper'
-
-MongoMapper::Document.class_eval do
-  yaml_as "tag:ruby.yaml.org,2002:MongoMapper"
-  
-  def self.yaml_new(klass, tag, val)
-    klass.find(val['_id'])
-  end
-
-  def to_yaml_properties
-    ['@_id']
-  end
-end
-
-module Delayed
-  module Backend
-    module MongoMapper
-      class Job
-        include ::MongoMapper::Document
-        include Delayed::Backend::Base
-        set_collection_name 'delayed_jobs'
-        
-        key :priority,    Integer, :default => 0
-        key :attempts,    Integer, :default => 0
-        key :handler,     String
-        key :run_at,      Time
-        key :locked_at,   Time
-        key :locked_by,   String, :index => true
-        key :failed_at,   Time
-        key :last_error,  String
-        timestamps!
-        
-        before_save :set_default_run_at
-
-        ensure_index [[:priority, 1], [:run_at, 1]]
-        
-        def self.before_fork
-          ::MongoMapper.connection.close
-        end
-        
-        def self.after_fork
-          ::MongoMapper.connect(RAILS_ENV)
-        end
-        
-        def self.db_time_now
-          Time.now.utc
-        end
-        
-        def self.find_available(worker_name, limit = 5, max_run_time = Worker.max_run_time)
-          right_now = db_time_now
-
-          conditions = {
-            :run_at => {"$lte" => right_now},
-            :limit => -limit, # In mongo, positive limits are 'soft' and negative are 'hard'
-            :failed_at => nil,
-            :sort => [['priority', 1], ['run_at', 1]]
-          }
-
-          where = "this.locked_at == null || this.locked_at < #{make_date(right_now - max_run_time)}"
-          
-          (conditions[:priority] ||= {})['$gte'] = Worker.min_priority.to_i if Worker.min_priority
-          (conditions[:priority] ||= {})['$lte'] = Worker.max_priority.to_i if Worker.max_priority
-
-          results = all(conditions.merge(:locked_by => worker_name))
-          results += all(conditions.merge('$where' => where)) if results.size < limit
-          results
-        end
-        
-        # When a worker is exiting, make sure we don't have any locked jobs.
-        def self.clear_locks!(worker_name)
-          collection.update({:locked_by => worker_name}, {"$set" => {:locked_at => nil, :locked_by => nil}}, :multi => true)
-        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)
-          right_now = self.class.db_time_now
-          overtime = right_now - max_run_time.to_i
-          
-          query = "this.locked_at == null || this.locked_at < #{make_date(overtime)} || this.locked_by == #{worker.to_json}"
-          conditions = {:_id => id, :run_at => {"$lte" => right_now}, "$where" => query}
-
-          collection.update(conditions, {"$set" => {:locked_at => right_now, :locked_by => worker}})
-          affected_rows = collection.find({:_id => id, :locked_by => worker}).count
-          if affected_rows == 1
-            self.locked_at = right_now
-            self.locked_by = worker
-            return true
-          else
-            return false
-          end
-        end
-        
-      private
-      
-        def self.make_date(date_or_seconds)
-          "new Date(#{date_or_seconds.to_f * 1000})"
-        end
-
-        def make_date(date)
-          self.class.make_date(date)
-        end
-      end
-    end
-  end
-end

data/spec/backend/couch_rest_job_spec.rb

@@ -1,15 +0,0 @@
-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/data_mapper_job_spec.rb

@@ -1,16 +0,0 @@
-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,94 +0,0 @@
-require 'spec_helper'
-require 'backend/shared_backend_spec'
-require 'delayed/backend/mongo_mapper'
-
-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
-    it "should have combo index on priority and run_at" do
-      @backend.collection.index_information.detect { |index| index[0] == 'priority_1_run_at_1' }.should_not be_nil
-    end
-
-    it "should have index on locked_by" 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
-      story.destroy
-      lambda { job.invoke_job }.should_not raise_error
-    end
-
-    it "should store the object as string" do
-      story = MongoStory.create :text => 'Once upon a time...'
-      job = story.delay.tell
-
-      job.payload_object.class.should   == Delayed::PerformableMethod
-      job.payload_object.object.should  == story
-      job.payload_object.method.should  == :tell
-      job.payload_object.args.should    == []
-      job.payload_object.perform.should == 'Once upon a time...'
-    end
-
-    it "should store arguments as string" do
-      story = MongoStory.create :text => 'Once upon a time...'
-      job = MongoStoryReader.new.delay.read(story)
-      job.payload_object.class.should   == Delayed::PerformableMethod
-      job.payload_object.method.should  == :read
-      job.payload_object.args.should    == [story]
-      job.payload_object.perform.should == 'Epilog: Once upon a time...'
-    end
-  end
-  
-  describe "before_fork" do
-    after do
-      MongoMapper.connection.connect_to_master
-    end
-    
-    it "should disconnect" do
-      lambda do
-        Delayed::Backend::MongoMapper::Job.before_fork
-      end.should change { !!MongoMapper.connection.connected? }.from(true).to(false)
-    end
-  end
-
-  describe "after_fork" 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