resque-concurrent-restriction 0.5.0 → 0.5.1

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

@@ -2,6 +2,43 @@ module Resque
   module Plugins
     module ConcurrentRestriction
 
+      # Redis Data Structures
+      #
+      # concurrent.lock.tracking_id => timestamp
+      #   Maintains the distributed lock for the tracking_key to ensure
+      #   atomic modification of other data structures
+      #
+      # concurrent.count.tracking_id => count
+      #   The count of currently running jobs for the tracking_id
+      #
+      # concurrent.queue.queue_name.tracking_id => List[job1, job2, ...]
+      #   The queue of items that is currently unable to run due to count being exceeded
+      #
+      # concurrent.queue_availability.tracking_key => Set[queue_name1, queue_name2, ...]
+      #   Maintains the set of queues that currently have something
+      #   runnable for each tracking_id
+      #
+      # concurrent.runnable[.queue_name] => Set[tracking_id1, tracking_id2, ...]
+      #   Maintains the set of tracking_ids that have something
+      #   runnable for each queue (globally without .queue_name postfix in key)
+      #
+      # The behavior has two points of entry:
+      #
+      # When the Resque::Worker is looking for a job to run from a restriction
+      # queue, we use the queue_name to look up the set of tracking IDs that
+      # are currently runnable for that queue.  If we get a tracking id, we
+      # know that there is a restriction queue with something runnable in it,
+      # and we then use that tracking_id and queue to look up and pop something
+      # off of the restriction queue.
+      #
+      # When the Resque::Worker gets a job off of a normal resque queue, it uses
+      # the count to see if that job is currently restricted.  If not, it runs it
+      # as normal, but if it is restricted, then it sticks it on a restriction queue.
+      #
+      # In both cases, before a job is handed off to resque to be run, we increment
+      # the count so we can keep tracking of how many are currently running.  When
+      # the job finishes, we then decrement the count.
+
       # Used by the user in their job class to set the concurrency limit
       def concurrent(limit)
         @concurrent = limit
@@ -20,26 +57,26 @@ module Resque
       # The key used to acquire a lock so we can operate on multiple
       # redis structures (runnables set, running_count) atomically
       def lock_key(tracking_key)
-        parts = tracking_key.split(":")
-        "concurrent:lock:#{parts[2..-1].join(':')}"
+        parts = tracking_key.split(".")
+        "concurrent.lock.#{parts[2..-1].join('.')}"
       end
 
       # The redis key used to store the number of currently running
       # jobs for the restriction_identifier
       def running_count_key(tracking_key)
-        parts = tracking_key.split(":")
-        "concurrent:count:#{parts[2..-1].join(':')}"
+        parts = tracking_key.split(".")
+        "concurrent.count.#{parts[2..-1].join('.')}"
       end
 
       # The key for the redis list where restricted jobs for the given resque queue are stored
       def restriction_queue_key(tracking_key, queue)
-        parts = tracking_key.split(":")
-        "concurrent:queue:#{queue}:#{parts[2..-1].join(':')}"
+        parts = tracking_key.split(".")
+        "concurrent.queue.#{queue}.#{parts[2..-1].join('.')}"
       end
 
       def restriction_queue_availability_key(tracking_key)
-        parts = tracking_key.split(":")
-        "concurrent:queue_availability:#{parts[2..-1].join(':')}"
+        parts = tracking_key.split(".")
+        "concurrent.queue_availability.#{parts[2..-1].join('.')}"
       end
 
       # The key that groups all jobs of the same restriction_identifier together
@@ -48,18 +85,18 @@ module Resque
       # for those queues are stored
       def tracking_key(*args)
         id = concurrent_identifier(*args)
-        id = ":#{id}" if id && id.strip.size > 0
-        "concurrent:tracking:#{self.to_s}#{id}"
+        id = ".#{id}" if id && id.strip.size > 0
+        "concurrent.tracking.#{self.to_s}#{id}"
       end
 
       def tracking_class(tracking_key)
-        Resque.constantize(tracking_key.split(":")[2])
+        Resque.constantize(tracking_key.split(".")[2])
       end
 
       # The key to the redis set where we keep a list of runnable tracking_keys
       def runnables_key(queue=nil)
-        key = ":#{queue}" if queue
-        "concurrent:runnable#{key}"
+        key = ".#{queue}" if queue
+        "concurrent.runnable#{key}"
       end
 
       # Encodes the job intot he restriction queue
@@ -328,16 +365,44 @@ module Resque
         end
       end
 
+      # Resets everything to be runnable
+      def reset_restrictions
+
+        counts_reset = 0
+        count_keys = Resque.redis.keys("concurrent.count.*")
+        counts_reset = Resque.redis.del(*count_keys) if count_keys.size > 0
+
+        runnable_keys = Resque.redis.keys("concurrent.runnable*")
+        Resque.redis.del(*runnable_keys) if runnable_keys.size > 0
+
+        queues_enabled = 0
+        queue_keys = Resque.redis.keys("concurrent.queue.*")
+        queue_keys.each do |k|
+          if Resque.redis.llen(k) > 0
+            parts = k.split(".")
+            queue = parts[2]
+            ident = parts[3..-1].join('.')
+            tracking_key = "concurrent.tracking.#{ident}"
+            update_queues_available(tracking_key, queue, :add)
+            mark_runnable(tracking_key, true)
+            queues_enabled += 1
+          end
+        end
+
+        return counts_reset, queues_enabled
+        
+      end
+
       def stats
         results = {}
 
-        queue_keys = Resque.redis.keys("concurrent:queue:*")
+        queue_keys = Resque.redis.keys("concurrent.queue.*")
 
         queue_sizes = {}
         ident_sizes = {}
         queue_keys.each do |k|
-          parts = k.split(":")
-          ident = parts[3..-1].join(":")
+          parts = k.split(".")
+          ident = parts[3..-1].join(".")
           queue_name = parts[2]
           size = Resque.redis.llen(k)
           queue_sizes[queue_name] ||= 0
@@ -346,15 +411,15 @@ module Resque
           ident_sizes[ident] += size
         end
 
-        count_keys = Resque.redis.keys("concurrent:count:*")
+        count_keys = Resque.redis.keys("concurrent.count.*")
         running_counts = {}
         count_keys.each do |k|
-          parts = k.split(":")
-          ident = parts[2..-1].join(":")
+          parts = k.split(".")
+          ident = parts[2..-1].join(".")
           running_counts[ident] = Resque.redis.get(k).to_i
         end
 
-        lock_keys = Resque.redis.keys("concurrent:lock:*")
+        lock_keys = Resque.redis.keys("concurrent.lock.*")
         lock_count = lock_keys.size
 
         runnable_count = Resque.redis.scard(runnables_key)

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

@@ -1,7 +1,7 @@
 module Resque
   module Plugins
     module ConcurrentRestriction
-      VERSION = "0.5.0"
+      VERSION = "0.5.1"
     end
   end
 end

data/spec/concurrent_restriction_job_spec.rb

@@ -18,15 +18,17 @@ describe Resque::Plugins::ConcurrentRestriction do
 
   context "keys" do
     it "should always contain the classname in tracking_key" do
-      ConcurrentRestrictionJob.tracking_key.should == "concurrent:tracking:ConcurrentRestrictionJob"
-      IdentifiedRestrictionJob.tracking_key.should == "concurrent:tracking:IdentifiedRestrictionJob"
-      IdentifiedRestrictionJob.tracking_key(1).should == "concurrent:tracking:IdentifiedRestrictionJob:1"
+      ConcurrentRestrictionJob.tracking_key.should == "concurrent.tracking.ConcurrentRestrictionJob"
+      IdentifiedRestrictionJob.tracking_key.should == "concurrent.tracking.IdentifiedRestrictionJob"
+      IdentifiedRestrictionJob.tracking_key(1).should == "concurrent.tracking.IdentifiedRestrictionJob.1"
+      Jobs::NestedRestrictionJob.tracking_key.should == "concurrent.tracking.Jobs::NestedRestrictionJob"
     end
 
     it "should be able to get the class from tracking_key" do
       ConcurrentRestrictionJob.tracking_class(ConcurrentRestrictionJob.tracking_key).should == ConcurrentRestrictionJob
       IdentifiedRestrictionJob.tracking_class(IdentifiedRestrictionJob.tracking_key).should == IdentifiedRestrictionJob
       IdentifiedRestrictionJob.tracking_class(IdentifiedRestrictionJob.tracking_key(1)).should == IdentifiedRestrictionJob
+      Jobs::NestedRestrictionJob.tracking_class(Jobs::NestedRestrictionJob.tracking_key).should == Jobs::NestedRestrictionJob
     end
     
   end
@@ -418,6 +420,46 @@ describe Resque::Plugins::ConcurrentRestriction do
 
   end
 
+  context "#reset_restrictions" do
+    it "should do nothing when nothing is in redis" do
+      ConcurrentRestrictionJob.reset_restrictions.should == [0, 0]
+    end
+
+    it "should reset counts" do
+      ConcurrentRestrictionJob.set_running_count(ConcurrentRestrictionJob.tracking_key, 5)
+      IdentifiedRestrictionJob.set_running_count(IdentifiedRestrictionJob.tracking_key(1), 5)
+      IdentifiedRestrictionJob.set_running_count(IdentifiedRestrictionJob.tracking_key(2), 5)
+
+      ConcurrentRestrictionJob.reset_restrictions.should == [3, 0]
+      ConcurrentRestrictionJob.running_count(ConcurrentRestrictionJob.tracking_key).should == 0
+      IdentifiedRestrictionJob.running_count(IdentifiedRestrictionJob.tracking_key(1)).should == 0
+      IdentifiedRestrictionJob.running_count(IdentifiedRestrictionJob.tracking_key(2)).should == 0
+    end
+
+    it "should reset restriction queue runnable state" do
+      job1 = Resque::Job.new("queue1", {"class" => "IdentifiedRestrictionJob", "args" => [1]})
+      job2 = Resque::Job.new("queue2", {"class" => "IdentifiedRestrictionJob", "args" => [1]})
+      job3 = Resque::Job.new("queue1", {"class" => "IdentifiedRestrictionJob", "args" => [2]})
+      job4 = Resque::Job.new("queue2", {"class" => "IdentifiedRestrictionJob", "args" => [2]})
+      job5 = Resque::Job.new("queue3", {"class" => "ConcurrentRestrictionJob", "args" => []})
+
+      IdentifiedRestrictionJob.push_to_restriction_queue(job1)
+      IdentifiedRestrictionJob.push_to_restriction_queue(job2)
+      IdentifiedRestrictionJob.push_to_restriction_queue(job3)
+      IdentifiedRestrictionJob.push_to_restriction_queue(job4)
+      ConcurrentRestrictionJob.push_to_restriction_queue(job5)
+
+      ConcurrentRestrictionJob.reset_restrictions.should == [0, 5]
+      IdentifiedRestrictionJob.runnables(:queue1).sort.should == [IdentifiedRestrictionJob.tracking_key(1), IdentifiedRestrictionJob.tracking_key(2)]
+      IdentifiedRestrictionJob.runnables(:queue2).sort.should == [IdentifiedRestrictionJob.tracking_key(1), IdentifiedRestrictionJob.tracking_key(2)]
+      ConcurrentRestrictionJob.runnables(:queue3).sort.should == [ConcurrentRestrictionJob.tracking_key]
+
+      IdentifiedRestrictionJob.runnables.sort.should == [ConcurrentRestrictionJob.tracking_key, IdentifiedRestrictionJob.tracking_key(1), IdentifiedRestrictionJob.tracking_key(2)]
+
+    end
+
+  end
+
   context "#stats" do
     
     it "should have blank info when nothing going on" do
@@ -444,7 +486,7 @@ describe Resque::Plugins::ConcurrentRestriction do
 
       stats = IdentifiedRestrictionJob.stats
       stats[:queue_totals][:by_queue_name].should == {"queue1" => 2, "queue2" => 2, "queue3" => 1}
-      stats[:queue_totals][:by_identifier].should == {"IdentifiedRestrictionJob:1" => 2, "IdentifiedRestrictionJob:2" => 2, "ConcurrentRestrictionJob" => 1}
+      stats[:queue_totals][:by_identifier].should == {"IdentifiedRestrictionJob.1" => 2, "IdentifiedRestrictionJob.2" => 2, "ConcurrentRestrictionJob" => 1}
     end
 
     it "should track running_counts" do
@@ -452,7 +494,7 @@ describe Resque::Plugins::ConcurrentRestriction do
       IdentifiedRestrictionJob.set_running_count(IdentifiedRestrictionJob.tracking_key(2), 3)
       ConcurrentRestrictionJob.set_running_count(ConcurrentRestrictionJob.tracking_key, 4)
       stats = IdentifiedRestrictionJob.stats
-      stats[:running_counts].should == {"IdentifiedRestrictionJob:1" => 2, "IdentifiedRestrictionJob:2" => 3, "ConcurrentRestrictionJob" => 4}
+      stats[:running_counts].should == {"IdentifiedRestrictionJob.1" => 2, "IdentifiedRestrictionJob.2" => 3, "ConcurrentRestrictionJob" => 4}
     end
 
     it "should track lock_count" do

data/spec/spec_helper.rb

@@ -115,6 +115,15 @@ class RestrictionJob
   @queue = 'normal'
 end
 
+module Jobs
+  class NestedRestrictionJob
+    extend RunCountHelper
+    extend Resque::Plugins::ConcurrentRestriction
+    concurrent 1
+    @queue = 'normal'
+  end
+end
+
 class IdentifiedRestrictionJob
   extend RunCountHelper
   extend Resque::Plugins::ConcurrentRestriction

metadata

@@ -2,7 +2,7 @@
 name: resque-concurrent-restriction
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors: 
 - Matt Conway