resque-concurrent-restriction 0.5.7 → 0.5.8

data/CHANGELOG

@@ -0,0 +1,5 @@
+0.5.8 (06/07/2012)
+------------------
+
+cut up keys and runnables into slices to prevent stack level too deep exceptions when deleting from redis <faecea7>
+

data/README.md

@@ -5,6 +5,8 @@ Resque Concurrent Restriction is a plugin for the [Resque][0] queueing system (h
 
 Resque Concurrent Restriction requires Resque 1.10 and redis 2.2
 
+[![Build Status](https://secure.travis-ci.org/wr0ngway/resque-concurrent-restriction.png)](http://travis-ci.org/wr0ngway/resque-concurrent-restriction)
+
 Install
 -------
 
@@ -15,18 +17,31 @@ To use
 
 It is especially useful when a system has intensive jobs for which you should only run a few at a time.  What you should do for the IntensiveJob is to make it extend Resque::Plugins::ConcurrentRestriction and specify the concurrent limit (defaults to 1). For example:
 
-	class IntensiveJob
-	  extend Resque::Plugins::ConcurrentRestriction
-	  concurrent 4
-
-	  #rest of your class here
-	end
+    class IntensiveJob
+      extend Resque::Plugins::ConcurrentRestriction
+      concurrent 4
+    
+      #rest of your class here
+    end
 
 That means the IntensiveJob can not have more than 4 jobs running simultaneously
 
+One can also make the concurrency limit depend on the parameters of a job, for example, if you always pass a user_id as the first param, you can restrict the job to run N concurrent jobs per user:
+
+    class IntensiveJob
+      extend Resque::Plugins::ConcurrentRestriction
+      concurrent 4
+
+      def self.concurrent_identifier(*args)
+        args.first.to_s
+      end
+    
+      #rest of your class here
+    end
+
 Author
 ------
-Code was originally forkd from the [resque-restriction][1] plugin (Richard Huang :: flyerhzm@gmail.com :: @flyerhzm), but diverged enough that it warranted being its own plugin to keep the code simple.
+Code was originally forked from the [resque-restriction][1] plugin (Richard Huang :: flyerhzm@gmail.com :: @flyerhzm), but diverged enough that it warranted being its own plugin to keep the code simple.
 
 Matt Conway :: matt@conwaysplace.com :: @mattconway
 

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

@@ -442,10 +442,18 @@ module Resque
 
         counts_reset = 0
         count_keys = Resque.redis.keys("concurrent.count.*")
-        counts_reset = Resque.redis.del(*count_keys) if count_keys.size > 0
+        if count_keys.size > 0
+          count_keys.each_slice(100000) do |key_slice|
+            counts_reset += Resque.redis.del(*key_slice)
+          end
+        end
 
         runnable_keys = Resque.redis.keys("concurrent.runnable*")
-        Resque.redis.del(*runnable_keys) if runnable_keys.size > 0
+        if runnable_keys.size > 0
+          runnable_keys.each_slice(100000) do |runnable_slice|
+            Resque.redis.del(*runnable_slice)
+          end
+        end
 
         Resque.redis.del(queue_count_key)
         queues_enabled = 0

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

@@ -1,7 +1,7 @@
 module Resque
   module Plugins
     module ConcurrentRestriction
-      VERSION = "0.5.7"
+      VERSION = "0.5.8"
     end
   end
 end

data/spec/concurrent_restriction_job_spec.rb

@@ -586,6 +586,28 @@ describe Resque::Plugins::ConcurrentRestriction do
 
     end
 
+    it "should handle a large amount of concurrent keys" do
+      # the ruby splat operator will choke on an arguments list greater than a couple hundred thousand objects.  make sure this case is handled correctly
+      # It might be better to actually populate redis with a bunch keys but that makes the test pretty slow
+
+      # we have to keep this splat limitation in mind when populating test data, too
+      concurrent_count_keys = 200001.times.collect{ |i| ["concurrent.count.#{i}", "#{i}"] }.flatten
+      concurrent_count_keys.each_slice(100000) do |slice|
+        Resque.redis.mset *slice
+      end
+
+      concurrent_runnable_keys = 200001.times.collect{ |i| ["concurrent.runnable.#{i}", "#{i}"] }.flatten
+      concurrent_runnable_keys.each_slice(100000) do |slice|
+        Resque.redis.mset *slice
+      end
+
+      return_value = nil
+
+      lambda{ return_value = ConcurrentRestrictionJob.reset_restrictions }.should_not raise_exception
+
+      return_value.should == [200001, 0]
+    end
+
   end
 
   context "#stats" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: resque-concurrent-restriction
 version: !ruby/object:Gem::Version
-  version: 0.5.7
+  version: 0.5.8
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-24 00:00:00.000000000 Z
+date: 2012-06-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: resque
@@ -100,6 +100,7 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .travis.yml
+- CHANGELOG
 - Gemfile
 - LICENSE
 - README.md