resque-loner 1.2.1 → 1.3.0

data/lib/resque-loner/legacy_helpers.rb

@@ -0,0 +1,91 @@
+# This is an old helpers module pulled in from Resque 1.25.1
+# which will be deprecated in future Resque versions. Bringing in
+# this module allows us to get rid of the deprecation message
+# (Resque::Helpers will be gone with no replacement in Resque 2.0.0.)
+require 'multi_json'
+
+# OkJson won't work because it doesn't serialize symbols
+# in the same way yajl and json do.
+if MultiJson.engine.to_s == 'MultiJson::Engines::OkJson'
+  fail 'Please install the yajl-ruby or json gem'
+end
+
+module Resque
+  module Plugins
+    module Loner
+      # Methods used by various classes in Resque.
+      module LegacyHelpers
+        class DecodeException < StandardError; end
+
+        # Direct access to the Redis instance.
+        def redis
+          Resque.redis
+        end
+
+        # Given a Ruby object, returns a string suitable for storage in a
+        # queue.
+        def encode(object)
+          ::MultiJson.encode(object)
+        end
+
+        # Given a string, returns a Ruby object.
+        def decode(object)
+          return unless object
+
+          begin
+            ::MultiJson.decode(object)
+          rescue ::MultiJson::DecodeError => e
+            raise DecodeException, e.message, e.backtrace
+          end
+        end
+
+        # Given a word with dashes, returns a camel cased version of it.
+        #
+        # classify('job-name') # => 'JobName'
+        def classify(dashed_word)
+          dashed_word.split('-').each { |part| part[0] = part[0].chr.upcase }.join
+        end
+
+        # Tries to find a constant with the name specified in the argument string:
+        #
+        # constantize("Module") # => Module
+        # constantize("Test::Unit") # => Test::Unit
+        #
+        # The name is assumed to be the one of a top-level constant, no matter
+        # whether it starts with "::" or not. No lexical context is taken into
+        # account:
+        #
+        # C = 'outside'
+        # module M
+        #   C = 'inside'
+        #   C # => 'inside'
+        #   constantize("C") # => 'outside', same as ::C
+        # end
+        #
+        # NameError is raised when the constant is unknown.
+        def constantize(camel_cased_word)
+          camel_cased_word = camel_cased_word.to_s
+
+          if camel_cased_word.include?('-')
+            camel_cased_word = classify(camel_cased_word)
+          end
+
+          names = camel_cased_word.split('::')
+          names.shift if names.empty? || names.first.empty?
+
+          constant = Object
+          names.each do |name|
+            args = Module.method(:const_get).arity != 1 ? [false] : []
+
+            if constant.const_defined?(name, *args)
+              constant = constant.const_get(name)
+            else
+              constant = constant.const_missing(name)
+            end
+          end
+          constant
+        end
+      end
+    end
+  end
+end

data/lib/resque-loner/unique_job.rb

@@ -1,4 +1,5 @@
 require 'digest/md5'
+require 'resque-loner/helpers'
 
 #
 #  If you want your job to be unique, include this module in it. If you wish,
@@ -7,37 +8,34 @@ require 'digest/md5'
 module Resque
   module Plugins
     module UniqueJob
-
       def self.included(base)
-        base.extend         ClassMethods
+        base.extend ClassMethods
         base.class_eval do
-          base.send(:extend, Resque::Helpers)
+          base.send(:extend, Resque::Plugins::Loner::LegacyHelpers)
         end
       end # self.included
 
       module ClassMethods
-
-
         #
         #  Payload is what Resque stored for this job along with the job's class name.
         #  On a Resque with no plugins installed, this is a hash containing :class and :args
         #
         def redis_key(payload)
           payload = decode(encode(payload)) # This is the cycle the data goes when being enqueued/dequeued
-          job  = payload[:class] || payload["class"]
-          args = (payload[:args]  || payload["args"])
+          job  = payload[:class] || payload['class']
+          args = (payload[:args]  || payload['args'])
           args.map! do |arg|
             arg.is_a?(Hash) ? arg.sort : arg
           end
 
-          digest = Digest::MD5.hexdigest encode(:class => job, :args => args)
+          digest = Digest::MD5.hexdigest(encode(class: job, args: args))
           digest
         end
 
         #
         # The default ttl of a locking key is -1, i.e. forever.  If for some reason you only
-        # want the lock to be in place after a certain amount of time, just set a ttl for
-        # for your job.  For example:
+        # want the lock to be in place after a certain amount of time, just set a ttl (in
+        # seconds) for your job.  For example:
         #
         # class FooJob
         #   include Resque::Plugins::UniqueJob
@@ -49,9 +47,21 @@ module Resque
           @loner_ttl || -1
         end
 
+        #
+        # The default ttl of a persisting key is 0, i.e. immediately deleted.
+        # You can set loner_lock_after_execution_period if you want to block the execution
+        # of the job for a certain amount of time (in seconds).  For example:
+        #
+        # class FooJob
+        #   include Resque::Plugins::UniqueJob
+        #   @loner_lock_after_execution_period = 40
+        #   end
+        # end
+        #
+        def loner_lock_after_execution_period
+          @loner_lock_after_execution_period || 0
+        end
       end # ClassMethods
-
-
     end
   end
 end
@@ -60,13 +70,12 @@ module Resque
   module Plugins
     module Loner
       class UniqueJob
-
         include Resque::Plugins::UniqueJob
 
         def self.inherited(host)
           super(host)
           return  if @__unique_job_warned
-          warn "Inherit Resque::Plugins::Loner::UniqueJob is deprecated. Include Resque::Plugins::UniqueJob module instead."
+          warn 'Inherit Resque::Plugins::Loner::UniqueJob is deprecated. Include Resque::Plugins::UniqueJob module instead.'
           @__unique_job_warned = true
         end
       end

data/lib/resque-loner/version.rb

@@ -1,7 +1,7 @@
 module Resque
   module Plugins
     module Loner
-      VERSION = "1.2.1"
+      VERSION = '1.3.0'
     end
   end
 end

data/resque-loner.gemspec

@@ -5,46 +5,55 @@ $:.unshift lib unless $:.include?(lib)
 require 'resque-loner/version'
 
 Gem::Specification.new do |s|
-  s.name        = 'resque-loner'
-  s.version     = Resque::Plugins::Loner::VERSION
-  s.platform    = Gem::Platform::RUBY
-  s.authors     = ['Jannis Hermanns']
-  s.email       = ['jannis@moviepilot.com']
-  s.homepage    = 'http://github.com/jayniz/resque-loner'
-  s.summary     = 'Adds unique jobs to resque'
-  s.has_rdoc    = false
+  s.name = 'resque-loner'
+  s.version = Resque::Plugins::Loner::VERSION
+  s.platform = Gem::Platform::RUBY
+  s.authors = ['Jannis Hermanns']
+  s.email = ['jannis@moviepilot.com']
+  s.homepage = 'http://github.com/jayniz/resque-loner'
+  s.summary = 'Adds unique jobs to resque'
+  s.has_rdoc = false
+  s.license = 'MIT'
 
   s.rubyforge_project = 'resque-loner'
 
   s.add_dependency 'resque', '~>1.0'
-  {
-    'rake'                => '> 0.8.7',
-    'rack-test'           => '~> 0.5.7',
-    'rspec'               => '~> 2.5.0',
-    'mock_redis'          => '~> 0.2.0',
-    'yajl-ruby'           => '~> 0.8.2'
-  }.each do |lib, version|
-    s.add_development_dependency lib, version
-  end
 
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.require_paths = ["lib"]
+  %w(
+    airbrake
+    i18n
+    mocha
+    mock_redis
+    rack-test
+    rake
+    rspec
+    rubocop
+    simplecov
+    yajl-ruby
+  ).each do |gemname|
+    s.add_development_dependency gemname
+  end
 
-  s.description = <<desc
-Makes sure that for special jobs, there can be only one job with the same workload in one queue.
+  s.executables = `git ls-files -z -- bin/*`.split("\0").map do
+    |f| File.basename(f)
+  end
+  s.files = `git ls-files -z`.split("\0")
+  s.test_files = `git ls-files -z -- {test,spec,features}/*`.split("\0")
+  s.require_paths = ['lib']
 
-Example:
-    class CacheSweeper 
+  s.description = <<-EODESC.gsub(/^ {4}/, '')
+    Makes sure that for special jobs, there can be only one job with the same
+    workload in one queue.
 
-       include Resque::Plugins::UniqueJob
+    Example:
+        class CacheSweeper
+           include Resque::Plugins::UniqueJob
 
-       @queue = :cache_sweeps
+           @queue = :cache_sweeps
 
-       def self.perform(article_id)
-         # Cache Me If You Can...
-       end
-    end
-desc
+           def self.perform(article_id)
+             # Cache Me If You Can...
+           end
+        end
+  EODESC
 end

data/spec/loner_spec.rb

@@ -1,6 +1,5 @@
 require 'spec_helper'
 
-
 #
 #  Resque-loner specific specs. I'm shooting right through the stack here and just
 #  test the outcomes, because the implementation will change soon and the tests run
@@ -11,10 +10,8 @@ class SomeJob
   @queue = :some_queue
 end
 
-class SomeUniqueJob 
-
+class SomeUniqueJob
   include Resque::Plugins::UniqueJob
-
   @queue = :other_queue
   def self.perform(foo); end
 end
@@ -23,12 +20,11 @@ class FailingUniqueJob
   include Resque::Plugins::UniqueJob
   @queue = :other_queue
   def self.perform(foo)
-    raise "I beg to differ"
+    fail 'I beg to differ'
   end
 end
 
 class DeprecatedUniqueJob < Resque::Plugins::Loner::UniqueJob
-
   @queue = :other_queue
   def self.perform(foo); end
 end
@@ -37,11 +33,17 @@ class UniqueJobWithTtl
   include Resque::Plugins::UniqueJob
   @queue = :unique_with_ttl
   @loner_ttl = 300
+  def self.perform(*args); end
+end
 
+class UniqueJobWithLockAfterExecution
+  include Resque::Plugins::UniqueJob
+  @queue = :unique_with_loner_lock_after_execution_period
+  @loner_lock_after_execution_period = 150
   def self.perform(*args); end
 end
 
-describe "Resque" do
+describe 'Resque' do
 
   before(:each) do
     Resque.redis.flushall
@@ -49,107 +51,107 @@ describe "Resque" do
     Resque.size(:some_queue).should == 0
   end
 
-  describe "Jobs" do
-    it "can put multiple normal jobs on a queue" do
-      Resque.enqueue SomeJob, "foo"
-      Resque.enqueue SomeJob, "foo"
+  describe 'Jobs' do
+    it 'can put multiple normal jobs on a queue' do
+      Resque.enqueue SomeJob, 'foo'
+      Resque.enqueue SomeJob, 'foo'
       Resque.size(:some_queue).should == 2
     end
 
-    it "should allow only one of the same job to sit in a queue" do
-      Resque.enqueue SomeUniqueJob, "foo"
-      Resque.enqueue SomeUniqueJob, "foo"
+    it 'should allow only one of the same job to sit in a queue' do
+      Resque.enqueue SomeUniqueJob, 'foo'
+      Resque.enqueue SomeUniqueJob, 'foo'
       Resque.size(:other_queue).should == 1
     end
 
-    it "should support deprecated Resque::Plugins::Loner::UniqueJob class" do
-      Resque.enqueue DeprecatedUniqueJob, "foo"
-      Resque.enqueue DeprecatedUniqueJob, "foo"
+    it 'should support deprecated Resque::Plugins::Loner::UniqueJob class' do
+      Resque.enqueue DeprecatedUniqueJob, 'foo'
+      Resque.enqueue DeprecatedUniqueJob, 'foo'
       Resque.size(:other_queue).should == 1
     end
 
-    it "should allow the same jobs to be executed one after the other" do
-      Resque.enqueue SomeUniqueJob, "foo"
-      Resque.enqueue SomeUniqueJob, "foo"
+    it 'should allow the same jobs to be executed one after the other' do
+      Resque.enqueue SomeUniqueJob, 'foo'
+      Resque.enqueue SomeUniqueJob, 'foo'
       Resque.size(:other_queue).should == 1
 
       Resque.reserve(:other_queue)
       Resque.size(:other_queue).should == 0
 
-      Resque.enqueue SomeUniqueJob, "foo"
-      Resque.enqueue SomeUniqueJob, "foo"
+      Resque.enqueue SomeUniqueJob, 'foo'
+      Resque.enqueue SomeUniqueJob, 'foo'
       Resque.size(:other_queue).should == 1
     end
 
-    it "should be robust regarding hash attributes" do
-      Resque.enqueue SomeUniqueJob, :bar => 1, :foo => 2
-      Resque.enqueue SomeUniqueJob, :foo => 2, :bar => 1
+    it 'should be robust regarding hash attributes' do
+      Resque.enqueue SomeUniqueJob, bar: 1, foo: 2
+      Resque.enqueue SomeUniqueJob, foo: 2, bar: 1
       Resque.size(:other_queue).should == 1
     end
 
-    it "should be robust regarding hash attributes (JSON does not distinguish between string and symbol)" do
-      Resque.enqueue SomeUniqueJob, :bar => 1, :foo  => 1
-      Resque.enqueue SomeUniqueJob, :bar => 1, "foo" => 1
+    it 'should be robust regarding hash attributes (JSON does not distinguish between string and symbol)' do
+      Resque.enqueue SomeUniqueJob, bar: 1, foo: 1
+      Resque.enqueue SomeUniqueJob, :bar => 1, 'foo' => 1
       Resque.size(:other_queue).should == 1
     end
 
-    it "should mark jobs as unqueued, when Job.destroy is killing them" do
-      Resque.enqueue SomeUniqueJob, "foo"
-      Resque.enqueue SomeUniqueJob, "foo"
+    it 'should mark jobs as unqueued, when Job.destroy is killing them' do
+      Resque.enqueue SomeUniqueJob, 'foo'
+      Resque.enqueue SomeUniqueJob, 'foo'
       Resque.size(:other_queue).should == 1
 
       Resque::Job.destroy(:other_queue, SomeUniqueJob)
       Resque.size(:other_queue).should == 0
 
-      Resque.enqueue SomeUniqueJob, "foo"
-      Resque.enqueue SomeUniqueJob, "foo"
+      Resque.enqueue SomeUniqueJob, 'foo'
+      Resque.enqueue SomeUniqueJob, 'foo'
       Resque.size(:other_queue).should == 1
     end
 
-    it "should mark jobs as unqueued, when they raise an exception during #perform" do
-      2.times { Resque.enqueue( FailingUniqueJob, "foo" ) }
+    it 'should mark jobs as unqueued, when they raise an exception during #perform' do
+      2.times { Resque.enqueue(FailingUniqueJob, 'foo') }
       Resque.size(:other_queue).should == 1
 
       worker = Resque::Worker.new(:other_queue)
       worker.work 0
       Resque.size(:other_queue).should == 0
 
-      2.times { Resque.enqueue( FailingUniqueJob, "foo" ) }
+      2.times { Resque.enqueue(FailingUniqueJob, 'foo') }
       Resque.size(:other_queue).should == 1
     end
 
-    it "should report if a job is queued or not" do
-      Resque.enqueue SomeUniqueJob, "foo"
-      Resque.enqueued?(SomeUniqueJob, "foo").should be_true
-      Resque.enqueued?(SomeUniqueJob, "bar").should be_false
+    it 'should report if a job is queued or not' do
+      Resque.enqueue SomeUniqueJob, 'foo'
+      Resque.enqueued?(SomeUniqueJob, 'foo').should be_true
+      Resque.enqueued?(SomeUniqueJob, 'bar').should be_false
     end
 
-    it "should report if a job is in a special queue or not" do
+    it 'should report if a job is in a special queue or not' do
       default_queue = SomeUniqueJob.instance_variable_get(:@queue)
       SomeUniqueJob.instance_variable_set(:@queue, :special_queue)
 
-      Resque.enqueue SomeUniqueJob, "foo"
-      Resque.enqueued_in?( :special_queue, SomeUniqueJob, "foo").should be_true
+      Resque.enqueue SomeUniqueJob, 'foo'
+      Resque.enqueued_in?(:special_queue, SomeUniqueJob, 'foo').should be_true
 
       SomeUniqueJob.instance_variable_set(:@queue, default_queue)
 
-      Resque.enqueued?( SomeUniqueJob, "foo").should be_false
+      Resque.enqueued?(SomeUniqueJob, 'foo').should be_false
     end
 
-    it "should not be able to report if a non-unique job was enqueued" do
+    it 'should not be able to report if a non-unique job was enqueued' do
       Resque.enqueued?(SomeJob).should be_nil
     end
 
-    it "should cleanup all loners when a queue is destroyed" do
-      Resque.enqueue SomeUniqueJob, "foo"
-      Resque.enqueue FailingUniqueJob, "foo"
+    it 'should cleanup all loners when a queue is destroyed' do
+      Resque.enqueue SomeUniqueJob, 'foo'
+      Resque.enqueue FailingUniqueJob, 'foo'
 
       Resque.remove_queue(:other_queue)
 
-      Resque.enqueue(SomeUniqueJob, "foo")
+      Resque.enqueue(SomeUniqueJob, 'foo')
       Resque.size(:other_queue).should == 1
     end
-    
+
     it 'should not raise an error when deleting an already empty queue' do
       expect { Resque.remove_queue(:other_queue) }.to_not raise_error
     end
@@ -157,9 +159,29 @@ describe "Resque" do
     it 'should honor loner_ttl in the redis key' do
       Resque.enqueue UniqueJobWithTtl
       Resque.enqueued?(UniqueJobWithTtl).should be_true
-      k=Resque.redis.keys "loners:queue:unique_with_ttl:job:*"
+      k = Resque.redis.keys 'loners:queue:unique_with_ttl:job:*'
       k.length.should == 1
       Resque.redis.ttl(k[0]).should be_within(2).of(UniqueJobWithTtl.loner_ttl)
     end
+
+    it 'should not allow the same job to be enqueued after execution if loner_lock_after_execution_period is set' do
+      Resque.enqueue UniqueJobWithLockAfterExecution, 'foo'
+      Resque.enqueue UniqueJobWithLockAfterExecution, 'foo'
+      Resque.size(:unique_with_loner_lock_after_execution_period).should == 1
+
+      Resque.reserve(:unique_with_loner_lock_after_execution_period)
+      Resque.size(:unique_with_loner_lock_after_execution_period).should == 0
+
+      Resque.enqueue UniqueJobWithLockAfterExecution, 'foo'
+      Resque.size(:unique_with_loner_lock_after_execution_period).should == 0
+    end
+
+    it 'should honor loner_lock_after_execution_period in the redis key' do
+      Resque.enqueue UniqueJobWithLockAfterExecution
+      Resque.reserve(:unique_with_loner_lock_after_execution_period)
+      k = Resque.redis.keys 'loners:queue:unique_with_loner_lock_after_execution_period:job:*'
+      k.length.should == 1
+      Resque.redis.ttl(k[0]).should be_within(2).of(UniqueJobWithLockAfterExecution.loner_lock_after_execution_period)
+    end
   end
 end