resque-unique_at_runtime 2.0.1 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4df741e7e76af4475e15a3f2fd4a820bc64fb535
-  data.tar.gz: '05833f9f5ecea8a7513df2f8ebef479b52c3c5db'
+  metadata.gz: 3d3d6b55df9f56bfc4706242b0d7f1f6e47fae6d
+  data.tar.gz: 816c4042916af3a170e6af35b1978f4f2a3cc338
 SHA512:
-  metadata.gz: 7734660f78f5626ec08f83a36504b8e14d2019226b772463937cdba0b8645cddecf005ea7262dc313a8f38b97c0982579c244235c51219b6ebe337282060a133
-  data.tar.gz: 857a0e636da5f0ea235e0c73ca93c3a75794e440a6fb5226d1821bf7210060f44ac35ebf3478623ac4c61bb6b45e02a6da8c22b2b7450a69a75a6f92cb80509e
+  metadata.gz: c61abb7166768391285d3a0478a23d0b63564c134969cd099fd69c05b5cdd2f156aaf529b8b859e91bd40627beb258abb2b4c4d81ba2cc9e678314df92c8cce2
+  data.tar.gz: d900c6c92ad2cf28f94872ae014044b821ec488b974e78428bfdcec3cfc81ed3c069d93211cdccf06d625b0e47242d7c45a332a326d6291b65a0ffdfbf6108d7

data/.travis.yml

@@ -1,5 +1,5 @@
 language: ruby
 rvm:
-  - 1.9.3
-  - 2.0.0
-  - 2.1.0
+  - 2.2.8
+  - 2.3.5
+  - 2.4.2

data/README.md

@@ -165,7 +165,7 @@ 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
+This can be customized using a ```@runtime_requeue_interval``` class instance variable
 in your job like so:
 
 
@@ -175,7 +175,7 @@ in your job like so:
       extend Resque::Plugins::UniqueAtRuntime
 
       @queue = :serial_work
-      @requeue_interval = 5         # sleep for 5 seconds before requeueing
+      @runtime_requeue_interval = 5         # sleep for 5 seconds before requeueing
 
       def self.perform
         # some implementation

data/lib/resque-unique_at_runtime/version.rb

@@ -1,7 +1,7 @@
 module Resque
   module Plugins
     module UniqueAtRuntime
-      VERSION = "2.0.1"
+      VERSION = "2.0.2"
     end
   end
 end

data/lib/resque-unique_at_runtime.rb

@@ -3,62 +3,86 @@ require 'resque-unique_at_runtime/version'
 module Resque
   module Plugins
     module UniqueAtRuntime
-      LOCK_TIMEOUT = 60 * 60 * 24 * 5 # 5 days
+      def runtime_lock_timeout_at(now)
+        now + runtime_lock_timeout + 1
+      end
 
-      def lock_timeout
-        Time.now.to_i + LOCK_TIMEOUT + 1
+      def runtime_lock_timeout
+        self.instance_variable_get(:@runtime_lock_timeout) || 60 * 60 * 24 * 5
       end
 
-      def requeue_interval
-        self.instance_variable_get(:@requeue_interval) || 1
+      def runtime_requeue_interval
+        self.instance_variable_get(:@runtime_requeue_interval) || 1
       end
 
       # Overwrite this method to uniquely identify which mutex should be used
       # for a resque worker.
       def unique_at_runtime_redis_key(*_)
-        "unique_at_runtime:#{@queue}"
+        puts "resque-unique_at_runtime: getting key for #{@queue}!" if ENV['RESQUE_DEBUG']
+        "resque-unique_at_runtime:#{@queue}"
       end
 
       def can_lock_queue?(*args)
+        queue_locked?(*args) == false ? true : false
+      end
+      
+      def queue_locked?(*args)
         now = Time.now.to_i
         key = unique_at_runtime_redis_key(*args)
-        timeout = lock_timeout
+        timeout = runtime_lock_timeout_at(now)
+
+        puts "resque-unique_at_runtime: attempting to lock queue with #{key}" if ENV['RESQUE_DEBUG']
 
         # Per http://redis.io/commands/setnx
-        return true  if Resque.redis.setnx(key, timeout)
-        return false if Resque.redis.get(key).to_i > now
-        return true  if Resque.redis.getset(key, timeout).to_i <= now
-        return false
+        return false if Resque.redis.setnx(key, timeout)
+        return key if Resque.redis.get(key).to_i > now
+        return false if Resque.redis.getset(key, timeout).to_i <= now
+        return key
       end
 
       def unlock_queue(*args)
-        Resque.redis.del(unique_at_runtime_redis_key(*args))
+        key = unique_at_runtime_redis_key(*args)
+        puts "resque-unique_at_runtime: unlock queue with #{key}" if ENV['RESQUE_DEBUG']
+        Resque.redis.del(key)
       end
 
       def reenqueue(*args)
         Resque.enqueue(self, *args)
       end
 
-      def before_perform(*args)
-        unless can_lock_queue?(*args)
+      def before_perform_lock_runtime(*args)
+        if (key = queue_locked?(*args))
+          puts "resque-unique_at_runtime: failed to lock queue with #{key}" if ENV['RESQUE_DEBUG']
+
           # Sleep so the CPU's rest
-          sleep(requeue_interval)
+          sleep(runtime_requeue_interval)
 
           # can't get the lock, so re-enqueue the task
           reenqueue(*args)
 
           # and don't perform
           raise Resque::Job::DontPerform
+        else
+          puts "will perform"
+          true
         end
       end
 
-      def around_perform(*args)
+      def around_perform_unlock_runtime(*args)
         begin
           yield
         ensure
           unlock_queue(*args)
         end
       end
+      
+      # There may be scenarios where the around_perform's ensure unlock 
+      #   duplicates the on_failure unlock, but that's a small price to pay for 
+      #   uniqueness.
+      def on_failure_unlock_runtime(*args)
+        puts "resque-unique_at_runtime: on failure unlock" if ENV['RESQUE_DEBUG']
+        unlock_queue(*args)
+      end
     end
   end
 end

data/spec/lib/unique_at_runtime_spec.rb

@@ -23,14 +23,14 @@ describe Resque::Plugins::UniqueAtRuntime do
     Resque.redis.flushall
   end
 
-  describe ".requeue_interval" do
+  describe ".runtime_requeue_interval" do
     it "should default to 5" do
-      expect(SerialJob.requeue_interval).to eql(1)
+      expect(SerialJob.runtime_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)
+      SerialJob.instance_variable_set(:@runtime_requeue_interval, 5)
+      expect(SerialJob.runtime_requeue_interval).to eql(5)
     end
   end
 
@@ -78,7 +78,7 @@ describe Resque::Plugins::UniqueAtRuntime do
 
   describe ".perform" do
     before do
-      SerialJob.instance_variable_set(:@requeue_interval, 0)
+      SerialJob.instance_variable_set(:@runtime_requeue_interval, 0)
     end
 
     describe "using the default redis key" do
@@ -86,7 +86,7 @@ describe Resque::Plugins::UniqueAtRuntime 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
-        expect(SerialJob).to receive(:can_lock_queue?).and_return(true)
+        expect(SerialJob).to receive(:queue_locked?).and_return(false)
 
         # but it should also clean up after itself
         expect(SerialJob).to receive(:unlock_queue)
@@ -98,13 +98,13 @@ describe Resque::Plugins::UniqueAtRuntime 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
-        expect(SerialJob).to receive(:can_lock_queue?).and_return(true)
+        expect(SerialJob).to receive(:queue_locked?).and_return(false)
 
         # but we have a catastrophic job failure
         expect(SerialJob).to receive(:perform).and_raise(Exception)
 
         # and still it should clean up after itself
-        expect(SerialJob).to receive(:unlock_queue)
+        expect(SerialJob).to receive(:unlock_queue).at_least(1).times
 
         # unfortunately, the job will be lost but resque doesn't guarantee jobs
         # aren't lost
@@ -117,7 +117,7 @@ describe Resque::Plugins::UniqueAtRuntime do
         Resque::Job.create(:serial_work, 'SerialJob', job1_payload)
         Resque::Job.create(:serial_work, 'SerialJob', job2_payload)
 
-        expect(SerialJob).to receive(:can_lock_queue?).and_return(false)
+        expect(SerialJob).to receive(:queue_locked?).and_return(true)
 
         # perform returns false when DontPerform exception is raised in
         # before_perform callback
@@ -134,7 +134,7 @@ describe Resque::Plugins::UniqueAtRuntime 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
-        expect(SerialJobWithCustomRedisKey).to receive(:can_lock_queue?).and_return(true)
+        expect(SerialJobWithCustomRedisKey).to receive(:queue_locked?).and_return(false)
 
         # but it should also clean up after itself
         expect(SerialJobWithCustomRedisKey).to receive(:unlock_queue)
@@ -146,13 +146,13 @@ describe Resque::Plugins::UniqueAtRuntime 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
-        expect(SerialJobWithCustomRedisKey).to receive(:can_lock_queue?).and_return(true)
+        expect(SerialJobWithCustomRedisKey).to receive(:queue_locked?).and_return(false)
 
         # but we have a catastrophic job failure
         expect(SerialJobWithCustomRedisKey).to receive(:perform).and_raise(Exception)
 
         # and still it should clean up after itself
-        expect(SerialJobWithCustomRedisKey).to receive(:unlock_queue)
+        expect(SerialJobWithCustomRedisKey).to receive(:unlock_queue).at_least(1).times
 
         # unfortunately, the job will be lost but resque doesn't guarantee jobs
         # aren't lost
@@ -165,7 +165,7 @@ describe Resque::Plugins::UniqueAtRuntime do
         Resque::Job.create(:serial_work, 'SerialJobWithCustomRedisKey', job1_payload)
         Resque::Job.create(:serial_work, 'SerialJobWithCustomRedisKey', job2_payload)
 
-        expect(SerialJobWithCustomRedisKey).to receive(:can_lock_queue?).and_return(false)
+        expect(SerialJobWithCustomRedisKey).to receive(:queue_locked?).and_return(true)
 
         # perform returns false when DontPerform exception is raised in
         # before_perform callback

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: resque-unique_at_runtime
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.0.2
 platform: ruby
 authors:
 - Peter H. Boling
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-10-01 00:00:00.000000000 Z
+date: 2017-11-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: resque