resque-lock-timeout 0.2.0

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2010 Chris Wanstrath
+Copyright (c) 2010 Ryan Carver
+Copyright (c) 2010 Luke Antins
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+Software), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED AS IS, WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,138 @@
+Resque Lock Timeout
+===================
+
+A [Resque][rq] plugin. Requires Resque 1.8.0.
+
+resque-lock-timeout adds locking, with optional timeout/deadlock handling to
+resque jobs.
+
+Using a `lock_timeout` allows you to re-aquire the lock should your worker
+fail, crash, or is otherwise unable to relase the lock. **i.e.** Your server
+unexpectedly looses power. Very handy for jobs that are recurring or may be
+retried.
+
+Usage / Examples
+----------------
+
+### Single Job Instance
+
+    require 'resque-lock-timeout'
+
+    class UpdateNetworkGraph
+      extend Resque::Plugins::LockTimeout
+      @queue = :network_graph
+
+      def self.perform(repo_id)
+        heavy_lifting
+      end
+    end
+
+Locking is achieved by storing a identifyer/lock key in Redis.
+
+Default behaviour...
+
+* Only one instance of a job may execute at once.
+* The lock is held until the job completes or fails.
+* If another job is executing with the same arguments the job will abort.
+
+Please see below for more information about the identifer/lock key.
+
+### With Lock Expiry/Timeout
+
+The locking algorithm used can be found in the [Redis SETNX][redis-setnx]
+documentation.
+
+Simply set the lock timeout in seconds, e.g.
+
+    class UpdateNetworkGraph
+      extend Resque::Plugins::LockTimeout
+      @queue = :network_graph
+
+      # Lock may be held for upto an hour.
+      @lock_timeout = 3600
+
+      def self.perform(repo_id)
+        heavy_lifting
+      end
+    end
+
+Customise & Extend
+==================
+
+### Job Identifier/Lock Key
+
+The key is built using the `identifier`. If you have a lot of arguments or
+really long ones, you should consider overriding `identifier` to define a
+more precise or loose custom identifier.
+
+The default identifier is just your job arguments joined with a dash `-`.
+
+By default the key uses this format: 
+`resque-lock-timeout:<job class name>:<identifier>`.
+
+Or you can define the entire key by overriding `redis_lock_key`.
+
+    class UpdateNetworkGraph
+      extend Resque::Plugins::LockTimeout
+      @queue = :network_graph
+
+      # Run only one at a time, regardless of repo_id.
+      def self.identifier(repo_id)
+        nil
+      end
+
+      def self.perform(repo_id)
+        heavy_lifting
+      end
+    end
+
+The above modification will ensure only one job of class
+UpdateNetworkGraph is running at a time, regardless of the
+repo_id.
+
+It's lock key would be: `resque-lock-timeout:UpdateNetworkGraph`.
+
+### Callbacks
+
+Several callbacks are available to override and implement your own logic, e.g.
+
+    class UpdateNetworkGraph
+      extend Resque::Plugins::Lock
+      @queue = :network_graph
+
+      # Lock may be held for upto an hour.
+      @lock_timeout = 3600
+
+      # Job failed to acquire lock. You may implement retry or other logic.
+      def self.lock_failed(repo_id)
+        raise LockFailed
+      end
+
+      # Job has complete; but the lock expired before we could relase it.
+      # The lock wasn't released; as its *possible* the lock is now held
+      # by another job.
+      def self.lock_expired_before_release(repo_id)
+        handle_if_needed
+      end
+
+      def self.perform(repo_id)
+        heavy_lifting
+      end
+    end
+
+Install
+=======
+
+    $ gem install resque-lock-retry
+
+Acknowledgements
+================
+
+Forked from Chris Wanstrath' [resque-lock][resque-lock] plugin.
+Lock timeout from Ryan Carvar' [resque-lock-retry][resque-lock-retry] plugin.
+And a little tinkering from Luke Antins.
+
+[rq]: http://github.com/defunkt/resque
+[redis-setnx]: http://code.google.com/p/redis/wiki/SetnxCommand
+[resque-lock]: http://github.com/defunkt/resque-lock
+[resque-lock-retry]: http://github.com/rcarver/resque-lock-retry

data/Rakefile

@@ -0,0 +1,21 @@
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'yard'
+require 'yard/rake/yardoc_task'
+
+task :default => :test
+
+desc 'Run tests.'
+Rake::TestTask.new(:test) do |task|
+  task.test_files = FileList['test/*_test.rb']
+  task.verbose = true
+end
+
+desc 'Build Yardoc documentation.'
+YARD::Rake::YardocTask.new :yardoc do |t|
+    t.files   = ['lib/**/*.rb']
+    t.options = ['--output-dir', "doc/",
+                 '--files', 'LICENSE',
+                 '--readme', 'README.md',
+                 '--title', 'resque-lock-timeout documentation']
+end

data/lib/resque-lock-timeout.rb

@@ -0,0 +1 @@
+require 'resque/plugins/lock_timeout'

data/lib/resque/plugins/lock_timeout.rb

@@ -0,0 +1,151 @@
+module Resque
+  module Plugins
+    # If you want only one instance of your job running at a time,
+    # extend it with this module:
+    #
+    # require 'resque-lock'
+    #
+    # class UpdateNetworkGraph
+    #   extend Resque::Plugins::LockTimeout
+    #   @queue = :network_graph
+    #
+    #   def self.perform(repo_id)
+    #     heavy_lifting
+    #   end
+    # end
+    #
+    # If you wish to limit the durati on a lock may be held for, you can
+    # set/override `lock_timeout`. e.g.
+    #
+    # class UpdateNetworkGraph
+    #   extend Resque::Plugins::LockTimeout
+    #   @queue = :network_graph
+    #
+    #   # lock may be held for upto an hour.
+    #   @lock_timeout = 3600
+    #
+    #   def self.perform(repo_id)
+    #     heavy_lifting
+    #   end
+    # end
+    #
+    module LockTimeout
+      # @abstract You may override to implement a custom identifier,
+      #           you should consider doing this if your job arguments
+      #           are many/long or may not cleanly cleanly to strings.
+      #
+      # Builds an identifier using the job arguments. This identifier
+      # is used as part of the redis lock key.
+      #
+      # @param [Array] args job arguments
+      # @return [String, nil] job identifier
+      def identifier(*args)
+        args.join('-')
+      end
+
+      # Override to fully control the lock key used. It is passed
+      # the job arguments.
+      #
+      # The default looks like this:
+      # `resque-lock-timeout:<class name>:<identifier>`
+      #
+      # @return [String] redis key
+      def redis_lock_key(*args)
+        ['lock', name, identifier(*args)].compact.join(":")
+      end
+
+      # Number of seconds the lock may be held for.
+      # A value of 0 or below will lock without a timeout.
+      #
+      # @return [Fixnum]
+      def lock_timeout
+        @lock_timeout ||= 0
+      end
+
+      # Try to acquire a lock.
+      #
+      # * Returns false; when unable to acquire the lock.
+      # * Returns true; when lock acquired, without a timeout.
+      # * Returns timestamp; when lock acquired with a timeout, timestamp is
+      #   when the lock timeout expires.
+      #
+      # @return [Boolean, Fixnum]
+      def acquire_lock!(*args)
+        acquired = false
+        lock_key = redis_lock_key(*args)
+
+        unless lock_timeout > 0
+          # Acquire without using a timeout.
+          acquired = true if Resque.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_until && acquired ? lock_until : acquired
+      end
+
+      # 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)
+        now = Time.now.to_i
+        lock_until = now + lock_timeout
+        acquired = false
+
+        return [true, lock_until] if Resque.redis.setnx(lock_key, lock_until)
+        # Can't acquire the lock, see if it has expired.
+        lock_expiration = Resque.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)
+          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)
+        end
+
+        [acquired, lock_until]
+      end
+
+      # 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))
+      end
+
+      # Where the magic happens.
+      def around_perform_lock(*args)
+        # Abort if another job holds the lock.
+        return unless lock_until = acquire_lock!(*args)
+
+        begin
+          yield
+        ensure
+          # Release the lock on success and error. Unless a lock_timeout is
+          # 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)
+              # Eeek! Lock expired before perform finished. Trigger callback.
+              lock_expired_before_release(*args)
+              return # dont relase lock.
+            end
+          end
+          release_lock!(*args)
+        end
+      end
+
+    end
+
+  end
+end

data/test/lock_test.rb

@@ -0,0 +1,108 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class LockTest < Test::Unit::TestCase
+  def setup
+    $success = $lock_failed = $lock_expired = 0
+    Resque.redis.flushall
+    @worker = Resque::Worker.new(:test)
+  end
+
+  def test_lint
+    assert_nothing_raised do
+      Resque::Plugin.lint(Resque::Plugins::LockTimeout)
+    end
+  end
+
+  def test_version
+    major, minor, patch = Resque::Version.split('.')
+    assert_equal 1, major.to_i
+    assert minor.to_i >= 7
+  end
+
+  def test_can_acquire_lock
+    SlowJob.acquire_lock!
+    assert_equal true, SlowJob.locked?, 'lock should be acquired'
+  end
+
+  def test_can_release_lock
+    SlowJob.acquire_lock!
+    assert_equal true, SlowJob.locked?, 'lock should be acquired'
+
+    SlowJob.release_lock!
+    assert_equal false, SlowJob.locked?, 'lock should have been released'
+  end
+
+  def test_lock_failed_callback
+    FastJob.acquire_lock!
+    assert_equal true, FastJob.locked?, 'lock should be acquired'
+
+    FastJob.acquire_lock!
+    assert_equal 1, $lock_failed, 'job callback should increment lock_failed'
+  end
+
+  def test_lock_without_timeout
+    3.times { Resque.enqueue(SlowJob) }
+
+    workers = []
+    3.times do
+      workers << Thread.new { @worker.process }
+    end
+    workers.each { |t| t.join }
+
+    assert_equal 1, $success, 'job should increment success'
+  end
+
+  def test_lock_is_released_on_success
+    Resque.enqueue(FastJob)
+    @worker.process
+    assert_equal 1, $success, 'job should increment success'
+    assert_equal false, FastJob.locked?, 'lock should have been released'
+  end
+
+  def test_lock_is_released_on_failure
+    Resque.enqueue(FailingFastJob)
+    @worker.process
+    assert_equal 0, $success, 'job shouldnt increment success'
+    assert_equal false, FastJob.locked?, 'lock should have been released'
+  end
+
+  def test_can_acquire_lock_with_timeout
+    now = Time.now.to_i
+    assert SlowWithTimeoutJob.acquire_lock!, 'acquire lock'
+
+    lock = Resque.redis.get(SlowWithTimeoutJob.redis_lock_key)
+    assert (now + 58) < lock.to_i, 'lock expire time should be in the future'
+  end
+
+  def test_lock_recovers_after_lock_timeout
+    now = Time.now.to_i
+    assert SlowWithTimeoutJob.acquire_lock!, 'acquire lock'
+    assert_equal false, SlowWithTimeoutJob.acquire_lock!, 'acquire lock fails'
+
+    Resque.redis.set(SlowWithTimeoutJob.redis_lock_key, now - 40) # haxor timeout.
+    assert SlowWithTimeoutJob.acquire_lock!, 'acquire lock, timeout expired'
+
+    lock = Resque.redis.get(SlowWithTimeoutJob.redis_lock_key)
+    assert (now + 58) < lock.to_i
+  end
+
+  def test_lock_with_timeout
+    3.times { Resque.enqueue(SlowWithTimeoutJob) }
+
+    workers = []
+    3.times do
+      workers << Thread.new { @worker.process }
+    end
+    workers.each { |t| t.join }
+
+    assert_equal 1, $success, 'job should increment success'
+  end
+
+  def test_lock_expired_before_release
+    Resque.enqueue(ExpireBeforeReleaseJob)
+    @worker.process
+    assert_equal 1, $success, 'job should increment success'
+    assert_equal true, $lock_expired, 'should be set by callback method'
+    assert_equal false, FastJob.locked?, 'lock should not release'
+  end
+end

data/test/redis-test.conf

@@ -0,0 +1,132 @@
+# Redis configuration file example
+
+# By default Redis does not run as a daemon. Use 'yes' if you need it.
+# Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
+daemonize yes
+
+# When run as a daemon, Redis write a pid file in /var/run/redis.pid by default.
+# You can specify a custom pid file location here.
+pidfile ./test/redis-test.pid
+
+# Accept connections on the specified port, default is 6379
+port 9736
+
+# If you want you can bind a single interface, if the bind option is not
+# specified all the interfaces will listen for connections.
+#
+# bind 127.0.0.1
+
+# Close the connection after a client is idle for N seconds (0 to disable)
+timeout 300
+
+# Save the DB on disk:
+#
+#   save <seconds> <changes>
+#
+#   Will save the DB if both the given number of seconds and the given
+#   number of write operations against the DB occurred.
+#
+#   In the example below the behaviour will be to save:
+#   after 900 sec (15 min) if at least 1 key changed
+#   after 300 sec (5 min) if at least 10 keys changed
+#   after 60 sec if at least 10000 keys changed
+save 900 1
+save 300 10
+save 60 10000
+
+# The filename where to dump the DB
+dbfilename dump.rdb
+
+# For default save/load DB in/from the working directory
+# Note that you must specify a directory not a file name.
+dir ./test/
+
+# Set server verbosity to 'debug'
+# it can be one of:
+# debug (a lot of information, useful for development/testing)
+# notice (moderately verbose, what you want in production probably)
+# warning (only very important / critical messages are logged)
+loglevel debug
+
+# Specify the log file name. Also 'stdout' can be used to force
+# the demon to log on the standard output. Note that if you use standard
+# output for logging but daemonize, logs will be sent to /dev/null
+logfile stdout
+
+# Set the number of databases. The default database is DB 0, you can select
+# a different one on a per-connection basis using SELECT <dbid> where
+# dbid is a number between 0 and 'databases'-1
+databases 16
+
+################################# REPLICATION #################################
+
+# Master-Slave replication. Use slaveof to make a Redis instance a copy of
+# another Redis server. Note that the configuration is local to the slave
+# so for example it is possible to configure the slave to save the DB with a
+# different interval, or to listen to another port, and so on.
+
+# slaveof <masterip> <masterport>
+
+################################## SECURITY ###################################
+
+# Require clients to issue AUTH <PASSWORD> before processing any other
+# commands.  This might be useful in environments in which you do not trust
+# others with access to the host running redis-server.
+#
+# This should stay commented out for backward compatibility and because most
+# people do not need auth (e.g. they run their own servers).
+
+# requirepass foobared
+
+################################### LIMITS ####################################
+
+# Set the max number of connected clients at the same time. By default there
+# is no limit, and it's up to the number of file descriptors the Redis process
+# is able to open. The special value '0' means no limts.
+# Once the limit is reached Redis will close all the new connections sending
+# an error 'max number of clients reached'.
+
+# maxclients 128
+
+# Don't use more memory than the specified amount of bytes.
+# When the memory limit is reached Redis will try to remove keys with an
+# EXPIRE set. It will try to start freeing keys that are going to expire
+# in little time and preserve keys with a longer time to live.
+# Redis will also try to remove objects from free lists if possible.
+#
+# If all this fails, Redis will start to reply with errors to commands
+# that will use more memory, like SET, LPUSH, and so on, and will continue
+# to reply to most read-only commands like GET.
+#
+# WARNING: maxmemory can be a good idea mainly if you want to use Redis as a
+# 'state' server or cache, not as a real DB. When Redis is used as a real
+# database the memory usage will grow over the weeks, it will be obvious if
+# it is going to use too much memory in the long run, and you'll have the time
+# to upgrade. With maxmemory after the limit is reached you'll start to get
+# errors for write operations, and this may even lead to DB inconsistency.
+
+# maxmemory <bytes>
+
+############################### ADVANCED CONFIG ###############################
+
+# 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

data/test/test_helper.rb

@@ -0,0 +1,41 @@
+dir = File.dirname(File.expand_path(__FILE__))
+$LOAD_PATH.unshift dir + '/../lib'
+$TESTING = true
+
+require 'test/unit'
+require 'resque'
+require 'turn'
+
+require 'resque-lock-timeout'
+require dir + '/test_jobs'
+
+##
+# make sure we can run redis
+if !system("which redis-server")
+  puts '', "** can't find `redis-server` in your path"
+  puts "** try running `sudo rake install`"
+  abort ''
+end
+
+##
+# start our own redis when the tests start,
+# kill it when they end
+at_exit do
+  next if $!
+
+  if defined?(MiniTest)
+    exit_code = MiniTest::Unit.new.run(ARGV)
+  else
+    exit_code = Test::Unit::AutoRunner.run
+  end
+
+  pid = `ps -e -o pid,command | grep [r]edis-test`.split(" ")[0]
+  puts "Killing test redis server..."
+  `rm -f #{dir}/dump.rdb`
+  Process.kill("KILL", pid.to_i)
+  exit exit_code
+end
+
+puts "Starting redis for testing at localhost:9736..."
+`redis-server #{dir}/redis-test.conf`
+Resque.redis = '127.0.0.1:9736'

data/test/test_jobs.rb

@@ -0,0 +1,62 @@
+class SlowJob
+  extend Resque::Plugins::LockTimeout
+  @queue = :test
+
+  def self.perform
+    $success += 1
+    sleep 0.2
+  end
+
+  def self.lock_failed(*args)
+    $lock_failed += 1
+  end
+end
+
+class FastJob
+  extend Resque::Plugins::LockTimeout
+  @queue = :test
+
+  def self.perform
+    $success += 1
+  end
+
+  def self.lock_failed(*args)
+    $lock_failed += 1
+  end
+end
+
+class FailingFastJob
+  extend Resque::Plugins::LockTimeout
+  @queue = :test
+
+  def self.perform
+    raise
+    $success += 1
+  end
+end
+
+class SlowWithTimeoutJob
+  extend Resque::Plugins::LockTimeout
+  @queue = :test
+  @lock_timeout = 60
+
+  def self.perform
+    $success += 1
+    sleep 0.2
+  end
+end
+
+class ExpireBeforeReleaseJob
+  extend Resque::Plugins::LockTimeout
+  @queue = :test
+  @lock_timeout = 1
+
+  def self.perform
+    $success += 1
+    sleep 2
+  end
+
+  def self.lock_expired_before_release
+    $lock_expired = true
+  end
+end

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification 
+name: resque-lock-timeout
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 0
+  version: 0.2.0
+platform: ruby
+authors: 
+- Luke Antins
+- Ryan Carver
+- Chris Wanstrath
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-06 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: resque
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 8
+        - 0
+        version: 1.8.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: turn
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: yard
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+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: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.md
+- Rakefile
+- LICENSE
+- lib/resque/plugins/lock_timeout.rb
+- lib/resque-lock-timeout.rb
+- test/lock_test.rb
+- test/redis-test.conf
+- test/test_helper.rb
+- test/test_jobs.rb
+has_rdoc: false
+homepage: http://github.com/lantins/resque-lock-timeout
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: A Resque plugin adding locking, with optional timeout/deadlock handling to resque jobs.
+test_files: []
+