sidekiq-unique-jobs 6.0.7 → 7.1.33

data/lib/sidekiq_unique_jobs/sidekiq_unique_ext.rb

@@ -1,114 +1,163 @@
 # frozen_string_literal: true
 
-require 'sidekiq/api'
+require "sidekiq/api"
 
+#
+# @api private
+#
 module Sidekiq
+  # See Sidekiq::Api
   class SortedEntry
+    #
+    # Provides extensions for unlocking jobs that are removed and deleted
+    #
+    # @author Mikael Henriksson <mikael@mhenrixon.com>
+    #
     module UniqueExtension
-      def self.included(base)
-        base.class_eval do
-          alias_method :delete_orig, :delete
-          alias_method :delete, :delete_ext
-          alias_method :remove_job_orig, :remove_job
-          alias_method :remove_job, :remove_job_ext
-        end
-      end
-
-      def delete_ext
-        SidekiqUniqueJobs::Unlockable.unlock(item) if delete_orig
+      #
+      # Wraps the original method to ensure locks for the job are deleted
+      #
+      #
+      # @return [Hash] the deleted sidekiq job hash
+      #
+      def delete
+        SidekiqUniqueJobs::Unlockable.delete!(item) if super
+        item
       end
 
       private
 
-      def remove_job_ext
-        remove_job_orig do |message|
-          SidekiqUniqueJobs::Unlockable.unlock(Sidekiq.load_json(message))
+      #
+      # Wraps the original method to ensure locks for the job are deleted
+      #
+      #
+      # @yieldparam [Hash] message the sidekiq job hash
+      def remove_job
+        super do |message|
+          SidekiqUniqueJobs::Unlockable.delete!(Sidekiq.load_json(message))
           yield message
         end
       end
     end
 
-    include UniqueExtension
+    prepend UniqueExtension
   end
 
+  # See Sidekiq::Api
   class ScheduledSet
+    #
+    # Provides extensions for unlocking jobs that are removed and deleted
+    #
+    # @author Mikael Henriksson <mikael@mhenrixon.com>
+    #
     module UniqueExtension
-      def self.included(base)
-        base.class_eval do
-          alias_method :delete_orig, :delete
-          alias_method :delete, :delete_ext
-        end
-      end
-
-      def delete_ext
-        SidekiqUniqueJobs::Unlockable.unlock(item) if delete_orig
+      #
+      # Wraps the original method to ensure locks for the job are deleted
+      #
+      #
+      # @param [Integer, Float] score the score in the scheduled set
+      # @param [String] job_id the Sidekiq JID
+      #
+      def delete(score, job_id)
+        entry = find_job(job_id)
+        SidekiqUniqueJobs::Unlockable.delete!(entry.item) if super(score, job_id)
+        entry
       end
     end
-    include UniqueExtension
+
+    prepend UniqueExtension
   end
 
-  class Job
-    module UniqueExtension
-      def self.included(base)
-        base.class_eval do
-          alias_method :delete_orig, :delete
-          alias_method :delete, :delete_ext
+  if Sidekiq.const_defined?(:JobRecord)
+    # See Sidekiq::Api
+    class JobRecord
+      #
+      # Provides extensions for unlocking jobs that are removed and deleted
+      #
+      # @author Mikael Henriksson <mikael@mhenrixon.com>
+      #
+      module UniqueExtension
+        #
+        # Wraps the original method to ensure locks for the job are deleted
+        #
+        def delete
+          SidekiqUniqueJobs::Unlockable.delete!(item)
+          super
         end
       end
 
-      def delete_ext
-        delete_orig
-        SidekiqUniqueJobs::Unlockable.unlock(item)
-      end
+      prepend UniqueExtension
     end
+  else
+    # See Sidekiq::Api
+    class Job
+      #
+      # Provides extensions for unlocking jobs that are removed and deleted
+      #
+      # @author Mikael Henriksson <mikael@mhenrixon.com>
+      #
+      module UniqueExtension
+        #
+        # Wraps the original method to ensure locks for the job are deleted
+        #
+        def delete
+          SidekiqUniqueJobs::Unlockable.delete!(item)
+          super
+        end
+      end
 
-    include UniqueExtension
+      prepend UniqueExtension
+    end
   end
 
+  # See Sidekiq::Api
   class Queue
+    #
+    # Provides extensions for unlocking jobs that are removed and deleted
+    #
+    # @author Mikael Henriksson <mikael@mhenrixon.com>
+    #
     module UniqueExtension
-      def self.included(base)
-        base.class_eval do
-          alias_method :clear_orig, :clear
-          alias_method :clear, :clear_ext
-        end
-      end
-
-      def clear_ext
+      #
+      # Wraps the original method to ensure locks for the job are deleted
+      #
+      def clear
         each(&:delete)
-        clear_orig
+        super
       end
     end
 
-    include UniqueExtension
+    prepend UniqueExtension
   end
 
+  # See Sidekiq::Api
   class JobSet
+    #
+    # Provides extensions for unlocking jobs that are removed and deleted
+    #
+    # @author Mikael Henriksson <mikael@mhenrixon.com>
+    #
     module UniqueExtension
-      def self.included(base)
-        base.class_eval do
-          if base.method_defined?(:clear)
-            alias_method :clear_orig, :clear
-            alias_method :clear, :clear_ext
-          end
-
-          if base.method_defined?(:delete_by_value)
-            alias_method :delete_by_value_orig, :delete_by_value
-            alias_method :delete_by_value, :delete_by_value_ext
-          end
-        end
-      end
-
-      def clear_ext
+      #
+      # Wraps the original method to ensure locks for the job are deleted
+      #
+      def clear
         each(&:delete)
-        clear_orig
+        super
       end
 
-      def delete_by_value_ext(name, value)
-        SidekiqUniqueJobs::Unlockable.unlock(Sidekiq.load_json(value)) if delete_by_value_orig(name, value)
+      #
+      # Wraps the original method to ensure locks for the job are deleted
+      #
+      #
+      # @param [String] name the name of the key
+      # @param [String] value a sidekiq job hash
+      #
+      def delete_by_value(name, value)
+        SidekiqUniqueJobs::Unlockable.delete!(Sidekiq.load_json(value)) if super(name, value)
       end
     end
 
-    include UniqueExtension
+    prepend UniqueExtension
   end
 end

data/lib/sidekiq_unique_jobs/sidekiq_unique_jobs.rb

@@ -0,0 +1,304 @@
+# frozen_string_literal: true
+
+#
+# Contains configuration and utility methods that belongs top level
+#
+# @author Mikael Henriksson <mikael@mhenrixon.com>
+module SidekiqUniqueJobs # rubocop:disable Metrics/ModuleLength
+  include SidekiqUniqueJobs::Connection
+  extend SidekiqUniqueJobs::JSON
+
+  module_function
+
+  #
+  # The current configuration (See: {.configure} on how to configure)
+  #
+  #
+  # @return [SidekiqUniqueJobs::Config] the gem configuration
+  #
+  def config
+    @config ||= reset! # rubocop:disable ThreadSafety/InstanceVariableInClassMethod
+  end
+
+  #
+  # The current strategies
+  #
+  #
+  # @return [Hash<Symbol, SidekiqUniqueJobs::Strategy>] the configured locks
+  #
+  def strategies
+    config.strategies
+  end
+
+  #
+  # The current locks
+  #
+  #
+  # @return [Hash<Symbol, SidekiqUniqueJobs::BaseLock>] the configured locks
+  #
+  def locks
+    config.locks
+  end
+
+  #
+  # The current logger
+  #
+  #
+  # @return [Logger] the configured logger
+  #
+  def logger
+    config.logger
+  end
+
+  #
+  # The current gem version
+  #
+  #
+  # @return [String] the current gem version
+  #
+  def version
+    VERSION
+  end
+
+  #
+  # Set a new logger
+  #
+  # @param [Logger] other another logger
+  #
+  # @return [Logger] the new logger
+  #
+  def logger=(other)
+    config.logger = other
+  end
+
+  #
+  # Check if logging is enabled
+  #
+  #
+  # @return [true, false]
+  #
+  def logging?
+    config.logger_enabled
+  end
+
+  #
+  # Temporarily use another configuration and reset to the old config after yielding
+  #
+  # @param [Hash] tmp_config the temporary configuration to use
+  #
+  # @return [void]
+  #
+  # @yield control to the caller
+  def use_config(tmp_config = {})
+    raise ::ArgumentError, "#{name}.#{__method__} needs a block" unless block_given?
+
+    old_config = config.to_h
+    reset!
+    configure(tmp_config)
+    yield
+  ensure
+    reset!
+    configure(old_config.to_h)
+  end
+
+  #
+  # Resets configuration to deafult
+  #
+  #
+  # @return [SidekiqUniqueJobs::Config] a default gem configuration
+  #
+  def reset!
+    @config = SidekiqUniqueJobs::Config.default # rubocop:disable ThreadSafety/InstanceVariableInClassMethod
+  end
+
+  #
+  # Enable SidekiqUniuqeJobs either temporarily in a block or for good
+  #
+  #
+  # @return [true] when not given a block
+  # @return [true, false] the previous value of enable when given a block
+  #
+  # @yieldreturn [void] temporarily enable sidekiq unique jobs while executing a block of code
+  def enable!(&block)
+    toggle(true, &block)
+  end
+
+  #
+  # Disable SidekiqUniuqeJobs either temporarily in a block or for good
+  #
+  #
+  # @return [false] when not given a block
+  # @return [true, false] the previous value of enable when given a block
+  #
+  # @yieldreturn [void] temporarily disable sidekiq unique jobs while executing a block of code
+  def disable!(&block)
+    toggle(false, &block)
+  end
+
+  #
+  # Checks if the gem has been disabled
+  #
+  # @return [true] when config.enabled is true
+  # @return [false] when config.enabled is false
+  #
+  def enabled?
+    config.enabled
+  end
+
+  #
+  # Checks if the gem has been disabled
+  #
+  # @return [true] when config.enabled is false
+  # @return [false] when config.enabled is true
+  #
+  def disabled?
+    !enabled?
+  end
+
+  #
+  # Toggles enabled on or off
+  #
+  # @api private
+  # :nodoc:
+  def toggle(enabled)
+    if block_given?
+      enabled_was = config.enabled
+      config.enabled = enabled
+      yield
+      config.enabled = enabled_was
+    else
+      config.enabled = enabled
+    end
+  end
+
+  # Configure the gem
+  #
+  # This is usually called once at startup of an application
+  # @param [Hash] options global gem options
+  # @option options [Integer] :lock_timeout (default is 0)
+  # @option options [Integer] :lock_ttl (default is 0)
+  # @option options [true,false] :enabled (default is true)
+  # @option options [String] :lock_prefix (default is 'uniquejobs')
+  # @option options [Logger] :logger (default is Sidekiq.logger)
+  # @yield control to the caller when given block
+  def configure(options = {})
+    if block_given?
+      yield config
+    else
+      options.each do |key, val|
+        config.send(:"#{key}=", val)
+      end
+    end
+  end
+
+  #
+  # Returns the current redis version
+  #
+  #
+  # @return [String] a string like `5.0.2`
+  #
+  def fetch_redis_version
+    Sidekiq.redis_info["redis_version"]
+  end
+
+  #
+  # Current time as float
+  #
+  #
+  # @return [Float]
+  #
+  def now_f
+    now.to_f
+  end
+
+  #
+  # Current time
+  #
+  #
+  # @return [Time]
+  #
+  def now
+    Time.now
+  end
+
+  #
+  # Checks that the worker is valid with the given options
+  #
+  # @param [Hash] options the `sidekiq_options` to validate
+  #
+  # @return [Boolean]
+  #
+  def validate_worker(options)
+    raise NotUniqueWorker, options unless (lock_type = options[LOCK])
+
+    lock_class = locks[lock_type]
+    lock_class.validate_options(options)
+  end
+
+  #
+  # Checks that the worker is valid with the given options
+  #
+  # @param [Hash] options the `sidekiq_options` to validate
+  #
+  # @raise [InvalidWorker] when {#validate_worker} returns false or nil
+  #
+  def validate_worker!(options)
+    lock_config = validate_worker(options)
+    raise InvalidWorker, lock_config unless lock_config.errors.empty?
+  end
+
+  # Attempt to constantize a string worker_class argument, always
+  # failing back to the original argument when the constant can't be found
+  #
+  # @return [Sidekiq::Worker]
+  def constantize(str)
+    return str.class             if str.is_a?(Sidekiq::Worker) # sidekiq v6.x
+    return str                   unless str.is_a?(String)
+    return Object.const_get(str) unless str.include?("::")
+
+    names = str.split("::")
+    names.shift if names.empty? || names.first.empty?
+
+    names.inject(Object) do |constant, name|
+      # the false flag limits search for name to under the constant namespace
+      #   which mimics Rails' behaviour
+      constant.const_get(name, false)
+    end
+  end
+
+  # Attempt to constantize a string worker_class argument, always
+  # failing back to the original argument when the constant can't be found
+  #
+  # @return [Sidekiq::Worker, String]
+  def safe_constantize(str)
+    constantize(str)
+  rescue NameError => ex
+    case ex.message
+    when /uninitialized constant/
+      str
+    else
+      raise
+    end
+  end
+
+  #
+  # Collection with notifications
+  #
+  #
+  # @return [Reflections]
+  #
+  def reflections
+    @reflections ||= Reflections.new # rubocop:disable ThreadSafety/InstanceVariableInClassMethod
+  end
+
+  #
+  # Yields notification stack for sidekiq unique jobs to configure notifications
+  #
+  #
+  # @return [void] <description>
+  #
+  # @yieldparam [Reflections] x used to configure notifications
+  def reflect
+    yield reflections if block_given?
+  end
+end

data/lib/sidekiq_unique_jobs/sidekiq_worker_methods.rb

@@ -3,60 +3,82 @@
 module SidekiqUniqueJobs
   # Module with convenience methods for the Sidekiq::Worker class
   #
-  # @author Mikael Henriksson <mikael@zoolutions.se>
+  # @author Mikael Henriksson <mikael@mhenrixon.com>
   module SidekiqWorkerMethods
+    #
+    # @!attribute [r] job_class
+    #   @return [Sidekiq::Worker] The Sidekiq::Worker implementation
+    attr_reader :job_class
+
     # Avoids duplicating worker_class.respond_to? in multiple places
     # @return [true, false]
-    def worker_method_defined?(method_sym)
-      worker_class.respond_to?(method_sym)
+    def job_method_defined?(method_sym)
+      job_class.respond_to?(method_sym)
     end
 
     # Wraps #get_sidekiq_options to always work with a hash
     # @return [Hash] of the worker class sidekiq options
-    def worker_options
-      return {} unless sidekiq_worker_class?
+    def job_options
+      return {} unless sidekiq_job_class?
 
-      worker_class.get_sidekiq_options.stringify_keys
+      job_class.get_sidekiq_options.deep_stringify_keys
     end
 
     # Tests that the
-    # @return [true] if worker_class responds to get_sidekiq_options
-    # @return [false] if worker_class does not respond to get_sidekiq_options
-    def sidekiq_worker_class?
-      worker_method_defined?(:get_sidekiq_options)
+    # @return [true] if job_class responds to get_sidekiq_options
+    # @return [false] if job_class does not respond to get_sidekiq_options
+    def sidekiq_job_class?
+      job_method_defined?(:get_sidekiq_options)
     end
 
-    # The Sidekiq::Worker implementation
-    # @return [Sidekiq::Worker]
-    def worker_class
-      @_worker_class ||= worker_class_constantize # rubocop:disable Naming/MemoizedInstanceVariableName
+    def job_class=(obj)
+      # this is what was originally passed in, it can be an instance or a class depending on sidekiq version
+      @original_job_class = obj
+      @job_class = job_class_constantize(obj)
     end
 
     # The hook to call after a successful unlock
     # @return [Proc]
-    def after_unlock_hook
-      -> { worker_class.after_unlock if worker_method_defined?(:after_unlock) }
+    def after_unlock_hook # rubocop:disable Metrics/MethodLength
+      lambda do
+        if @original_job_class.respond_to?(:after_unlock)
+          # instance method in sidekiq v6
+          if @original_job_class.method(:after_unlock).arity.positive? # arity check to maintain backwards compatibility
+            @original_job_class.after_unlock(item)
+          else
+            @original_job_class.after_unlock
+          end
+        elsif job_class.respond_to?(:after_unlock)
+          # class method regardless of sidekiq version
+          if job_class.method(:after_unlock).arity.positive? # arity check to maintain backwards compatibility
+            job_class.after_unlock(item)
+          else
+            job_class.after_unlock
+          end
+        end
+      end
     end
 
     # Attempt to constantize a string worker_class argument, always
     # failing back to the original argument when the constant can't be found
     #
     # @return [Sidekiq::Worker]
-    def worker_class_constantize(klazz = @worker_class)
-      return klazz unless klazz.is_a?(String)
-
-      Object.const_get(klazz)
-    rescue NameError => ex
-      case ex.message
-      when /uninitialized constant/
-        klazz
-      else
-        raise
-      end
+    def job_class_constantize(klazz = @job_class)
+      SidekiqUniqueJobs.safe_constantize(klazz)
     end
 
-    def default_worker_options
-      Sidekiq.default_worker_options
+    #
+    # Returns the default worker options from Sidekiq
+    #
+    #
+    # @return [Hash<Symbol, Object>]
+    #
+    def default_job_options
+      if Sidekiq.respond_to?(:default_job_options)
+        Sidekiq.default_job_options
+      else
+        Sidekiq.default_worker_options
+      end
     end
   end
 end