resque-fine-grained-locks 1.0.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) Chris Wanstrath, Ray Krueger
+
+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 Fine-Grained Locks
+===========
+
+A [Resque][rq] plugin. Requires Resque 1.7.0.
+
+If you want only one instance of your job queued at a time, extend it
+with Resque::Plugins::QueueLock.  You will be able to enqueue another
+job if one is currently executing.
+
+For example:
+
+    require 'resque/plugins/queue_lock'
+
+    class UpdateNetworkGraph
+      extend Resque::Plugins::QueueLock
+
+      def self.perform(repo_id)
+        heavy_lifting
+      end
+    end
+
+If you want only one instance of your job to execute at a time, extend
+it with Resque::Plugins::ExecutionLock.  You can optionally use
+resque-retry if you want to retry locked jobs without them failing.
+
+For example:
+
+require 'resque/plugins/execution_lock'
+
+class UpdateNetworkGraph
+  extend Resque::Plugins::Retry
+  extend Resque::Plugins::ExecutionLock
+
+  @retry_exceptions = [
+    Resque::Plugins::ExecutionLock::JobIsLocked
+  ]
+
+  def self.perform(repo_id)
+    heavy_lifting
+  end
+end
+
+And in your resque initializer (config/resque.rb):
+
+require 'resque/failure/multiple'
+
+Resque::Failure::MultipleWithRetrySuppression.classes = [Resque::Plugins::ExecutionLock::JobIsLocked]
+Resque::Failure.backend = Resque::Failure::MultipleWithRetrySuppression

data/Rakefile

@@ -0,0 +1,26 @@
+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/execution_lock.rb

@@ -0,0 +1,24 @@
+module Resque
+  module Plugins
+    module ExecutionLock
+      class JobIsLocked < RuntimeError; end
+
+      def execution_lock(*args)
+        "execution_lock:#{name}-#{args.to_s}"
+      end
+
+      def before_perform_execution_lock(*args)
+        raise JobIsLocked unless Resque.redis.setnx(execution_lock(*args), true)
+      end
+
+      def around_perform_execution_lock(*args)
+        begin
+          yield
+        ensure
+          Resque.redis.del(execution_lock(*args))
+        end
+      end
+    end
+  end
+end
+

data/lib/resque/plugins/queue_lock.rb

@@ -0,0 +1,17 @@
+module Resque
+  module Plugins
+    module QueueLock
+      def queue_lock(*args)
+        "queue_lock:#{name}-#{args.to_s}"
+      end
+
+      def before_enqueue_queue_lock(*args)
+        Resque.redis.setnx(queue_lock(*args), true)
+      end
+
+      def before_perform_queue_lock(*args)
+        Resque.redis.del(queue_lock(*args))
+      end
+    end
+  end
+end

data/test/execution_lock_test.rb

@@ -0,0 +1,84 @@
+require 'test/unit'
+require 'resque'
+require 'resque/plugins/execution_lock'
+
+$execution_lock_do = nil
+$execution_lock_results = nil
+
+class ExecutionLockTestJob
+  extend Resque::Plugins::ExecutionLock
+  @queue = :execution_lock_test
+
+  def self.perform(success_type)
+    if $execution_lock_do
+      block, $execution_lock_do = $execution_lock_do, nil
+      block.call
+    end
+
+    case success_type.to_sym
+    when :success
+      $execution_lock_results << :success
+    when :fail
+      raise RuntimeError, "Purposeful fail!"
+    end
+  end
+end
+
+class ExecutionLockTest < Test::Unit::TestCase
+  def setup
+    Resque.redis.del('queue:execution_lock_test')
+    Resque.redis.del(ExecutionLockTestJob.execution_lock('success'))
+    Resque.redis.del(ExecutionLockTestJob.execution_lock('fail'))
+
+    $execution_lock_do = nil
+    $execution_lock_results = []
+  end
+
+  def perform_job(success_type, &block)
+    $execution_lock_do = block if block_given?
+    payload = {"class" => "ExecutionLockTestJob", "args" => success_type.to_s}
+    Resque::Job.new(:execution_lock_test, payload).perform
+  end
+
+  def test_lint
+    assert_nothing_raised do
+      Resque::Plugin.lint(Resque::Plugins::ExecutionLock)
+    end
+  end
+
+  def test_multiple_jobs_can_run_sequentially
+    perform_job(:success)
+    assert_equal [:success], $execution_lock_results
+
+    perform_job(:success)
+    assert_equal [:success, :success], $execution_lock_results
+  end
+
+  def test_subsequent_jobs_can_run_after_a_job_failure
+    assert_raise RuntimeError do
+      perform_job(:fail)
+    end
+
+    perform_job(:success)
+    assert_equal [:success], $execution_lock_results
+  end
+
+  def test_multiple_jobs_cannot_run_simultaneously
+    perform_job(:success) do
+      assert_raise Resque::Plugins::ExecutionLock::JobIsLocked do
+        perform_job(:success)
+      end
+    end
+    assert_equal [:success], $execution_lock_results
+  end
+
+  def test_locked_job_does_not_clear_lock
+    perform_job(:success) do
+      assert_raise Resque::Plugins::ExecutionLock::JobIsLocked do
+        perform_job(:success)
+      end
+
+      assert Resque.redis.exists(ExecutionLockTestJob.execution_lock('success'))
+    end
+  end
+end

data/test/queue_lock_test.rb

@@ -0,0 +1,40 @@
+require 'test/unit'
+require 'resque'
+require 'resque/plugins/queue_lock'
+
+$counter = 0
+
+class QueueLockTest < Test::Unit::TestCase
+  class Job
+    extend Resque::Plugins::QueueLock
+    @queue = :lock_test
+
+    def self.perform
+      raise "Woah woah woah, that wasn't supposed to happen"
+    end
+  end
+
+  def setup
+    Resque.redis.del('queue:lock_test')
+    Resque.redis.del(Job.queue_lock)
+  end
+
+  def test_lint
+    assert_nothing_raised do
+      Resque::Plugin.lint(Resque::Plugins::QueueLock)
+    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_lock
+    3.times { Resque.enqueue(Job) }
+
+    assert_equal 1, Resque.redis.llen('queue:lock_test')
+  end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+name: resque-fine-grained-locks
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Efficiency 2.0
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-02-02 00:00:00 Z
+dependencies: []
+
+description: |+
+  A Resque plugin. If you want only one instance of your job
+  queued or executing at a time, extend it with Resque::Jobs::QueueLock
+  and/or Resque::Jobs::ExecutionLock.
+  
+email: tech@efficiency20.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.md
+- Rakefile
+- LICENSE
+- lib/resque/plugins/execution_lock.rb
+- lib/resque/plugins/queue_lock.rb
+- test/execution_lock_test.rb
+- test/queue_lock_test.rb
+homepage: http://github.com/efficiency20/resque-fine-grained-locks
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Resque plugins for ensuring only one instance of your job is queued and/or executing at a time.
+test_files: []
+