resque-concurrent-restriction 0.5.2 → 0.5.4

data/lib/resque/plugins/concurrent_restriction/concurrent_restriction_job.rb

@@ -1,7 +1,32 @@
+# To configure resque concurrent restriction, add something like the
+# following to an initializer (defaults shown):
+#
+#    Resque::Plugins::ConcurrentRestriction.configure do |config|
+#      # The lock timeout for the restriction queue lock
+#      config.lock_timeout = 60
+#      # Try to pick jobs off of the restricted queue before normal queues
+#      config.restricted_before_queued = true
+#    end
+
 module Resque
   module Plugins
     module ConcurrentRestriction
 
+      # Allows configuring via class accessors
+      class << self
+        # optional
+        attr_accessor :lock_timeout, :restricted_before_queued
+      end
+
+      # default values
+      self.lock_timeout = 60
+      self.restricted_before_queued = false
+
+      # Allows configuring via class accessors
+      def self.configure
+        yield self
+      end
+
       # Redis Data Structures
       #
       # concurrent.lock.tracking_id => timestamp
@@ -317,7 +342,7 @@ module Resque
         exp_backoff = 1
 
         while trying do
-          lock_expiration = Time.now.to_i + 10
+          lock_expiration = Time.now.to_i + ConcurrentRestriction.lock_timeout
           if acquire_lock(lock_key, lock_expiration)
             begin
               yield

data/lib/resque/plugins/concurrent_restriction/resque_worker_extension.rb

@@ -14,7 +14,7 @@ module Resque
            end
          end
 
-        # Wrap reserve so we can pass the job to done_working to release restriction if neccessary
+        # Wrap reserve so we can pass the job to done_working to release restriction if necessary
         def reserve_with_restriction
           @job_in_progress = reserve_without_restriction
           return @job_in_progress
@@ -47,6 +47,26 @@ module Resque
         # Wrap reserve so we can move a job to restriction queue if it is restricted
         # This needs to be a class method
         def reserve_with_restriction(queue)
+          order = [:get_queued_job, :get_restricted_job]
+          order.reverse! if ConcurrentRestriction.restricted_before_queued
+
+          resque_job = nil
+          order.each do |m|
+            resque_job ||= self.send(m, queue)
+          end
+
+          # Return job or nil to move on to next queue if we couldn't get a job
+          return resque_job
+        end
+
+        def get_restricted_job(queue)
+          # Try to find a runnable job from restriction queues
+          # This also acquires a restriction lock, which is released in done_working
+          resque_job = ConcurrentRestrictionJob.next_runnable_job(queue)
+          return resque_job
+        end
+
+        def get_queued_job(queue)
           resque_job = reserve_without_restriction(queue)
 
           if resque_job
@@ -60,21 +80,10 @@ module Resque
               # Move on to next if job is restricted
               # If job is runnable, we keep the lock until done_working
               resque_job = nil if job_class.stash_if_restricted(resque_job)
-
             end
-            
-          else
-            # if no queues have a runnable job, then try to find a
-            # runnable job from restriction queues
-            # This also acquires a restriction lock, which is released in done_working
-            resque_job = ConcurrentRestrictionJob.next_runnable_job(queue)
-
-            return resque_job
           end
 
-          # Return job or nil to move on to next queue if we couldn't get a job
           return resque_job
-
         end
 
       end

data/lib/resque/plugins/concurrent_restriction/version.rb

@@ -1,7 +1,7 @@
 module Resque
   module Plugins
     module ConcurrentRestriction
-      VERSION = "0.5.2"
+      VERSION = "0.5.4"
     end
   end
 end

data/spec/concurrent_restriction_job_spec.rb

@@ -9,12 +9,36 @@ describe Resque::Plugins::ConcurrentRestriction do
 
   after(:each) do
     Resque.redis.lrange("failed", 0, -1).size.should == 0
+    Resque.redis.get("stat:failed").to_i.should == 0
   end
 
   it "should follow the convention" do
     Resque::Plugin.lint(Resque::Plugins::ConcurrentRestrictionJob)
   end
 
+  context "settings" do
+
+    it "should allow setting/getting global config for lock_timeout" do
+      Resque::Plugins::ConcurrentRestriction.lock_timeout.should == 60
+      Resque::Plugins::ConcurrentRestriction.configure do |config|
+        config.lock_timeout = 61
+      end
+      Resque::Plugins::ConcurrentRestriction.lock_timeout.should == 61
+      Resque::Plugins::ConcurrentRestriction.lock_timeout = 60
+      Resque::Plugins::ConcurrentRestriction.lock_timeout.should == 60
+    end
+
+    it "should allow setting/getting global config for restricted_before_queued" do
+      Resque::Plugins::ConcurrentRestriction.restricted_before_queued.should == false
+      Resque::Plugins::ConcurrentRestriction.configure do |config|
+        config.restricted_before_queued = true
+      end
+      Resque::Plugins::ConcurrentRestriction.restricted_before_queued.should == true
+      Resque::Plugins::ConcurrentRestriction.restricted_before_queued = false
+      Resque::Plugins::ConcurrentRestriction.restricted_before_queued.should == false
+    end
+
+  end
 
   context "keys" do
     it "should always contain the classname in tracking_key" do
@@ -180,7 +204,6 @@ describe Resque::Plugins::ConcurrentRestriction do
       ConcurrentRestrictionJob.restricted?(ConcurrentRestrictionJob.tracking_key).should == false
       ConcurrentRestrictionJob.set_running_count(ConcurrentRestrictionJob.tracking_key, 1)
       ConcurrentRestrictionJob.restricted?(ConcurrentRestrictionJob.tracking_key).should == true
-
     end
 
   end

data/spec/resque_worker_extensions_spec.rb

@@ -9,6 +9,7 @@ describe Resque::Plugins::ConcurrentRestriction::Worker do
 
   after(:each) do
     Resque.redis.lrange("failed", 0, -1).size.should == 0
+    Resque.redis.get("stat:failed").to_i.should == 0
   end
 
   it "should do nothing for no jobs" do
@@ -58,6 +59,8 @@ describe Resque::Plugins::ConcurrentRestriction::Worker do
   end
 
   it "should prefer running a normal job over one on restriction queue" do
+    Resque::Plugins::ConcurrentRestriction.restricted_before_queued.should == false
+    
     RestrictionJob.set_running_count(RestrictionJob.tracking_key, 99)
 
     run_resque_job(RestrictionJob, :queue => :normal)
@@ -74,6 +77,32 @@ describe Resque::Plugins::ConcurrentRestriction::Worker do
     RestrictionJob.restriction_queue(RestrictionJob.tracking_key, :normal).should == []
     NoRestrictionJob.run_count.should == 1
     RestrictionJob.run_count.should == 1
+
+  end
+
+  it "should prefer running a restricted job over normal one when option given" do
+    begin
+      Resque::Plugins::ConcurrentRestriction.restricted_before_queued = true
+
+      RestrictionJob.set_running_count(RestrictionJob.tracking_key, 99)
+
+      run_resque_job(RestrictionJob, :queue => :normal)
+      RestrictionJob.run_count.should == 0
+
+      RestrictionJob.set_running_count(RestrictionJob.tracking_key, 0)
+      
+      run_resque_job(NoRestrictionJob, :queue => :normal)
+      RestrictionJob.restriction_queue(RestrictionJob.tracking_key, :normal).should == []
+      NoRestrictionJob.run_count.should == 0
+      RestrictionJob.run_count.should == 1
+
+      run_resque_queue(:normal)
+      RestrictionJob.restriction_queue(RestrictionJob.tracking_key, :normal).should == []
+      NoRestrictionJob.run_count.should == 1
+      RestrictionJob.run_count.should == 1
+    ensure
+      Resque::Plugins::ConcurrentRestriction.restricted_before_queued = false
+    end
   end
 
   it "should be able to run multiple restricted jobs in a row without exceeding restriction" do
@@ -154,6 +183,7 @@ describe Resque::Plugins::ConcurrentRestriction::Worker do
     Resque.redis.lrange("failed", 0, -1).size.should == 1
     ConcurrentRestrictionJob.running_count(ConcurrentRestrictionJob.tracking_key).should == 0
     Resque.redis.del("failed")
+    Resque.redis.del("stat:failed")
   end
 
   it "should handle jobs with custom restriction identifier" do

metadata

@@ -1,61 +1,57 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: resque-concurrent-restriction
-version: !ruby/object:Gem::Version 
+version: !ruby/object:Gem::Version
+  version: 0.5.4
   prerelease: 
-  version: 0.5.2
 platform: ruby
-authors: 
+authors:
 - Matt Conway
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-04-11 00:00:00 -04:00
+date: 2011-08-26 00:00:00.000000000 -04:00
 default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+dependencies:
+- !ruby/object:Gem::Dependency
   name: resque
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &2168987840 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        version: "1.10"
+      - !ruby/object:Gem::Version
+        version: '1.10'
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: rspec
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: *2168987840
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2168987340 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        version: "2.5"
+      - !ruby/object:Gem::Version
+        version: '2.5'
   type: :development
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: awesome_print
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  version_requirements: *2168987340
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: &2168986960 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id003
+  prerelease: false
+  version_requirements: *2168986960
 description: A resque plugin for limiting how many of a specific job can run concurrently
-email: 
+email:
 - matt@conwaysplace.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - .gitignore
 - Gemfile
 - LICENSE
@@ -74,32 +70,29 @@ files:
 has_rdoc: true
 homepage: http://github.com/wr0ngway/resque-concurrent-restriction
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: resque-concurrent-restriction
-rubygems_version: 1.6.1
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: A resque plugin for limiting how many of a specific job can run concurrently
-test_files: 
+test_files:
 - spec/concurrent_restriction_job_spec.rb
 - spec/redis-test.conf
 - spec/resque_worker_extensions_spec.rb