resque-lock-timeout 0.3.0 → 0.3.1

data/HISTORY.md

@@ -1,3 +1,8 @@
+## 0.3.1 (2011-07-16)
+
+* Pass job arguments to `lock_timeout`. (Bob Potter)
+* Added `refresh_lock!` method for long running jobs. (Bob Potter)
+
 ## 0.3.0 (2011-07-16)
 
 * Ability to customize redis connection used for storing locks.

data/README.md

@@ -1,7 +1,7 @@
 Resque Lock Timeout
 ===================
 
-A [Resque][rq] plugin. Requires Resque 1.8.0.
+A [Resque][rq] plugin. Requires Resque >= 01.8.0.
 
 resque-lock-timeout adds locking, with optional timeout/deadlock handling to
 resque jobs.
@@ -110,6 +110,30 @@ change this you may override `lock_redis`.
       end
     end
 
+### Setting Timeout At Runtime
+
+You may define the `lock_timeout` method to adjust the timeout at runtime
+using job arguments. e.g.
+
+    class UpdateNetworkGraph
+      extend Resque::Plugins::LockTimeout
+      @queue = :network_graph
+
+      def self.lock_timeout(repo_id, timeout_minutes)
+        60 * timeout_minutes
+      end
+
+      def self.perform(repo_id, timeout_minutes = 1)
+        heavy_lifting
+      end
+    end
+
+### Helper Methods
+
+* `locked?` - checks if the lock is currently held.
+* `refresh_lock!` - Refresh the lock, useful for jobs that are taking longer
+    then usual but your okay with them holding on to the lock a little longer.
+
 ### Callbacks
 
 Several callbacks are available to override and implement your own logic, e.g.

data/Rakefile

@@ -14,7 +14,7 @@ desc 'Build Yardoc documentation.'
 YARD::Rake::YardocTask.new :yardoc do |t|
     t.files   = ['lib/**/*.rb']
     t.options = ['--output-dir', "doc/",
-                 '--files', 'LICENSE',
+                 '--files', 'LICENSE,HISTORY.md',
                  '--readme', 'README.md',
                  '--title', 'resque-lock-timeout documentation']
 end

data/lib/resque/plugins/lock_timeout.rb

@@ -59,6 +59,7 @@ module Resque
       # The default looks like this:
       # `resque-lock-timeout:<class name>:<identifier>`
       #
+      # @param [Array] args job arguments
       # @return [String] redis key
       def redis_lock_key(*args)
         ['lock', name, identifier(*args)].compact.join(":")
@@ -67,8 +68,9 @@ module Resque
       # Number of seconds the lock may be held for.
       # A value of 0 or below will lock without a timeout.
       #
+      # @param [Array] args job arguments
       # @return [Fixnum]
-      def lock_timeout
+      def lock_timeout(*args)
         @lock_timeout ||= 0
       end
 
@@ -105,12 +107,12 @@ module Resque
         acquired = false
         lock_key = redis_lock_key(*args)
 
-        unless lock_timeout > 0
+        unless lock_timeout(*args) > 0
           # Acquire without using a timeout.
           acquired = true if lock_redis.setnx(lock_key, true)
         else
           # Acquire using the timeout algorithm.
-          acquired, lock_until = acquire_lock_algorithm!(lock_key)
+          acquired, lock_until = acquire_lock_algorithm!(lock_key, *args)
         end
 
         lock_failed(*args) if !acquired
@@ -120,9 +122,12 @@ module Resque
       # Attempts to aquire the lock using a timeout / deadlock algorithm.
       #
       # Locking algorithm: http://code.google.com/p/redis/wiki/SetnxCommand
-      def acquire_lock_algorithm!(lock_key)
+      #
+      # @param [String] lock_key redis lock key
+      # @param [Array] args job arguments
+      def acquire_lock_algorithm!(lock_key, *args)
         now = Time.now.to_i
-        lock_until = now + lock_timeout
+        lock_until = now + lock_timeout(*args)
         acquired = false
 
         return [true, lock_until] if lock_redis.setnx(lock_key, lock_until)
@@ -143,11 +148,24 @@ module Resque
       end
 
       # Release the lock.
+      #
+      # @param [Array] args job arguments
       def release_lock!(*args)
         lock_redis.del(redis_lock_key(*args))
       end
 
+      # Refresh the lock.
+      #
+      # @param [Array] args job arguments
+      def refresh_lock!(*args)
+        now = Time.now.to_i
+        lock_until = now + lock_timeout(*args)
+        lock_redis.set(redis_lock_key(*args), lock_until)
+      end
+
       # Where the magic happens.
+      #
+      # @param [Array] args job arguments
       def around_perform_lock(*args)
         # Abort if another job holds the lock.
         return unless lock_until = acquire_lock!(*args)

data/test/lock_test.rb

@@ -126,4 +126,34 @@ class LockTest < Test::Unit::TestCase
     assert_nil lock_redis.get('specific_redis')
     assert_equal 1, $success, 'job should increment success'
   end
+
+  def test_lock_timeout_accepts_job_args
+    # setup our time values.
+    now = Time.now.to_i
+    one_hour_ahead = now + 3600
+    twelve_hours_ahead = (now + (3600 * 12))
+
+    # 1 hour ahead.
+    assert VariableTimeoutJob.acquire_lock!(1) >= one_hour_ahead, 'lock should be 1 hour ahead'
+    VariableTimeoutJob.release_lock!
+
+    # 12 hours ahead.
+    assert VariableTimeoutJob.acquire_lock!(12) >= twelve_hours_ahead, 'lock should be 12 hours ahead'
+    VariableTimeoutJob.release_lock!
+  end
+
+  def test_refresh_lock!
+    # grab the lock.
+    RefreshLockJob.acquire_lock!
+    sleep 2
+
+    # grab the initial lock timeout then refresh the lock.
+    initial_lock = Resque.redis.get(RefreshLockJob.redis_lock_key).to_i
+    RefreshLockJob.refresh_lock!
+
+    # lock should now be at least 1 second more then the initial lock.
+    latest_lock = Resque.redis.get(RefreshLockJob.redis_lock_key).to_i
+    diff = latest_lock - initial_lock
+    assert diff >= 1, 'diff between initial lock and refreshed lock should be at least 1 second'
+  end
 end

data/test/test_jobs.rb

@@ -1,3 +1,4 @@
+# Slow successful job, does not use timeout algorithm.
 class SlowJob
   extend Resque::Plugins::LockTimeout
   @queue = :test
@@ -12,6 +13,7 @@ class SlowJob
   end
 end
 
+# Fast successful job, does not use timeout algorithm.
 class FastJob
   extend Resque::Plugins::LockTimeout
   @queue = :test
@@ -25,6 +27,7 @@ class FastJob
   end
 end
 
+# Job that fails quickly, does not use timeout algorithm.
 class FailingFastJob
   extend Resque::Plugins::LockTimeout
   @queue = :test
@@ -35,6 +38,7 @@ class FailingFastJob
   end
 end
 
+# Job that enables the timeout algorithm.
 class SlowWithTimeoutJob
   extend Resque::Plugins::LockTimeout
   @queue = :test
@@ -46,6 +50,7 @@ class SlowWithTimeoutJob
   end
 end
 
+# Job that releases its lock AFTER its expired.
 class ExpireBeforeReleaseJob
   extend Resque::Plugins::LockTimeout
   @queue = :test
@@ -61,6 +66,7 @@ class ExpireBeforeReleaseJob
   end
 end
 
+# Job that uses a spesific redis connection just for storing locks.
 class SpecificRedisJob
   extend Resque::Plugins::LockTimeout
   @queue = :test
@@ -81,4 +87,29 @@ class SpecificRedisJob
     $success += 1
     sleep 0.2
   end
+end
+
+# Job that uses a different lock timeout value depending on job args.
+class VariableTimeoutJob
+  extend Resque::Plugins::LockTimeout
+  @queue = :test
+
+  def self.identifier(*args)
+    nil
+  end
+
+  def self.lock_timeout(extra_timeout)
+    3600 * extra_timeout
+  end
+
+  def self.perform
+    $success += 1
+  end
+end
+
+# Job to simulate a long running job that refreshes its hold on the lock.
+class RefreshLockJob
+  extend Resque::Plugins::LockTimeout
+  @queue = :test
+  @lock_timeout = 60
 end

metadata

@@ -2,7 +2,7 @@
 name: resque-lock-timeout
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors: 
 - Luke Antins