resque-lonely_job 1.0.2 → 1.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 83362de6a98d68ae3f20fd8e7cd0cb11fff06be7
-  data.tar.gz: 829b8cc700dbfda2772cd3c15f3df8ab1fd7deed
+  metadata.gz: 385d9088e5dcf459dc861e253a7311171ed99081
+  data.tar.gz: c3670738b0a5913dd7b1eb7351f05c8c73028ce2
 SHA512:
-  metadata.gz: b9bfed33191b4010235ca4eec4b141a33b5cdfd81162823b46b044de4bfe13a9b469e85b1904f836d95ddd5b6ee65831297e18ede0281af896d5122402f1d52c
-  data.tar.gz: 9d38553d777a2a8fe93b2f421f2cd21dfcd56dd0ed8c8a04cd1357d983aa2c85a7468347f955db00f761a5cbda9c1241302631b61a5eb8768083c724e7ac2a5d
+  metadata.gz: 7967576ae3331cb0fde89d639dd81a93f54cab0d53f8bbd5f7e48815b10ac5363bd8c22171c45d2dbd934710deb0db9d90884a8778c2982798818edc4cfcfa2f
+  data.tar.gz: f731d546913937b970112aea7fdde0971e42cbcf7ae9b0c8d4deade8c97c58002930e3d7be1922f5d1d09d7dc1ce054fc2718cbe515f1b58590cc8f4aaf14422

data/README.md

@@ -2,15 +2,9 @@
 
 [![Build Status](https://travis-ci.org/wallace/resque-lonely_job.png)](https://travis-ci.org/wallace/resque-lonely\_job)
 
-A [Resque](https://github.com/resque/resque) plugin that implements [Semantic
-Versioning](http://semver.org/).
-
-Version 1.x Requires Resque >= 1.20.0 and < 1.25.0.
-
-Requires a version of MRI Ruby >= 1.9.3.
-
-Ensures that for a given queue, only one worker is working on a job at any given
-time.
+A [semanticaly versioned](http://semver.org/)
+[Resque](https://github.com/resque/resque) plugin which ensures for a given
+queue, that only one worker is working on a job at any given time.
 
 Resque::LonelyJob differs from [resque-queue-lock](https://github.com/mashion/resque-queue-lock), [resque-lock](https://github.com/defunkt/resque-lock) and
 [resque-loner](http://github.com/jayniz/resque-loner) in that the same job may
@@ -26,6 +20,12 @@ ordering but introduces the possibility of starvation.)
 Therefore it is recommended that the payload for jobs be stored in a separate
 redis list distinct from the Resque queue (see Example #3).
 
+## Requirements
+
+Version 1.x Requires Resque >= 1.20.0 and < 1.25.0.
+
+Requires a version of MRI Ruby >= 1.9.3.
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -153,6 +153,32 @@ It now doesn't matter whether job 1 and job 2 are re-ordered as whichever goes
 first will perform an atomic pop on the redis list that contains the data needed
 for its job (data x, data y, data z).
 
+#### Example #4 -- Requeue interval
+
+The behavior when multiple jobs exist in a queue protected by resque-lonely_job
+is for one job to be worked, while the other is continuously dequeued and
+requeued until the first job is finished.  This can result in that worker
+process pegging a CPU/core on a worker server.  To guard against this, the
+default behavior is to sleep for 1 second before the requeue, which will allow
+the cpu to perform other work.
+
+This can be customized using a ```@requeue_interval``` class instance variable
+in your job like so:
+
+
+    require 'resque-lonely_job'
+
+    class StrictlySerialJob
+      extend Resque::Plugins::LonelyJob
+
+      @queue = :serial_work
+      @requeue_interval = 5         # sleep for 5 seconds before requeueing
+
+      def self.perform
+        # some implementation
+      end
+    end
+
 ## Contributing
 
 1. Fork it

data/lib/resque-lonely_job.rb

@@ -9,6 +9,10 @@ module Resque
         Time.now.to_i + LOCK_TIMEOUT + 1
       end
 
+      def requeue_interval
+        self.instance_variable_get(:@requeue_interval) || 1
+      end
+
       # Overwrite this method to uniquely identify which mutex should be used
       # for a resque worker.
       def redis_key(*args)
@@ -37,6 +41,9 @@ module Resque
 
       def before_perform(*args)
         unless can_lock_queue?(*args)
+          # Sleep so the CPU's rest
+          sleep(requeue_interval)
+
           # can't get the lock, so re-enqueue the task
           reenqueue(*args)
 

data/lib/resque-lonely_job/version.rb

@@ -1,7 +1,7 @@
 module Resque
   module Plugins
     module LonelyJob
-      VERSION = "1.0.2"
+      VERSION = "1.1.3"
     end
   end
 end

data/resque-lonely_job.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |gem|
   gem.add_dependency 'resque', '>= 1.2'
   gem.add_development_dependency 'mock_redis'
   gem.add_development_dependency 'rake'
-  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'rspec', '>= 3.0'
   gem.add_development_dependency 'timecop'
 
   gem.description   = <<desc

data/spec/lib/lonely_job_spec.rb

@@ -23,33 +23,44 @@ describe Resque::Plugins::LonelyJob do
     Resque.redis.flushall
   end
 
+  describe ".requeue_interval" do
+    it "should default to 5" do
+      expect(SerialJob.requeue_interval).to eql(1)
+    end
+
+    it "should be overridable with a class instance var" do
+      SerialJob.instance_variable_set(:@requeue_interval, 5)
+      expect(SerialJob.requeue_interval).to eql(5)
+    end
+  end
+
   describe ".can_lock_queue?" do
     it 'can lock a queue' do
-      SerialJob.can_lock_queue?(:serial_work).should be_true
+      expect(SerialJob.can_lock_queue?(:serial_work)).to eql(true)
     end
 
     it 'cannot lock an already locked queue' do
-      SerialJob.can_lock_queue?(:serial_work).should be_true
-      SerialJob.can_lock_queue?(:serial_work).should be_false
+      expect(SerialJob.can_lock_queue?(:serial_work)).to eql(true)
+      expect(SerialJob.can_lock_queue?(:serial_work)).to eql(false)
     end
 
     it 'cannot lock a queue with active lock' do
-      SerialJob.can_lock_queue?(:serial_work).should be_true
+      expect(SerialJob.can_lock_queue?(:serial_work)).to eql(true)
       Timecop.travel(Date.today + 1) do
-        SerialJob.can_lock_queue?(:serial_work).should be_false
+        expect(SerialJob.can_lock_queue?(:serial_work)).to eql(false)
       end
     end
 
     it 'can relock a queue with expired lock' do
-      SerialJob.can_lock_queue?(:serial_work).should be_true
+      expect(SerialJob.can_lock_queue?(:serial_work)).to eql(true)
 
       Timecop.travel(Date.today + 10) do
-        SerialJob.can_lock_queue?(:serial_work).should be_true
+        expect(SerialJob.can_lock_queue?(:serial_work)).to eql(true)
       end
     end
 
     it 'solves race condition with getset' do
-      SerialJob.can_lock_queue?(:serial_work).should be_true
+      expect(SerialJob.can_lock_queue?(:serial_work)).to eql(true)
 
       Timecop.travel(Date.today + 10) do
         threads = (1..10).to_a.map {
@@ -60,21 +71,25 @@ describe Resque::Plugins::LonelyJob do
 
         # Only one worker should acquire lock
         locks = threads.map {|t| t.join; t[:locked] }
-        locks.count(true).should == 1
+        expect(locks.count(true)).to eql(1)
       end
     end
   end
 
   describe ".perform" do
+    before do
+      SerialJob.instance_variable_set(:@requeue_interval, 0)
+    end
+
     describe "using the default redis key" do
       it 'should lock and unlock the queue' do
         job = Resque::Job.new(:serial_work, { 'class' => 'SerialJob', 'args' => %w[account_one job_one] })
 
         # job is the first SerialJob to run so it can lock the queue and perform
-        SerialJob.should_receive(:can_lock_queue?).and_return(true)
+        expect(SerialJob).to receive(:can_lock_queue?).and_return(true)
 
         # but it should also clean up after itself
-        SerialJob.should_receive(:unlock_queue)
+        expect(SerialJob).to receive(:unlock_queue)
 
         job.perform
       end
@@ -83,17 +98,17 @@ describe Resque::Plugins::LonelyJob do
         job = Resque::Job.new(:serial_work, { 'class' => 'SerialJob', 'args' => %w[account_one job_one] })
 
         # job is the first SerialJob to run so it can lock the queue and perform
-        SerialJob.should_receive(:can_lock_queue?).and_return(true)
+        expect(SerialJob).to receive(:can_lock_queue?).and_return(true)
 
         # but we have a catastrophic job failure
-        SerialJob.should_receive(:perform).and_raise(Exception)
+        expect(SerialJob).to receive(:perform).and_raise(Exception)
 
         # and still it should clean up after itself
-        SerialJob.should_receive(:unlock_queue)
+        expect(SerialJob).to receive(:unlock_queue)
 
         # unfortunately, the job will be lost but resque doesn't guarantee jobs
         # aren't lost
-        -> { job.perform }.should raise_error(Exception)
+        expect { job.perform }.to raise_error(Exception)
       end
 
       it 'should place self at the end of the queue if unable to acquire the lock' do
@@ -102,15 +117,15 @@ describe Resque::Plugins::LonelyJob do
         Resque::Job.create(:serial_work, 'SerialJob', job1_payload)
         Resque::Job.create(:serial_work, 'SerialJob', job2_payload)
 
-        SerialJob.should_receive(:can_lock_queue?).and_return(false)
+        expect(SerialJob).to receive(:can_lock_queue?).and_return(false)
 
         # perform returns false when DontPerform exception is raised in
         # before_perform callback
         job1 = Resque.reserve(:serial_work)
-        job1.perform.should be_false
+        expect(job1.perform).to eql(false)
 
         first_queue_element = Resque.reserve(:serial_work)
-        first_queue_element.payload["args"].should == [job2_payload]
+        expect(first_queue_element.payload["args"]).to eql([job2_payload])
       end
     end
 
@@ -119,10 +134,10 @@ describe Resque::Plugins::LonelyJob do
         job = Resque::Job.new(:serial_work, { 'class' => 'SerialJobWithCustomRedisKey', 'args' => %w[account_one job_one] })
 
         # job is the first SerialJobWithCustomRedisKey to run so it can lock the queue and perform
-        SerialJobWithCustomRedisKey.should_receive(:can_lock_queue?).and_return(true)
+        expect(SerialJobWithCustomRedisKey).to receive(:can_lock_queue?).and_return(true)
 
         # but it should also clean up after itself
-        SerialJobWithCustomRedisKey.should_receive(:unlock_queue)
+        expect(SerialJobWithCustomRedisKey).to receive(:unlock_queue)
 
         job.perform
       end
@@ -131,17 +146,17 @@ describe Resque::Plugins::LonelyJob do
         job = Resque::Job.new(:serial_work, { 'class' => 'SerialJobWithCustomRedisKey', 'args' => %w[account_one job_one] })
 
         # job is the first SerialJobWithCustomRedisKey to run so it can lock the queue and perform
-        SerialJobWithCustomRedisKey.should_receive(:can_lock_queue?).and_return(true)
+        expect(SerialJobWithCustomRedisKey).to receive(:can_lock_queue?).and_return(true)
 
         # but we have a catastrophic job failure
-        SerialJobWithCustomRedisKey.should_receive(:perform).and_raise(Exception)
+        expect(SerialJobWithCustomRedisKey).to receive(:perform).and_raise(Exception)
 
         # and still it should clean up after itself
-        SerialJobWithCustomRedisKey.should_receive(:unlock_queue)
+        expect(SerialJobWithCustomRedisKey).to receive(:unlock_queue)
 
         # unfortunately, the job will be lost but resque doesn't guarantee jobs
         # aren't lost
-        -> { job.perform }.should raise_error(Exception)
+        expect { job.perform }.to raise_error(Exception)
       end
 
       it 'should place self at the end of the queue if unable to acquire the lock' do
@@ -150,15 +165,15 @@ describe Resque::Plugins::LonelyJob do
         Resque::Job.create(:serial_work, 'SerialJobWithCustomRedisKey', job1_payload)
         Resque::Job.create(:serial_work, 'SerialJobWithCustomRedisKey', job2_payload)
 
-        SerialJobWithCustomRedisKey.should_receive(:can_lock_queue?).and_return(false)
+        expect(SerialJobWithCustomRedisKey).to receive(:can_lock_queue?).and_return(false)
 
         # perform returns false when DontPerform exception is raised in
         # before_perform callback
         job1 = Resque.reserve(:serial_work)
-        job1.perform.should be_false
+        expect(job1.perform).to eql(false)
 
         first_queue_element = Resque.reserve(:serial_work)
-        first_queue_element.payload["args"].should == [job2_payload]
+        expect(first_queue_element.payload["args"]).to eql([job2_payload])
       end
     end
   end

metadata

@@ -1,83 +1,83 @@
 --- !ruby/object:Gem::Specification
 name: resque-lonely_job
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.1.3
 platform: ruby
 authors:
 - Jonathan R. Wallace
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-10 00:00:00.000000000 Z
+date: 2014-08-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: resque
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.2'
 - !ruby/object:Gem::Dependency
   name: mock_redis
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: timecop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: |
@@ -103,8 +103,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .travis.yml
+- ".gitignore"
+- ".travis.yml"
 - Gemfile
 - LICENSE
 - README.md
@@ -124,17 +124,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: A resque plugin that ensures that only one job for a given queue will be