topprospect-delayed_job 2.0.6 → 2.0.7

data/lib/delayed/backend/active_record.rb

@@ -25,6 +25,8 @@ module Delayed
         
         before_save :set_default_run_at
 
+
+        # TODO Rails 3 scope is not queue-aware as the mainstream delayed_job does it
         if ::ActiveRecord::VERSION::MAJOR >= 3
           scope :ready_to_run, lambda {|worker_name, max_run_time|
             where(['(run_at <= ? AND (locked_at IS NULL OR locked_at < ?) OR locked_by = ?) AND failed_at IS NULL', db_time_now, db_time_now - max_run_time, worker_name])
@@ -32,7 +34,16 @@ module Delayed
           scope :by_priority, order('priority ASC, run_at ASC')
         else
           named_scope :ready_to_run, lambda {|worker_name, max_run_time|
-            {:conditions => ['queue = ? AND (run_at <= ? AND (locked_at IS NULL OR locked_at < ?) OR locked_by = ?) AND failed_at IS NULL', Worker.queue, db_time_now, db_time_now - max_run_time, worker_name]}
+
+            if Worker.queue == Delayed::ALL_QUEUES
+              conditions = ['(run_at <= ? AND (locked_at IS NULL OR locked_at < ?) OR locked_by = ?) AND failed_at IS NULL',
+                            db_time_now, db_time_now - max_run_time, worker_name]
+            else
+              conditions = ['queue = ? AND (run_at <= ? AND (locked_at IS NULL OR locked_at < ?) OR locked_by = ?) AND failed_at IS NULL',
+                            Worker.queue, db_time_now, db_time_now - max_run_time, worker_name]
+            end
+
+            {:conditions => conditions}
           }
           named_scope :by_priority, :order => 'priority ASC, run_at ASC'
         end

data/lib/delayed/worker.rb

@@ -5,6 +5,7 @@ require 'active_support/core_ext/kernel'
 
 module Delayed
   DEFAULT_QUEUE = ''
+  ALL_QUEUES    = 'ALL'
 
   class Worker
     cattr_accessor :min_priority, :max_priority, :max_attempts, :max_run_time, :default_priority, :sleep_delay, :logger, :queue
@@ -32,6 +33,7 @@ module Delayed
 
     # rename the default Rails logger file, if requested
     # TODO should we put it inside a Rails own class/module?
+    # TODO flush in any case, even if not renaming?
     #
     # http://stackoverflow.com/questions/3500200/getting-delayed-job-to-log
     # https://gist.github.com/833828

data/spec/backend/active_record_job_spec.rb

@@ -16,8 +16,7 @@ describe Delayed::Backend::ActiveRecord::Job do
     Time.zone = nil
   end
   
-  it_should_behave_like 'a backend'
-    [Delayed::DEFAULT_QUEUE, "foo"].each do |queue|
+  [Delayed::DEFAULT_QUEUE, Delayed::ALL_QUEUES, "foo"].each do |queue|
     context "when given a queue of #{queue}" do
       before do
         Delayed::Worker.queue = queue
@@ -26,6 +25,46 @@ describe Delayed::Backend::ActiveRecord::Job do
     end
   end
 
+  context "named queues" do
+    def create_job(opts = {})
+      @backend.create({:payload_object => SimpleJob.new, :queue => Delayed::Worker.queue}.merge(opts))
+    end
+
+    context "when worker has one queue set" do
+      before(:each) do
+        @worker = Delayed::Worker.new(:queue => "large")
+      end
+
+      it "should only work off jobs which are from its queue" do
+        SimpleJob.runs.should == 0
+
+        create_job(:queue => "large")
+        create_job(:queue => "small")
+        @worker.work_off
+
+        SimpleJob.runs.should == 1
+      end
+    end
+
+    context "when worker has all queues set" do
+      before(:each) do
+        @worker = Delayed::Worker.new(:queue => Delayed::ALL_QUEUES)
+      end
+
+      it "should work off all jobs for ALL queue designator" do
+        SimpleJob.runs.should == 0
+
+        create_job(:queue => "large")
+        create_job(:queue => "small")
+        create_job(:queue => "medium")
+        create_job(:queue => Delayed::DEFAULT_QUEUE)
+        @worker.work_off
+
+        SimpleJob.runs.should == 4
+      end
+    end
+  end
+
   context "db_time_now" do
     it "should return time in current time zone if set" do
       Time.zone = 'Eastern Time (US & Canada)'

data/spec/backend/shared_backend_spec.rb

@@ -6,7 +6,7 @@ end
 
 shared_examples_for 'a backend' do
   def create_job(opts = {})
-    @backend.create(opts.merge(:payload_object => SimpleJob.new, :queue => Delayed::Worker.queue))
+    @backend.create({:payload_object => SimpleJob.new, :queue => Delayed::Worker.queue}.merge(opts))
   end
 
   before do
@@ -18,7 +18,7 @@ shared_examples_for 'a backend' do
   end
   
   it "should set run_at automatically if not set" do
-    @backend.create(:payload_object => ErrorJob.new ).run_at.should_not be_nil
+    @backend.create(:payload_object => ErrorJob.new).run_at.should_not be_nil
   end
 
   it "should not set run_at automatically if already set" do

metadata

@@ -1,23 +1,25 @@
 --- !ruby/object:Gem::Specification 
 name: topprospect-delayed_job
 version: !ruby/object:Gem::Version 
-  hash: 3
+  hash: 1
   prerelease: 
   segments: 
   - 2
   - 0
-  - 6
-  version: 2.0.6
+  - 7
+  version: 2.0.7
 platform: ruby
 authors: 
 - Chris Gaffney
 - Brandon Keepers
 - "Tobias L\xC3\xBCtke"
+- Sujoy Gupta
+- Alexy Khrabrov
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2011-07-26 00:00:00 -07:00
+date: 2011-09-01 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -190,9 +192,10 @@ dependencies:
   type: :development
   version_requirements: *id012
 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).
+  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 isa topprospect fork (http://github.com/topprospect/delayed_job)
+  of the  collectiveidea's fork (http://github.com/collectiveidea/delayed_job).
 email: 
 - chris@collectiveidea.com
 - brandon@opensoul.org
@@ -206,7 +209,6 @@ files:
 - contrib/delayed_job.monitrc
 - contrib/delayed_job_multiple.monitrc
 - lib/delayed/backend/active_record.rb
-- lib/delayed/backend/active_record.rb.orig
 - lib/delayed/backend/base.rb
 - lib/delayed/backend/couch_rest.rb
 - lib/delayed/backend/data_mapper.rb
@@ -276,10 +278,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.5.2
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
-summary: Database-backed asynchronous priority queue system -- Extracted from Shopify.  TopProspect improvements include named queues, bundler, and more
+summary: Database-backed asynchronous priority queue system -- Extracted from Shopify
 test_files: 
 - spec/autoloaded/clazz.rb
 - spec/autoloaded/struct.rb

data/lib/delayed/backend/active_record.rb.orig

@@ -1,105 +0,0 @@
-require 'active_record'
-
-class ActiveRecord::Base
-  yaml_as "tag:ruby.yaml.org,2002:ActiveRecord"
-  
-  def self.yaml_new(klass, tag, val)
-    klass.find(val['attributes']['id'])
-  rescue ActiveRecord::RecordNotFound
-    nil
-  end
-
-  def to_yaml_properties
-    ['@attributes']
-  end
-end
-
-module Delayed
-  module Backend
-    module ActiveRecord
-      # A job object that is persisted to the database.
-      # Contains the work object as a YAML field.
-      class Job < ::ActiveRecord::Base
-        include Delayed::Backend::Base
-        set_table_name :delayed_jobs
-        
-        before_save :set_default_run_at
-
-<<<<<<< HEAD
-        if ::ActiveRecord::VERSION::MAJOR >= 3
-          scope :ready_to_run, lambda {|worker_name, max_run_time|
-            where(['(run_at <= ? AND (locked_at IS NULL OR locked_at < ?) OR locked_by = ?) AND failed_at IS NULL', db_time_now, db_time_now - max_run_time, worker_name])
-          }
-          scope :by_priority, order('priority ASC, run_at ASC')
-        else
-          named_scope :ready_to_run, lambda {|worker_name, max_run_time|
-            {:conditions => ['queue = ? AND (run_at <= ? AND (locked_at IS NULL OR locked_at < ?) OR locked_by = ?) AND failed_at IS NULL', Worker.queue, db_time_now, db_time_now - max_run_time, worker_name]}
-          }
-          named_scope :by_priority, :order => 'priority ASC, run_at ASC'
-        end
-
-=======
-        named_scope :ready_to_run, lambda {|worker_name, max_run_time|
-          {:conditions => ['queue = ? AND (run_at <= ? AND (locked_at IS NULL OR locked_at < ?) OR locked_by = ?) AND failed_at IS NULL', Worker.queue, db_time_now, db_time_now - max_run_time, worker_name]}
-        }
-        named_scope :by_priority, :order => 'priority ASC, run_at ASC'
-        
->>>>>>> 75b6e0c... added queues from the original topprospect patch, added tests for queues
-        def self.after_fork
-          ::ActiveRecord::Base.connection.reconnect!
-        end
-
-        # When a worker is exiting, make sure we don't have any locked jobs.
-        def self.clear_locks!(worker_name)
-          update_all("locked_by = null, locked_at = null", ["locked_by = ?", worker_name])
-        end
-
-        # Find a few candidate jobs to run (in case some immediately get locked by others).
-        def self.find_available(worker_name, limit = 5, max_run_time = Worker.max_run_time)
-          scope = self.ready_to_run(worker_name, max_run_time)
-          scope = scope.scoped(:conditions => ['priority >= ?', Worker.min_priority]) if Worker.min_priority
-          scope = scope.scoped(:conditions => ['priority <= ?', Worker.max_priority]) if Worker.max_priority
-      
-          ::ActiveRecord::Base.silence do
-            scope.by_priority.all(:limit => limit)
-          end
-        end
-
-        # Lock this job for this worker.
-        # Returns true if we have the lock, false otherwise.
-        def lock_exclusively!(max_run_time, worker)
-          now = self.class.db_time_now
-          affected_rows = if locked_by != worker
-            # We don't own this job so we will update the locked_by name and the locked_at
-            self.class.update_all(["locked_at = ?, locked_by = ?", now, worker], ["id = ? and (locked_at is null or locked_at < ?) and (run_at <= ?)", id, (now - max_run_time.to_i), now])
-          else
-            # We already own this job, this may happen if the job queue crashes.
-            # Simply resume and update the locked_at
-            self.class.update_all(["locked_at = ?", now], ["id = ? and locked_by = ?", id, worker])
-          end
-          if affected_rows == 1
-            self.locked_at    = now
-            self.locked_by    = worker
-            return true
-          else
-            return false
-          end
-        end
-
-        # Get the current time (GMT or local depending on DB)
-        # Note: This does not ping the DB to get the time, so all your clients
-        # must have syncronized clocks.
-        def self.db_time_now
-          if Time.zone
-            Time.zone.now
-          elsif ::ActiveRecord::Base.default_timezone == :utc
-            Time.now.utc
-          else
-            Time.now
-          end
-        end
-
-      end
-    end
-  end
-end