resque-lonely_job 0.0.1 → 0.0.2

data/README.md

@@ -1,14 +1,15 @@
 # Resque::LonelyJob
 
-A [Resque](https://github.com/defunkt/resque) plugin. Requires Resque 1.20.0.
+A [Resque](https://github.com/defunkt/resque) plugin. Requires Resque >= 1.20.0.
 
 Ensures that for a given queue, only one worker is working on a job at any given
-time.  
+time.
 
 This differs from [resque-lock](from https://github.com/defunkt/resque-lock) and
 [resque-loner](http://github.com/jayniz/resque-loner) in that the same job may
 be queued multiple times but you're guaranteed that first job queued will run to
-completion before subsequent jobs are run. 
+completion before subsequent jobs are run.  In other words, job ordering is
+preserved.
 
 ## Installation
 
@@ -26,7 +27,7 @@ Or install it yourself as:
 
 ## Usage
 
-Example #1:
+#### Example #1
 
     require 'resque/plugins/lonely_job'
 
@@ -41,7 +42,9 @@ Example #1:
       end
     end
 
-Example #2: Let's say you want the serial constraint to apply at a more granular
+#### Example #2
+
+Let's say you want the serial constraint to apply at a more granular
 level.  Instead of applying at the queue level, you can overwrite the .redis\_key
 method.
 
@@ -61,9 +64,40 @@ method.
 
       def self.perform(account_id, *args)
         # only one at a time in this block, no parallelism allowed for this
-        # particular queue
+        # particular redis_key
       end
     end
+
+*NOTE*: Without careful consideration of your problem domain, worker starvation
+and/or unfairness is possible for jobs in this example.  Imagine a scenario
+where you have three jobs in the queue with two resque workers:
+
+    +---------------------------------------------------+
+    | :serial_work                                      |
+    |---------------------------------------------------|
+    |             |             |             |         |
+    | redis_key:  | redis_key:  | redis_key:  | ...     |
+    |    A        |    A        |    B        |         |
+    |             |             |             |         |
+    | job 1       | job 2       | job 3       |         |
+    +---------------------------------------------------+
+                                      ^
+                                      |
+      Possible starvation +-----------+
+      for this job and
+      subsequent ones
+
+
+  When the first worker grabs job 1, it'll acquire the mutex for processing
+  redis\_key A.  The second worker tries to grab the next job off the queue but
+  is unable to acquire the mutex for redis\_key A so it places job 2 back at the
+  head of the :serial\_work queue.  Until worker 1 completes job 1 and releases
+  the mutex for redis\_key A, no work will be done in this queue.
+
+  This issue may be avoided by employing dynamic queues,
+  http://blog.kabisa.nl/2010/03/16/dynamic-queue-assignment-for-resque-jobs/,
+  where the queue is a one to one mapping to the redis\_key.
+
 ## Contributing
 
 1. Fork it

data/lib/resque-lonely_job/version.rb

@@ -1,7 +1,7 @@
 module Resque
   module Plugins
     module LonelyJob
-      VERSION = "0.0.1"
+      VERSION = "0.0.2"
     end
   end
 end

data/lib/resque-lonely_job.rb

@@ -23,10 +23,18 @@ module Resque
         Resque.redis.del(redis_key(*args))
       end
 
+      # Unfortunately, there's not a Resque interface for lpush so we have to
+      # role our own.  This is based on Resque.push but we don't need to
+      # call Resque.watch_queue as the queue should already exist if we're
+      # unable to get the lock.
+      def lpush(*args)
+        Resque.redis.lpush("queue:#{Resque.queue_from_class(self)}", Resque.encode(class: self, args: args))
+      end
+
       def before_perform(*args)
         unless can_lock_queue?(*args)
-          # can't get the lock, so place self at the end of the queue
-          Resque.enqueue(self, *args)
+          # can't get the lock, so place at the front of the queue
+          lpush(*args)
 
           # and don't perform
           raise Resque::Job::DontPerform

data/spec/lib/lonely_job_spec.rb

@@ -65,18 +65,19 @@ describe Resque::Plugins::LonelyJob do
         -> { job.perform }.should raise_error(Exception)
       end
 
-      it 'should place self at the end of the queue if unable to acquire the lock' do
-        Resque.size(:serial_work).should == 0
-
-        job = Resque::Job.new(:serial_work, { 'class' => 'SerialJob', 'args' => %w[account_one job_one] })
+      it 'should place self at the beginning of the queue if unable to acquire the lock' do
+        job1 = Resque::Job.create(:serial_work, 'SerialJob', %w[account_one job_one])
+        job2 = Resque::Job.create(:serial_work, 'SerialJob', %w[account_one job_two])
 
         SerialJob.should_receive(:can_lock_queue?).and_return(false)
 
         # perform returns false when DontPerform exception is raised in
         # before_perform callback
-        job.perform.should be_false
+        job1 = Resque.reserve(:serial_work)
+        job1.perform.should be_false
 
-        Resque.size(:serial_work).should == 1
+        first_queue_element = Resque.reserve(:serial_work)
+        first_queue_element.should == job1
       end
     end
 
@@ -110,18 +111,19 @@ describe Resque::Plugins::LonelyJob do
         -> { job.perform }.should raise_error(Exception)
       end
 
-      it 'should place self at the end of the queue if unable to acquire the lock' do
-        Resque.size(:serial_work).should == 0
-
-        job = Resque::Job.new(:serial_work, { 'class' => 'SerialJobWithCustomRedisKey', 'args' => %w[account_one job_one] })
+      it 'should place self at the beginning of the queue if unable to acquire the lock' do
+        job1 = Resque::Job.create(:serial_work, 'SerialJobWithCustomRedisKey', %w[account_one job_one])
+        job2 = Resque::Job.create(:serial_work, 'SerialJobWithCustomRedisKey', %w[account_one job_two])
 
         SerialJobWithCustomRedisKey.should_receive(:can_lock_queue?).and_return(false)
 
         # perform returns false when DontPerform exception is raised in
         # before_perform callback
-        job.perform.should be_false
+        job1 = Resque.reserve(:serial_work)
+        job1.perform.should be_false
 
-        Resque.size(:serial_work).should == 1
+        first_queue_element = Resque.reserve(:serial_work)
+        first_queue_element.should == job1
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: resque-lonely_job
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-21 00:00:00.000000000 Z
+date: 2012-05-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: resque
-  requirement: &70323053547940 !ruby/object:Gem::Requirement
+  requirement: &70163618247460 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: 1.20.0
   type: :runtime
   prerelease: false
-  version_requirements: *70323053547940
+  version_requirements: *70163618247460
 - !ruby/object:Gem::Dependency
   name: mock_redis
-  requirement: &70323053547380 !ruby/object:Gem::Requirement
+  requirement: &70163618260080 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: 0.4.1
   type: :runtime
   prerelease: false
-  version_requirements: *70323053547380
+  version_requirements: *70163618260080
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70323053546980 !ruby/object:Gem::Requirement
+  requirement: &70163618269840 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70323053546980
+  version_requirements: *70163618269840
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70323053546520 !ruby/object:Gem::Requirement
+  requirement: &70163618268580 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,7 +54,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70323053546520
+  version_requirements: *70163618268580
 description: ! "Ensures that for a given queue, only one worker is working on a job
   at any given time.\n\nExample:\n\n  require 'resque/plugins/lonely_job'\n\n  class
   StrictlySerialJob\n    extend Resque::Plugins::LonelyJob\n\n    @queue = :serial_work\n\n