resque-unique_at_runtime 4.0.0 → 4.0.2

data/lib/resque/plugins/unique_at_runtime.rb

@@ -15,6 +15,16 @@ module Resque
     #   end
     #
     module UniqueAtRuntime
+      ATOMIC_LOCK_SCRIPT = <<~LUA
+        local previous_timeout = redis.call("HGET", KEYS[1], ARGV[1])
+        if previous_timeout and tonumber(previous_timeout) > tonumber(ARGV[3]) then
+          return 0
+        end
+        redis.call("HSET", KEYS[1], ARGV[1], ARGV[2])
+        return 1
+      LUA
+      LEGACY_LOCK_MUTEX = Mutex.new
+
       def self.included(base)
         base.extend ClassMethods
       end
@@ -26,24 +36,25 @@ module Resque
 
         def runtime_lock_timeout
           instance_variable_get(:@runtime_lock_timeout) ||
-              instance_variable_set(:@runtime_lock_timeout, Resque::UniqueAtRuntime.configuration&.lock_timeout)
+            instance_variable_set(:@runtime_lock_timeout, Resque::UniqueAtRuntime.configuration&.lock_timeout)
         end
 
         def runtime_requeue_interval
           instance_variable_get(:@runtime_requeue_interval) ||
-              instance_variable_set(:@runtime_requeue_interval, Resque::UniqueAtRuntime.configuration&.requeue_interval)
+            instance_variable_set(:@runtime_requeue_interval, Resque::UniqueAtRuntime.configuration&.requeue_interval)
         end
 
         def unique_at_runtime_key_base
           instance_variable_get(:@unique_at_runtime_key_base) ||
-              instance_variable_set(:@unique_at_runtime_key_base, Resque::UniqueAtRuntime.configuration&.unique_at_runtime_key_base)
+            instance_variable_set(:@unique_at_runtime_key_base, Resque::UniqueAtRuntime.configuration&.unique_at_runtime_key_base)
         end
 
         # Overwrite this method to uniquely identify which mutex should be used
         # for a resque worker.
         def unique_at_runtime_redis_key(*_)
-          Resque::UniqueAtRuntime.debug("getting key for #{@queue}!")
-          "#{unique_at_runtime_key_base}:#{@queue}"
+          queue = Resque.queue_from_class(self)
+          Resque::UniqueAtRuntime.debug("getting key for #{queue}!")
+          queue
         end
 
         # returns true if the job signature can be locked (is not currently locked)
@@ -59,18 +70,56 @@ module Resque
 
           Resque::UniqueAtRuntime.debug("attempting to lock queue with #{key}")
 
-          # Per http://redis.io/commands/setnx
-          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
+          case atomic_lock_result(key, timeout, now)
+          when 1
+            false
+          when 0
+            key
+          else
+            legacy_queue_locked(key, timeout, now)
+          end
+        end
+
+        private
+
+        def atomic_lock_result(key, timeout, now)
+          result = Resque.redis.eval(
+            Resque::Plugins::UniqueAtRuntime::ATOMIC_LOCK_SCRIPT,
+            [unique_at_runtime_key_base],
+            [key, timeout, now]
+          )
+          result&.to_i
+        rescue NoMethodError, NotImplementedError, Redis::CommandError
+          nil
+        end
+
+        # FakeRedis 0.9 exposes EVAL without implementing it. Keep the old
+        # command path for that test double and older Redis clients; the mutex
+        # only makes this compatibility path deterministic within one process.
+        def legacy_queue_locked(key, timeout, now)
+          Resque::Plugins::UniqueAtRuntime::LEGACY_LOCK_MUTEX.synchronize do
+            return false if Resque.redis.hsetnx(unique_at_runtime_key_base, key, timeout)
+
+            previous_timeout = Resque.redis.hget(unique_at_runtime_key_base, key).to_i
+            return key if previous_timeout > now
 
-          key
+            Resque.redis.hset(unique_at_runtime_key_base, key, timeout)
+            false
+          end
         end
 
+        public
+
         def unlock_queue(*args)
+          if @unlock_queue_executed
+            Resque::UniqueAtRuntime.debug("unlock queue already executed")
+            return
+          end
+
           key = unique_at_runtime_redis_key(*args)
           Resque::UniqueAtRuntime.debug("unlock queue with #{key}")
-          Resque.redis.del(key)
+          Resque.redis.hdel(unique_at_runtime_key_base, key)
+          @unlock_queue_executed = true
         end
 
         def reenqueue(*args)
@@ -90,12 +139,14 @@ module Resque
             # and don't perform
             raise Resque::Job::DontPerform
           else
-            Resque::UniqueAtRuntime.debug('check passed will perform')
+            Resque::UniqueAtRuntime.debug("check passed will perform")
             true
           end
         end
 
         def around_perform_unlock_runtime(*args)
+          @unlock_queue_executed = false
+
           yield
         ensure
           unlock_queue(*args)
@@ -105,7 +156,7 @@ module Resque
         #   duplicates the on_failure unlock, but that's a small price to pay for
         #   uniqueness.
         def on_failure_unlock_runtime(*args)
-          Resque::UniqueAtRuntime.debug('on failure unlock')
+          Resque::UniqueAtRuntime.debug("on failure unlock")
           unlock_queue(*args)
         end
       end

data/lib/resque/unique_at_runtime/configuration.rb

@@ -1,22 +1,22 @@
 # frozen_string_literal: true
 
-require 'logger'
+require "logger"
 module Resque
   module UniqueAtRuntime
     class Configuration
       DEFAULT_LOCK_TIMEOUT = 60 * 60 * 24 * 5
       DEFAULT_REQUEUE_INTERVAL = 1
-      DEFAULT_UNIQUE_AT_RUNTIME_KEY_BASE = 'r-uar'.freeze
+      DEFAULT_UNIQUE_AT_RUNTIME_KEY_BASE = "r-uar"
       DEFAULT_LOG_LEVEL = :debug
 
       include Singleton
 
       attr_accessor :debug_mode,
-                    :lock_timeout,
-                    :log_level,
-                    :logger,
-                    :requeue_interval,
-                    :unique_at_runtime_key_base
+        :lock_timeout,
+        :log_level,
+        :logger,
+        :requeue_interval,
+        :unique_at_runtime_key_base
 
       def initialize
         debug_mode_from_env
@@ -49,8 +49,8 @@ module Resque
       private
 
       def debug_mode_from_env
-        env_debug = ENV['RESQUE_DEBUG']
-        @debug_mode = !!(env_debug == 'true' || (env_debug.is_a?(String) && env_debug.match?(/runtime/)))
+        env_debug = ENV["RESQUE_DEBUG"]
+        @debug_mode = !!(env_debug == "true" || (env_debug.is_a?(String) && env_debug.match(/runtime/)))
       end
     end
   end

data/lib/resque/unique_at_runtime/version.rb

@@ -2,6 +2,12 @@
 
 module Resque
   module UniqueAtRuntime
-    VERSION = '4.0.0'
+    # Version namespace for this gem.
+    module Version
+      # Current gem version.
+      VERSION = "4.0.2"
+    end
+    # Current gem version exposed at the traditional constant location.
+    VERSION = Version::VERSION # Traditional Constant Location
   end
 end

data/lib/resque/unique_at_runtime.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative "unique_at_runtime/version"
+
+module Resque
+  module UniqueAtRuntime
+  end
+end

data/lib/resque-unique_at_runtime.rb

@@ -1,18 +1,17 @@
 # frozen_string_literal: true
 
-require 'resque/unique_at_runtime/version'
+require "resque/unique_at_runtime/version"
 
 # Ruby Std Lib
-require 'digest/md5'
+require "digest/md5"
 
 # External Gems
-require 'colorized_string'
-require 'resque'
+require "resque"
 
 # This Gem
-require 'resque/plugins/unique_at_runtime'
-require 'resque/unique_at_runtime/resque_ext/resque'
-require 'resque/unique_at_runtime/configuration'
+require "resque/plugins/unique_at_runtime"
+require "resque/unique_at_runtime/resque_ext/resque"
+require "resque/unique_at_runtime/configuration"
 
 # See lib/resque/plugins/unique_at_runtime.rb for the actual plugin
 #
@@ -21,7 +20,7 @@ require 'resque/unique_at_runtime/configuration'
 #   Resque, Resque::Job, or Resque::Queue.
 module Resque
   module UniqueAtRuntime
-    PLUGIN_TAG = (ColorizedString['[R-UAR] '].blue).freeze
+    PLUGIN_TAG = "[R-UAR] "
 
     def log(message)
       configuration.logger&.send(configuration.log_level, message) if configuration.logger
@@ -44,6 +43,6 @@ module Resque
     self.configuration = Configuration.instance # setup defaults
 
     module_function(:log,
-                    :debug)
+      :debug)
   end
 end

data/sig/resque/unique_at_runtime.rbs

@@ -0,0 +1,8 @@
+module Resque
+  module UniqueAtRuntime
+    module Version
+      VERSION: String
+    end
+    VERSION: String
+  end
+end