resque-lock-timeout 0.2.1 → 0.3.0

data/HISTORY.md

@@ -1,3 +1,11 @@
+## 0.3.0 (2011-07-16)
+
+* Ability to customize redis connection used for storing locks.
+  (thanks Richie Vos =))
+* Added Bundler `Gemfile`.
+* Added abstract stub methods for callback methods:
+  `lock_failed`, `lock_expired_before_release`
+
 ## 0.2.1 (2010-06-16)
 
 * Relax gemspec dependancies.
@@ -5,4 +13,4 @@
 ## 0.2.0 (2010-05-05)
 
 * Initial release as `resque-lock-timeout`, forked from Chris Wanstrath'
-  `resque-lock`.
+`resque-lock`.

data/README.md

@@ -92,6 +92,24 @@ repo_id.
 
 It's lock key would be: `resque-lock-timeout:UpdateNetworkGraph`.
 
+### Redis Connection Used for Locking
+
+By default all locks are stored via Resque's redis connection. If you wish to
+change this you may override `lock_redis`.
+
+    class UpdateNetworkGraph
+      extend Resque::Plugins::LockTimeout
+      @queue = :network_graph
+
+      def self.lock_redis
+        @lock_redis ||= Redis.new
+      end
+
+      def self.perform(repo_id)
+        heavy_lifting
+      end
+    end
+
 ### Callbacks
 
 Several callbacks are available to override and implement your own logic, e.g.

data/Rakefile

@@ -1,5 +1,4 @@
 require 'rake/testtask'
-require 'rake/rdoctask'
 require 'yard'
 require 'yard/rake/yardoc_task'
 

data/lib/resque/plugins/lock_timeout.rb

@@ -43,6 +43,16 @@ module Resque
         args.join('-')
       end
 
+      # Override to fully control the redis object used for storing
+      # the locks.
+      #
+      # The default is Resque.redis
+      #
+      # @return [Redis] redis object
+      def lock_redis
+        Resque.redis
+      end
+
       # Override to fully control the lock key used. It is passed
       # the job arguments.
       #
@@ -62,6 +72,27 @@ module Resque
         @lock_timeout ||= 0
       end
 
+      # Convenience method, not used internally.
+      #
+      # @return [Boolean] true if the job is locked by someone
+      def locked?(*args)
+        lock_redis.exists(redis_lock_key(*args))
+      end
+
+      # @abstract
+      # Hook method; called when a were unable to aquire the lock.
+      #
+      # @param [Array] args job arguments
+      def lock_failed(*args)
+      end
+
+      # @abstract
+      # Hook method; called when the lock expired before we released it.
+      #
+      # @param [Array] args job arguments
+      def lock_expired_before_release(*args)
+      end
+
       # Try to acquire a lock.
       #
       # * Returns false; when unable to acquire the lock.
@@ -76,13 +107,13 @@ module Resque
 
         unless lock_timeout > 0
           # Acquire without using a timeout.
-          acquired = true if Resque.redis.setnx(lock_key, true)
+          acquired = true if lock_redis.setnx(lock_key, true)
         else
           # Acquire using the timeout algorithm.
           acquired, lock_until = acquire_lock_algorithm!(lock_key)
         end
 
-        lock_failed(*args) if !acquired && respond_to?(:lock_failed)
+        lock_failed(*args) if !acquired
         lock_until && acquired ? lock_until : acquired
       end
 
@@ -94,18 +125,18 @@ module Resque
         lock_until = now + lock_timeout
         acquired = false
 
-        return [true, lock_until] if Resque.redis.setnx(lock_key, lock_until)
+        return [true, lock_until] if lock_redis.setnx(lock_key, lock_until)
         # Can't acquire the lock, see if it has expired.
-        lock_expiration = Resque.redis.get(lock_key)
+        lock_expiration = lock_redis.get(lock_key)
         if lock_expiration && lock_expiration.to_i < now
           # expired, try to acquire.
-          lock_expiration = Resque.redis.getset(lock_key, lock_until)
+          lock_expiration = lock_redis.getset(lock_key, lock_until)
           if lock_expiration.nil? || lock_expiration.to_i < now
             acquired = true
           end
         else
           # Try once more...
-          acquired = true if Resque.redis.setnx(lock_key, lock_until)
+          acquired = true if lock_redis.setnx(lock_key, lock_until)
         end
 
         [acquired, lock_until]
@@ -113,14 +144,7 @@ module Resque
 
       # Release the lock.
       def release_lock!(*args)
-        Resque.redis.del(redis_lock_key(*args))
-      end
-
-      # Convenience method, not used internally.
-      #
-      # @return [Boolean] true if the job is locked by someone
-      def locked?(*args)
-        Resque.redis.exists(redis_lock_key(*args))
+        lock_redis.del(redis_lock_key(*args))
       end
 
       # Where the magic happens.
@@ -135,7 +159,7 @@ module Resque
           # used, then we need to be more careful before releasing the lock.
           unless lock_until === true
             now = Time.now.to_i
-            if lock_until < now && respond_to?(:lock_expired_before_release)
+            if lock_until < now
               # Eeek! Lock expired before perform finished. Trigger callback.
               lock_expired_before_release(*args)
               return # dont relase lock.

data/test/lock_test.rb

@@ -105,4 +105,25 @@ class LockTest < Test::Unit::TestCase
     assert_equal true, $lock_expired, 'should be set by callback method'
     assert_equal false, FastJob.locked?, 'lock should not release'
   end
+
+  def test_lock_with_specific_redis
+    lock_redis = Redis.new(:host => Resque.redis.client.host,
+                           :port => Resque.redis.client.port,
+                           :db => 'locks',
+                           :threadsafe => true)
+    SpecificRedisJob.lock_redis = lock_redis
+    Resque.enqueue(SpecificRedisJob)
+
+    thread = Thread.new { @worker.process }
+
+    sleep 0.1
+    # this is nil in Resque.redis since we make no attempt to add a resque:
+    # prefix to the key
+    assert_nil Resque.redis.get('specific_redis')
+    assert_not_nil lock_redis.get('specific_redis')
+
+    thread.join
+    assert_nil lock_redis.get('specific_redis')
+    assert_equal 1, $success, 'job should increment success'
+  end
 end

data/test/redis-test.conf

@@ -112,21 +112,4 @@ databases 16
 # Glue small output buffers together in order to send small replies in a
 # single TCP packet. Uses a bit more CPU but most of the times it is a win
 # in terms of number of queries per second. Use 'yes' if unsure.
-glueoutputbuf yes
-
-# Use object sharing. Can save a lot of memory if you have many common
-# string in your dataset, but performs lookups against the shared objects
-# pool so it uses more CPU and can be a bit slower. Usually it's a good
-# idea.
-#
-# When object sharing is enabled (shareobjects yes) you can use
-# shareobjectspoolsize to control the size of the pool used in order to try
-# object sharing. A bigger pool size will lead to better sharing capabilities.
-# In general you want this value to be at least the double of the number of
-# very common strings you have in your dataset.
-#
-# WARNING: object sharing is experimental, don't enable this feature
-# in production before of Redis 1.0-stable. Still please try this feature in
-# your development environment so that we can test it better.
-shareobjects no
-shareobjectspoolsize 1024
+glueoutputbuf yes

data/test/test_jobs.rb

@@ -59,4 +59,26 @@ class ExpireBeforeReleaseJob
   def self.lock_expired_before_release
     $lock_expired = true
   end
+end
+
+class SpecificRedisJob
+  extend Resque::Plugins::LockTimeout
+  @queue = :test
+
+  def self.lock_redis
+    @redis
+  end
+
+  def self.lock_redis=(redis)
+    @redis = redis
+  end
+
+  def self.redis_lock_key
+    'specific_redis'
+  end
+
+  def self.perform
+    $success += 1
+    sleep 0.2
+  end
 end

metadata

@@ -1,12 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: resque-lock-timeout
 version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 2
-  - 1
-  version: 0.2.1
+  prerelease: 
+  version: 0.3.0
 platform: ruby
 authors: 
 - Luke Antins
@@ -16,20 +12,17 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-27 00:00:00 +01:00
+date: 2011-07-16 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: resque
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 1
-        - 8
-        - 0
         version: 1.8.0
   type: :runtime
   version_requirements: *id001
@@ -37,11 +30,10 @@ dependencies:
   name: turn
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 0
         version: "0"
   type: :development
   version_requirements: *id002
@@ -49,14 +41,24 @@ dependencies:
   name: yard
   prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 0
         version: "0"
   type: :development
   version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rdiscount
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id004
 description: "  A Resque plugin. Adds locking, with optional timeout/deadlock handling to\n  resque jobs.\n\n  Using a `lock_timeout` allows you to re-aquire the lock should your worker\n  fail, crash, or is otherwise unable to relase the lock.\n  \n  i.e. Your server unexpectedly looses power. Very handy for jobs that are\n  recurring or may be retried.\n"
 email: luke@lividpenguin.com
 executables: []
@@ -86,23 +88,21 @@ rdoc_options: []
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: A Resque plugin adding locking, with optional timeout/deadlock handling to resque jobs.