resque-unique 0.1.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) Ronny Haryanto, 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,53 @@
+Resque Unique
+=============
+
+This is a modified version of [resque-lock][rl]. This version uses the
+algorithm mentioned in the [Redis SETNX documentation][setnx] to avoid
+deadlocks. This version should also clean up the locks after the worker is
+finished performing, regardless of the outcome.
+
+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 this module.
+
+
+For example:
+
+    require 'resque/plugins/unique'
+
+    class UpdateNetworkGraph
+      extend Resque::Plugins::Unique
+
+      def self.perform(repo_id)
+        heavy_lifting
+      end
+    end
+
+While this job is queued or running, no other UpdateNetworkGraph
+jobs with the same arguments will be placed on the queue.
+
+If you want to define the key yourself you can override the
+`lock` class method in your subclass, e.g.
+
+    class UpdateNetworkGraph
+      extend Resque::Plugins::Unique
+
+      Run only one at a time, regardless of repo_id.
+      def self.lock(repo_id)
+        "network-graph"
+      end
+
+      def self.perform(repo_id)
+        heavy_lifting
+      end
+    end
+
+The above modification will ensure only one job of class
+UpdateNetworkGraph is queued at a time, regardless of the
+repo_id. Normally a job is locked using a combination of its
+class name and arguments.
+
+[rq]: http://github.com/defunkt/resque
+[rl]: http://github.com/defunkt/resque-lock
+[setnx]: http://redis.io/commands/setnx

data/Rakefile

@@ -0,0 +1,5 @@
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/resque/plugins/unique.rb

@@ -0,0 +1,49 @@
+module Resque
+  module Plugins
+    module Unique
+      def lock(*args)
+        "unique:#{name}-#{normalised_args(*args).to_s}"
+      end
+
+      def lock_timeout
+        @lock_timeout || 3_600 #seconds
+      end
+
+      def before_enqueue_unique(*args)
+        acquire_lock(*args)
+      end
+
+      def around_perform_unique(*args)
+        begin
+          yield
+        ensure
+          # Always clear the lock when we're done, even if there is an
+          # error.
+          Resque.redis.del(lock(*args))
+        end
+      end
+
+    private
+
+      def normalised_args(*args)
+        args.map {|arg| arg.to_s.to_sym}
+      end
+
+      def lock_expires_at
+        ((Time.now.to_f * 1_000).to_i + (lock_timeout * 1_000) + 1_000).to_i
+      end
+
+      # http://redis.io/commands/setnx
+      def acquire_lock(*args)
+        if Resque.redis.setnx(lock(*args), lock_expires_at)
+          true
+        else
+          new_lock_expiry = lock_expires_at
+          existing_lock_expiry = Resque.redis.getset(lock(*args), new_lock_expiry).to_i
+          existing_lock_expiry <= Time.now.to_i
+        end
+      end
+
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+require 'rspec/autorun'
+Dir["spec/support/**/*.rb"].each {|f| require f}
+
+require 'timecop'
+
+RSpec.configure do |config|
+  config.before(:each) do
+    Resque.redis.flushall
+  end
+
+  config.after(:each) do
+    Resque.redis.flushall
+  end
+end

data/spec/unique_spec.rb

@@ -0,0 +1,103 @@
+require 'resque'
+require 'resque/plugins/unique'
+
+require 'spec_helper'
+
+describe "Resque::Plugins::Unique" do
+  let(:queue) { :unique_test }
+  let(:resque_queue_key) { "queue:#{queue}" }
+  let(:arg) { :success }
+  let(:lock) { Job.lock(arg) }
+  let(:expires_at) {
+    ((Time.now.to_f * 1_000).to_i + 3_600_000 + 1_000).to_i
+  }
+
+
+  class Job
+    extend Resque::Plugins::Unique
+    @queue = :unique_test
+
+    def self.perform(arg)
+      if arg.to_sym == :raise
+        raise "perform: simulated exception"
+      else
+        puts "perform: #{arg}"
+      end
+    end
+  end
+
+  it "passes Resque::Plugin.lint" do
+    expect {
+      Resque::Plugin.lint(Resque::Plugins::Unique)
+    }.not_to raise_error
+  end
+
+  it "has before_enqueue_hooks" do
+    Resque::Plugin.should respond_to :before_enqueue_hooks
+  end
+
+  describe "enqueue" do
+    it "ensures only one instance of a job exists" do
+      3.times { Resque.enqueue(Job, arg) }
+      Resque.redis.llen(resque_queue_key).should == 1
+    end
+
+    it "locks with time out" do
+      Timecop.freeze(Time.now) do
+        3.times { Resque.enqueue(Job, arg) }
+        Resque.redis.get(lock).to_i.should == expires_at
+      end
+    end
+
+    it "advances lock expiry on subsequent enqueueing" do
+      Resque.enqueue(Job, arg)
+      first_expiry = Resque.redis.get(lock)
+      Timecop.freeze(Time.now + 10) do
+        Resque.enqueue(Job, arg)
+        second_expiry = Resque.redis.get(lock)
+        second_expiry.to_i.should > first_expiry.to_i
+      end
+    end
+  end
+
+  describe "worker" do
+    let(:worker) do
+      Resque::Worker.new(queue).tap do |w|
+        w.term_child = "1"
+        w.very_verbose = "1"
+        # w.verbose = "1"
+      end
+    end
+
+    before :each do
+      Resque.enqueue(Job, arg)
+      lock.should_not be_nil
+      Resque.redis.get(lock).should_not be_nil
+    end
+
+    shared_examples_for "a sane worker" do
+      it "removes the lock" do
+        worker.work(0)
+        Resque.redis.get(lock).should be_nil
+      end
+
+      it "allows requeueing" do
+        worker.work(0)
+        Resque.redis.get(lock).should be_nil
+        Resque.enqueue(Job, arg)
+        lock.should_not be_nil
+        Resque.redis.get(lock).should_not be_nil
+      end
+    end
+
+    context "when job was successfully performed" do
+      let!(:arg) { :success }
+      it_behaves_like "a sane worker"
+    end
+
+    context "when job failed" do
+      let!(:arg) { :raise }
+      it_behaves_like "a sane worker"
+    end
+  end
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: resque-unique
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Ronny Haryanto
+- Chris Wanstrath
+- Ray Krueger
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-13 00:00:00.000000000 Z
+dependencies: []
+description: ! "A Resque plugin. If you want only one instance of your job\nqueued
+  at a time, extend it with this module.\n\nFor example:\n\n    class UpdateNetworkGraph\n
+  \     extend Resque::Plugins::Unique\n\n      def self.perform(repo_id)\n        heavy_lifting\n
+  \     end\n    end\n"
+email: ronny@haryan.to
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- LICENSE
+- lib/resque/plugins/unique.rb
+- spec/spec_helper.rb
+- spec/unique_spec.rb
+homepage: http://github.com/ronny/resque-unique
+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 to ensure only one instance of a job exists in a queue.
+test_files: []