resque-workers-lock 1.0.6 → 1.0.7

data/README.md

@@ -23,12 +23,12 @@ class Parser
   extend Resque::Plugins::Workers::Lock
 
 	# Lock method has the same arguments as the self.perform
-	def self.workers_lock(domain, arg2, arg3)
+	def self.lock_workers(domain, arg2, arg3)
 		return domain
 	end
 	
 	# Turn off standard resque-lock functionality
-	def self.enqueue_lock(domain, arg2, arg3)
+	def self.lock_enqueue(domain, arg2, arg3)
 		false
 	end
 

data/lib/resque/plugins/workers/lock.rb

@@ -4,12 +4,12 @@ module Resque
       module Lock
         
         # Override in your job to control the queue lock key
-        def enqueue_lock(*args)
+        def lock_enqueue(*args)
           "enqueuelock:#{name}-#{args.to_s}"
         end
         
         # Override in your job to control the workers lock key.
-        def workers_lock(*args)
+        def lock_workers(*args)
           "workerslock:#{name}-#{args.to_s}"
         end
         
@@ -18,20 +18,25 @@ module Resque
           1.0
         end
         
+        
+        # Called with the job args before a job is placed on the queue. 
+        # If the hook returns false, the job will not be placed on the queue.
         def before_enqueue_lock(*args)
-          if enqueue_lock(*args)
-            return Resque.redis.setnx(enqueue_lock(*args), true)
-          else
+          if lock_enqueue(*args) == false
             return true
+          else
+            return Resque.redis.setnx(lock_enqueue(*args).to_s, true)
           end
         end
         
+        # Called with the job args before perform. 
+        # If it raises Resque::Job::DontPerform, the job is aborted.
         def before_perform_lock(*args)
-          if workers_lock(*args)
-            nx = Resque.redis.setnx(workers_lock(*args), true)
+          if lock_workers(*args)
+            nx = Resque.redis.setnx(lock_workers(*args).to_s, true)
             if nx == false
               sleep(requeue_perform_delay)
-              Resque.redis.del(enqueue_lock(*args))
+              Resque.redis.del(lock_enqueue(*args).to_s)
               Resque.enqueue(self, *args)
               raise Resque::Job::DontPerform
             end
@@ -43,15 +48,15 @@ module Resque
             yield
           ensure
             # Clear the lock. (even with errors)
-            Resque.redis.del(workers_lock(*args))
-            Resque.redis.del(enqueue_lock(*args))
+            Resque.redis.del(lock_workers(*args).to_s)
+            Resque.redis.del(lock_enqueue(*args).to_s)
           end
         end
         
         def on_failure_lock(exception, *args)
           # Clear the lock on DirtyExit
-          Resque.redis.del(workers_lock(*args))
-          Resque.redis.del(enqueue_lock(*args))
+          Resque.redis.del(lock_workers(*args).to_s)
+          Resque.redis.del(lock_enqueue(*args).to_s)
         end
         
       end

data/test/lock_test.rb

@@ -5,19 +5,36 @@ require 'resque/plugins/workers/lock'
 $counter = 0
 
 class LockTest < Test::Unit::TestCase
-  class Job
+  class SimilarJob
     extend Resque::Plugins::Workers::Lock
     @queue = :lock_test
 
     def self.perform
-      raise "This should not have not happened"
+      raise "Woah woah! How did this happen?"
+    end
+  end
+  
+  class UniqueJob
+    extend Resque::Plugins::Workers::Lock
+    @queue = :lock_test
+    
+    #def self.lock_enqueue(id)
+    #  return id.to_s
+    #end
+    
+    def self.lock_workers(id)
+      return id.to_s
+    end
+    
+    def self.perform(id)
+      raise "Woah woah! How did this happen?"
     end
   end
 
   def setup
     Resque.redis.del('queue:lock_test')
-    Resque.redis.del(Job.workers_lock)
-    Resque.redis.del(Job.enqueue_lock)
+    Resque.redis.del(SimilarJob.lock_workers)
+    Resque.redis.del(SimilarJob.lock_enqueue)
   end
 
   def test_lint
@@ -34,9 +51,30 @@ class LockTest < Test::Unit::TestCase
   end
 
   def test_enqueue
-    3.times { Resque.enqueue(Job) }
+    3.times { Resque.enqueue(SimilarJob) }
 
+    assert_equal "workerslock:LockTest::SimilarJob-[]", SimilarJob.lock_workers
+    assert_equal "enqueuelock:LockTest::SimilarJob-[]", SimilarJob.lock_enqueue
     assert_equal 1, Resque.redis.llen('queue:lock_test')
+    
+    3.times do |i|
+      Resque.enqueue(UniqueJob, (i+100).to_s)
+      #assert_equal i.to_s, UniqueJob.lock_enqueue(i.to_s)
+      assert_equal i.to_s, UniqueJob.lock_workers(i.to_s)
+    end
+    
+    assert_equal 4, Resque.redis.llen('queue:lock_test')
+  end
+  
+  def test_zcleanup
+    Resque.redis.del(SimilarJob.lock_workers)
+    Resque.redis.del(SimilarJob.lock_enqueue)
+    
+    3.times do |i|
+      Resque.redis.del(UniqueJob.lock_enqueue((i+100).to_s))
+    end
+    Resque.redis.del('queue:lock_test')
+    assert_equal 0, Resque.redis.llen('queue:lock_test')
   end
   
   def test_lock

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: resque-workers-lock
 version: !ruby/object:Gem::Version
-  version: 1.0.6
+  version: 1.0.7
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-25 00:00:00.000000000 Z
+date: 2012-07-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: resque