sidekiq-unique-jobs 4.0.0 → 4.0.7

data/gemfiles/sidekiq_3.3.gemfile

@@ -3,13 +3,15 @@
 source "http://rubygems.org"
 
 gem "appraisal", "~> 2.0.0"
+gem "rspec-its", :require => false
 gem "sidekiq", "~> 3.3.0"
 
-platforms :mri do
-  gem "pry-suite", :require => false
-  gem "let_it_go", :require => false
-  gem "memory-profiler", :require => false
+platforms :mri_22 do
+  gem "pry", :require => false
+  gem "pry-rescue", :require => false
+  gem "pry-byebug", :require => false
   gem "simplecov-json", :require => false
+  gem "memory_profiler", :require => false
   gem "codeclimate-test-reporter", :require => false
 end
 

data/gemfiles/sidekiq_develop.gemfile

@@ -3,13 +3,15 @@
 source "http://rubygems.org"
 
 gem "appraisal", "~> 2.0.0"
+gem "rspec-its", :require => false
 gem "sidekiq", :github => "mperham/sidekiq"
 
-platforms :mri do
-  gem "pry-suite", :require => false
-  gem "let_it_go", :require => false
-  gem "memory-profiler", :require => false
+platforms :mri_22 do
+  gem "pry", :require => false
+  gem "pry-rescue", :require => false
+  gem "pry-byebug", :require => false
   gem "simplecov-json", :require => false
+  gem "memory_profiler", :require => false
   gem "codeclimate-test-reporter", :require => false
 end
 

data/lib/sidekiq-unique-jobs.rb

@@ -1,5 +1,7 @@
 require 'yaml' if RUBY_VERSION.include?('2.0.0') # rubocop:disable FileName
+require 'sidekiq_unique_jobs/constants'
 require 'sidekiq_unique_jobs/core_ext'
+require 'sidekiq_unique_jobs/timeout_calculator'
 require 'sidekiq_unique_jobs/options_with_fallback'
 require 'sidekiq_unique_jobs/scripts'
 require 'sidekiq_unique_jobs/unique_args'
@@ -18,17 +20,12 @@ module SidekiqUniqueJobs
   def config
     @config ||= Config.new(
       unique_prefix: 'uniquejobs',
-      unique_args_enabled: true,
       default_expiration: 30 * 60,
       default_lock: :while_executing,
       redis_test_mode: :redis # :mock
     )
   end
 
-  def unique_args_enabled?
-    config.unique_args_enabled
-  end
-
   def default_lock
     config.default_lock
   end
@@ -38,7 +35,7 @@ module SidekiqUniqueJobs
       yield config
     else
       options.each do |key, val|
-        config[key] = val
+        config.send("#{key}=", val)
       end
     end
   end

data/lib/sidekiq_unique_jobs/config.rb

@@ -1,6 +1,5 @@
 module SidekiqUniqueJobs
   class Config < OpenStruct
-    TESTING_CONSTANT ||= 'Testing'.freeze
     CONFIG_ACCESSORS = [
       :unique_prefix,
       :default_expiration,
@@ -17,11 +16,7 @@ module SidekiqUniqueJobs
     end
 
     def testing_enabled?
-      Sidekiq.const_defined?(TESTING_CONSTANT) && Sidekiq::Testing.enabled?
-    end
-
-    def unique_args_enabled?
-      config.unique_args_enabled
+      Sidekiq.const_defined?(TESTING_CONSTANT, false) && Sidekiq::Testing.enabled?
     end
   end
 end

data/lib/sidekiq_unique_jobs/constants.rb

@@ -0,0 +1,17 @@
+module SidekiqUniqueJobs
+  ARGS_KEY ||= 'args'.freeze
+  AT_KEY ||= 'at'.freeze
+  CLASS_KEY ||= 'class'.freeze
+  JID_KEY ||= 'jid'.freeze
+  LOG_DUPLICATE_KEY ||= 'log_duplicate_payload'.freeze
+  QUEUE_KEY ||= 'queue'.freeze
+  TESTING_CONSTANT ||= 'Testing'.freeze
+  UNIQUE_KEY ||= 'unique'.freeze
+  UNIQUE_LOCK_KEY ||= 'unique_lock'.freeze
+  UNIQUE_ARGS_KEY ||= 'unique_args'.freeze
+  UNIQUE_PREFIX_KEY ||= 'unique_prefix'.freeze
+  UNIQUE_DIGEST_KEY ||= 'unique_digest'.freeze
+  UNIQUE_ON_ALL_QUEUES_KEY ||= 'unique_on_all_queues'.freeze
+  UNIQUE_TIMEOUT_KEY ||= 'unique_expiration'.freeze
+  UNIQUE_ARGS_ENABLED_KEY ||= 'unique_args_enabled'.freeze
+end

data/lib/sidekiq_unique_jobs/core_ext.rb

@@ -19,28 +19,33 @@ rescue LoadError
     end unless {}.respond_to?(:slice!)
   end
 end
-begin
-  require 'active_support/core_ext/string/inflections'
-rescue LoadError
-  class String
-    # File activesupport/lib/active_support/inflector/methods.rb, line 178
-    def classify
-      camelize(singularize(sub(/.*\./, '')))
-    end unless ''.respond_to?(:classify)
 
-    # File activesupport/lib/active_support/inflector/methods.rb, line 67
-    def camelize(uppercase_first_letter = true)
-      string = self
-      if uppercase_first_letter
-        string = string.sub(/^[a-z\d]*/) { $&.capitalize }
-      else
-        string = string.sub(/^(?:(?=\b|[A-Z_])|\w)/) { $&.downcase }
-      end
-      string.gsub!(%r{(?:_|(\/))([a-z\d]*)}i) do
-        "#{Regexp.last_match(1)}#{Regexp.last_match(2).capitalize}"
-      end
-      string.gsub!(%r{/}, '::')
-      string
-    end unless ''.respond_to?(:camelize)
-  end
+class Array
+  def extract_options!
+    if last.is_a?(Hash) && last.instance_of?(Hash)
+      pop
+    else
+      {}
+    end
+  end unless [].respond_to?(:extract_options!)
+end
+
+class String
+  def classify
+    camelize(sub(/.*\./, ''))
+  end unless ''.respond_to?(:classify)
+
+  def camelize(uppercase_first_letter = true)
+    string = self
+    if uppercase_first_letter
+      string = string.sub(/^[a-z\d]*/) { $&.capitalize }
+    else
+      string = string.sub(/^(?:(?=\b|[A-Z_])|\w)/) { $&.downcase }
+    end
+    string.gsub!(%r{(?:_|(\/))([a-z\d]*)}i) do
+      "#{Regexp.last_match(1)}#{Regexp.last_match(2).capitalize}"
+    end
+    string.gsub!(%r{/}, '::')
+    string
+  end unless ''.respond_to?(:camelize)
 end

data/lib/sidekiq_unique_jobs/lock.rb

@@ -1,8 +1,8 @@
-require 'sidekiq_unique_jobs/lock/time_calculator'
 require 'sidekiq_unique_jobs/lock/until_executed'
 require 'sidekiq_unique_jobs/lock/until_executing'
 require 'sidekiq_unique_jobs/lock/while_executing'
 require 'sidekiq_unique_jobs/lock/until_timeout'
+require 'sidekiq_unique_jobs/lock/until_and_while_executing'
 
 module SidekiqUniqueJobs
   module Lock

data/lib/sidekiq_unique_jobs/lock/until_and_while_executing.rb

@@ -0,0 +1,13 @@
+module SidekiqUniqueJobs
+  module Lock
+    class UntilAndWhileExecuting < UntilExecuting
+      def execute(callback)
+        lock = WhileExecuting.new(item, redis_pool)
+        lock.synchronize do
+          callback.call if unlock(:server)
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/lock/until_executed.rb

@@ -11,11 +11,21 @@ module SidekiqUniqueJobs
         @redis_pool = redis_pool
       end
 
+      def execute(callback, &blk)
+        operative = true
+        send(:after_yield_yield, &blk)
+      rescue Sidekiq::Shutdown
+        operative = false
+        raise
+      ensure
+        callback.call if operative && unlock(:server)
+      end
+
       def unlock(scope)
         unless [:server, :api, :test].include?(scope)
           fail ArgumentError, "#{scope} middleware can't #{__method__} #{unique_key}"
         end
-        SidekiqUniqueJobs::Unlockable.unlock(unique_key, item['jid'.freeze], redis_pool)
+        SidekiqUniqueJobs::Unlockable.unlock(unique_key, item[JID_KEY], redis_pool)
       end
 
       # rubocop:disable MethodLength
@@ -26,7 +36,7 @@ module SidekiqUniqueJobs
 
         result = Scripts.call(:aquire_lock, redis_pool,
                               keys: [unique_key],
-                              argv: [item['jid'.freeze], max_lock_time])
+                              argv: [item[JID_KEY], max_lock_time])
         case result
         when 1
           logger.debug { "successfully locked #{unique_key} for #{max_lock_time} seconds" }
@@ -45,7 +55,11 @@ module SidekiqUniqueJobs
       end
 
       def max_lock_time
-        @max_lock_time ||= TimeCalculator.for_item(item).seconds
+        @max_lock_time ||= TimeoutCalculator.for_item(item).seconds
+      end
+
+      def after_yield_yield
+        yield
       end
 
       private

data/lib/sidekiq_unique_jobs/lock/until_executing.rb

@@ -1,6 +1,10 @@
 module SidekiqUniqueJobs
   module Lock
     class UntilExecuting < UntilExecuted
+      def execute(callback, &_block)
+        callback.call if unlock(:server)
+        yield
+      end
     end
   end
 end

data/lib/sidekiq_unique_jobs/lock/until_timeout.rb

@@ -2,8 +2,15 @@ module SidekiqUniqueJobs
   module Lock
     class UntilTimeout < UntilExecuted
       def unlock(scope)
-        return true if scope.to_sym == :server
-        fail ArgumentError, "#{scope} middleware can't #{__method__} #{unique_key}"
+        if scope.to_sym == :server
+          return true
+        else
+          fail ArgumentError, "#{scope} middleware can't #{__method__} #{unique_key}"
+        end
+      end
+
+      def execute(_callback)
+        yield if block_given?
       end
     end
   end

data/lib/sidekiq_unique_jobs/lock/while_executing.rb

@@ -6,25 +6,37 @@ module SidekiqUniqueJobs
       end
 
       def initialize(item, redis_pool = nil)
-        @unique_digest = item['unique_digest'.freeze]
-        @run_key = "#{@unique_digest}:run"
+        @item = item
         @mutex = Mutex.new
         @redis_pool = redis_pool
+        @unique_digest = "#{create_digest}:run"
+        yield self if block_given?
       end
 
-      def synchronize(&_block)
+      def synchronize
         @mutex.lock
         sleep 0.001 until locked?
 
         yield
 
       ensure
-        SidekiqUniqueJobs.connection(@redis_pool) { |c| c.del @run_key }
+        SidekiqUniqueJobs.connection(@redis_pool) { |c| c.del @unique_digest }
         @mutex.unlock
       end
 
       def locked?
-        Scripts.call(:synchronize, @redis_pool, keys: [@run_key], argv: [Time.now.to_i]) == 1
+        Scripts.call(:synchronize, @redis_pool, keys: [@unique_digest], argv: [Time.now.to_i]) == 1
+      end
+
+      def execute(_callback)
+        synchronize do
+          yield
+        end
+      end
+
+      def create_digest
+        @unique_digest ||= @item[UNIQUE_DIGEST_KEY]
+        @unique_digest ||= SidekiqUniqueJobs::UniqueArgs.digest(@item)
       end
     end
   end

data/lib/sidekiq_unique_jobs/options_with_fallback.rb

@@ -1,8 +1,9 @@
 module SidekiqUniqueJobs
   module OptionsWithFallback
-    UNIQUE_KEY ||= 'unique'.freeze
-    UNIQUE_LOCK_KEY ||= 'unique_lock'.freeze
-    LOG_DUPLICATE_KEY ||= 'log_duplicate_payload'.freeze
+    def self.included(base)
+      base.class_attribute :lock_cache unless base.respond_to?(:lock_cache)
+      base.lock_cache ||= {}
+    end
 
     def unique_enabled?
       options[UNIQUE_KEY] || item[UNIQUE_KEY]
@@ -21,16 +22,24 @@ module SidekiqUniqueJobs
     end
 
     def lock_class
-      "SidekiqUniqueJobs::Lock::#{unique_lock.to_s.classify}".constantize
+      lock_cache[unique_lock.to_sym] ||= "SidekiqUniqueJobs::Lock::#{unique_lock.to_s.classify}".constantize
     end
 
     def unique_lock
-      options[UNIQUE_LOCK_KEY] || item[UNIQUE_LOCK_KEY] || SidekiqUniqueJobs.default_lock
+      if options.key?(UNIQUE_KEY) && options[UNIQUE_KEY] == true
+        warn('unique: true is no longer valid. Please set it to the type of lock required like: ' \
+             '`unique: :until_executed`')
+        options[UNIQUE_LOCK_KEY] || SidekiqUniqueJobs.default_lock
+      else
+        options[UNIQUE_KEY] || item[UNIQUE_KEY] || SidekiqUniqueJobs.default_lock
+      end
     end
 
     def options
       @options ||= worker_class.get_sidekiq_options if worker_class.respond_to?(:get_sidekiq_options)
+      @options ||= Sidekiq.default_worker_options
       @options ||= {}
+      @options &&= @options.stringify_keys
     end
   end
 end

data/lib/sidekiq_unique_jobs/server/middleware.rb

@@ -1,4 +1,3 @@
-require 'digest'
 require 'forwardable'
 
 module SidekiqUniqueJobs
@@ -15,54 +14,18 @@ module SidekiqUniqueJobs
         @redis_pool = redis_pool
         @queue = queue
         @item = item
-
-        send(unique_lock, &blk)
+        return yield unless unique_enabled?
+        lock.send(:execute, after_unlock_hook, &blk)
       end
 
       private
 
       attr_reader :redis_pool, :worker, :item, :worker_class
 
-      def until_executing
-        unlock
-        yield
-      end
-
-      def until_executed(&block)
-        operative = true
-        after_yield_yield(&block)
-      rescue Sidekiq::Shutdown
-        operative = false
-        raise
-      ensure
-        unlock if operative
-      end
-
-      def after_yield_yield
-        yield
-      end
-
-      def while_executing
-        lock.synchronize do
-          yield
-        end
-      rescue SidekiqUniqueJobs::RunLockFailed
-        return reschedule if reschedule_on_lock_fail
-        raise
-      end
-
-      def until_timeout
-        yield if block_given?
-      end
-
       protected
 
-      def unlock
-        after_unlock_hook if lock.unlock(:server)
-      end
-
       def after_unlock_hook
-        worker.after_unlock if worker.respond_to?(:after_unlock)
+        -> { worker.after_unlock if worker.respond_to?(:after_unlock) }
       end
 
       def reschedule

data/lib/sidekiq_unique_jobs/sidekiq_unique_ext.rb

@@ -37,7 +37,30 @@ module Sidekiq
   end
 
   class ScheduledSet
-    module UniqueExtension
+    # rubocop:disable Style/ClassAndModuleCamelCase
+    module UniqueExtension3_0
+      def self.included(base)
+        base.class_eval do
+          include UnlockMethod
+          alias_method :delete_orig, :delete
+          alias_method :delete, :delete_ext
+        end
+      end
+
+      def delete_ext(score, jid = nil)
+        item = find_job(jid)
+        unlock(item) if delete_orig(score, jid)
+      end
+
+      def remove_job_ext
+        remove_job_orig do |message|
+          unlock(Sidekiq.load_json(message))
+          yield message
+        end
+      end
+    end
+
+    module UniqueExtension3_4
       def self.included(base)
         base.class_eval do
           include UnlockMethod
@@ -57,7 +80,11 @@ module Sidekiq
         end
       end
     end
-    include UniqueExtension if Gem::Version.new(Sidekiq::VERSION) >= Gem::Version.new('3.1')
+    sidekiq_version = Gem::Version.new(Sidekiq::VERSION)
+    include UniqueExtension3_4 if sidekiq_version >= Gem::Version.new('3.4')
+    include UniqueExtension3_0 if sidekiq_version >= Gem::Version.new('3.0') &&
+                                  sidekiq_version < Gem::Version.new('3.4')
+    # rubocop:enable Style/ClassAndModuleCamelCase
   end
 
   class Job