resque-workers-lock 1.0.0

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012  Bart Olsthoorn, website: bartolsthoorn.nl
+
+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,48 @@
+# Resque Workers Lock
+This is a [resque](https://github.com/defunkt/resque) plugin inspired by [resque-lock](https://github.com/defunkt/resque-lock) and requires Resque 1.7.0.
+
+``` ruby
+gem 'resque-workers-lock'
+```
+
+## What does it do?
+If resque jobs have the same lock applied this means that those jobs cannot be processed simultaneously by two or more workers.
+
+## What is the default lock?
+By default the lock is the instance name + arguments (just like the classic resque-lock). Override this lock to lock on specific arguments.
+
+## How does it differ from resque-lock?
+Resque-lock will not let you queue jobs when you locked them. Resque-workers-lock locks on a workers-level and will requeue the locked jobs. Resque workers lock will not prevent you to queue jobs. If a worker takes on a job that is already being processed by another worker it will put the job back up in the queue!
+
+## Example
+This example shows how you can use the workers-lock to prevent two jobs with the same domain to be processed simultaneously.
+``` ruby
+require 'resque/plugins/workers/lock'
+
+class Scraper
+  extend Resque::Plugins::Workers::Lock
+
+	def self.lock(domain)
+		return domain
+	end
+
+  def self.perform(domain)
+    # do the work
+  end
+end
+```
+
+## Requeue loop
+When a job is requeue'ed there is a small delay (1 second by default) before the worker places the job actually back in the queue. Let's say you have two jobs left, and one job is taking 15 seconds on the first worker and the other similar job is being blocked by the second worker. The second worker will continuously try to put the job back in the queue and it will try to process it again (racing for 15 seconds untill the other job has finished). This only happens when there are no other (not locked) jobs in the queue.
+
+To overwrite this delay in your class:
+``` ruby
+def self.requeue_perform_delay
+	5.0
+end
+```
+
+Please note that setting this value to 5 seconds will keep the worker idle for 5 seconds when the job is locked.
+
+## Possibilities to prevent the loop 
+Do a delayed resque (re)queue. However, this will have approximately the same results and will require a large extra chunk of code and rake configurations.

data/Rakefile

@@ -0,0 +1,24 @@
+require 'rake/testtask'
+require 'rdoc/task'
+
+def command?(command)
+  system("type #{command} > /dev/null")
+end
+
+# Tests
+
+task :default => :test
+
+if command? :turn
+  desc "Run tests"
+  task :test do
+    suffix = "-n #{ENV['TEST']}" if ENV['TEST']
+    sh "turn test/*.rb #{suffix}"
+  end
+else
+  Rake::TestTask.new do |t|
+    t.libs << 'lib'
+    t.pattern = 'test/**/*_test.rb'
+    t.verbose = false
+  end
+end

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

@@ -0,0 +1,34 @@
+module Resque
+  module Plugins
+    module Workers
+      module Lock
+        # Override in your job to control the lock key.
+        def lock(*args)
+          "lock:#{name}-#{args.to_s}"
+        end
+        
+        def requeue_perform_delay
+          1.0
+        end
+        
+        def before_perform_lock(*args)
+          nx = Resque.redis.setnx(lock(*args), true)
+          if nx == false
+            sleep(requeue_perform_delay)
+            Resque.enqueue(self, *args)
+            raise Resque::Job::DontPerform
+          end
+        end
+      
+        def around_perform_lock(*args)
+          begin
+            yield
+          ensure
+            # Clear the lock. (even with errors)
+            Resque.redis.del(lock(*args))
+          end
+        end
+      end
+    end
+  end
+end

data/test/lock_test.rb

@@ -0,0 +1,44 @@
+require 'test/unit'
+require 'resque'
+require 'resque/plugins/workers/lock'
+
+$counter = 0
+
+class LockTest < Test::Unit::TestCase
+  class Job
+    extend Resque::Plugins::Workers::Lock
+    @queue = :lock_test
+
+    def self.perform
+      raise "This should not have not happened"
+    end
+  end
+
+  def setup
+    Resque.redis.del('queue:lock_test')
+    Resque.redis.del(Job.lock)
+  end
+
+  def test_lint
+    assert_nothing_raised do
+      Resque::Plugin.lint(Resque::Plugins::Workers::Lock)
+    end
+  end
+
+  def test_version
+    major, minor, patch = Resque::Version.split('.')
+    assert_equal 1, major.to_i
+    assert minor.to_i >= 17
+    assert Resque::Plugin.respond_to?(:before_enqueue_hooks)
+  end
+
+  def test_enqueue
+    3.times { Resque.enqueue(Job) }
+
+    assert_equal 3, Resque.redis.llen('queue:lock_test')
+  end
+  
+  def test_lock
+    # TODO: test that two workers are not processing two jobs
+  end
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: resque-workers-lock
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Bart Olsthoorn
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: resque
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: turn
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! "A Resque plugin. If you want to prevent specific jobs to be processed
+  simultaneously, \nextend it with this module. It locks on the first argument in
+  the perform method.\n\nFor example:\n\n    class Scraper\n      extend Resque::Plugins::Workers::Lock\n\n
+  \       def self.lock(domain)\n            return domain\n        end\n\n      def
+  self.perform(domain)\n        # do the work\n      end\n    end\n"
+email: bartolsthoorn@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- LICENSE
+- lib/resque/plugins/workers/lock.rb
+- test/lock_test.rb
+homepage: http://github.com/bartolsthoorn/resque-workers-lock
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Resque plugin, prevent specific jobs to be processed simultaneously by multiple
+  workers.
+test_files: []