sidekiq-unique-jobs 6.0.23 → 7.1.12

data/lib/sidekiq_unique_jobs/sidekiq_unique_jobs.rb

@@ -3,73 +3,172 @@
 #
 # Contains configuration and utility methods that belongs top level
 #
-# @author Mikael Henriksson <mikael@zoolutions.se>
-module SidekiqUniqueJobs
+# @author Mikael Henriksson <mikael@mhenrixon.com>
+module SidekiqUniqueJobs # rubocop:disable Metrics/ModuleLength
   include SidekiqUniqueJobs::Connection
+  extend SidekiqUniqueJobs::JSON
 
   module_function
 
-  Config = Concurrent::MutableStruct.new(
-    :default_lock_timeout,
-    :enabled,
-    :unique_prefix,
-    :logger,
-  )
-
+  #
   # The current configuration (See: {.configure} on how to configure)
+  #
+  #
+  # @return [SidekiqUniqueJobs::Config] the gem configuration
+  #
   def config
-    # Arguments here need to match the definition of the new class (see above)
-    @config ||= Config.new(
-      0,
-      true,
-      "uniquejobs",
-      Sidekiq.logger,
-    )
+    @config ||= reset!
+  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
 
-  # :reek:ManualDispatch
-  def with_context(context)
-    if logger.respond_to?(:with_context)
-      logger.with_context(context) { yield }
-    elsif defined?(Sidekiq::Context)
-      Sidekiq::Context.with(context) { yield }
-    elsif defined?(Sidekiq::Logging)
-      Sidekiq::Logging.with_context(context) { yield }
-    else
-      yield
-    end
+  #
+  # The current gem version
+  #
+  #
+  # @return [String] the current gem version
+  #
+  def version
+    VERSION
   end
 
+  #
   # Set a new logger
-  # @param [Logger] other a new logger
+  #
+  # @param [Logger] other another logger
+  #
+  # @return [Logger] the new logger
+  #
   def logger=(other)
     config.logger = other
   end
 
-  # Change global configuration while yielding
+  #
+  # 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)
+  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
-    configure(old_config)
+  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
+  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] :default_lock_timeout (default is 0)
+  # @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] :unique_prefix (default is 'uniquejobs')
+  # @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 = {})
@@ -82,7 +181,114 @@ module SidekiqUniqueJobs
     end
   end
 
-  def redis_version
-    @redis_version ||= redis { |conn| conn.info("server")["redis_version"] }
+  #
+  # 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
+  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,7 +3,7 @@
 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
     # Avoids duplicating worker_class.respond_to? in multiple places
     # @return [true, false]
@@ -16,7 +16,7 @@ module SidekiqUniqueJobs
     def worker_options
       return {} unless sidekiq_worker_class?
 
-      worker_class.get_sidekiq_options.stringify_keys
+      worker_class.get_sidekiq_options.deep_stringify_keys
     end
 
     # Tests that the
@@ -29,33 +29,35 @@ module SidekiqUniqueJobs
     # The Sidekiq::Worker implementation
     # @return [Sidekiq::Worker]
     def worker_class
-      @_worker_class ||= worker_class_constantize(@worker_class) # rubocop:disable Naming/MemoizedInstanceVariableName
+      @_worker_class ||= worker_class_constantize # rubocop:disable Naming/MemoizedInstanceVariableName
     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) }
+      lambda do
+        if @worker_class.respond_to?(:after_unlock)
+          @worker_class.after_unlock # instance method in sidekiq v6
+        elsif worker_class.respond_to?(:after_unlock)
+          worker_class.after_unlock # class method regardless of sidekiq version
+        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)
-      return klazz.class if klazz.is_a?(Sidekiq::Worker) # sidekiq v6.x
-      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 worker_class_constantize(klazz = @worker_class)
+      SidekiqUniqueJobs.safe_constantize(klazz)
     end
 
+    #
+    # Returns the default worker options from Sidekiq
+    #
+    #
+    # @return [Hash<Symbol, Object>]
+    #
     def default_worker_options
       Sidekiq.default_worker_options
     end

data/lib/sidekiq_unique_jobs/testing.rb

@@ -1,36 +1,69 @@
 # frozen_string_literal: true
 
 # :nocov:
+# :nodoc:
 
 require "sidekiq"
 require "sidekiq/testing"
+require "sidekiq_unique_jobs/rspec/matchers"
+require "sidekiq_unique_jobs/lock/validator"
+require "sidekiq_unique_jobs/lock/client_validator"
+require "sidekiq_unique_jobs/lock/server_validator"
 
+#
+# See Sidekiq gem for more details
+#
 module Sidekiq
+  #
+  # Temporarily turn Sidekiq's options into something different
+  #
+  # @note this method will restore the original options after yielding
+  #
+  # @param [Hash<Symbol, Object>] tmp_config the temporary config to use
+  #
   def self.use_options(tmp_config = {})
-    old_config = default_worker_options
+    old_options = default_worker_options.dup
+
     default_worker_options.clear
     self.default_worker_options = tmp_config
-
     yield
   ensure
     default_worker_options.clear
-    self.default_worker_options = old_config
+    self.default_worker_options = DEFAULT_WORKER_OPTIONS
+    self.default_worker_options = old_options
   end
 
+  #
+  # See Sidekiq::Worker in Sidekiq gem for more details
+  #
   module Worker
+    #
+    # Adds class methods to Sidekiq::Worker
+    #
     module ClassMethods
+      #
+      # Temporarily turn a workers sidekiq_options into something different
+      #
+      # @note this method will restore the original configuration after yielding
+      #
+      # @param [Hash<Symbol, Object>] tmp_config the temporary config to use
+      #
       def use_options(tmp_config = {})
-        old_config = get_sidekiq_options
-        sidekiq_options(tmp_config)
+        old_options = sidekiq_options_hash.dup
+        sidekiq_options(old_options.merge(tmp_config))
 
         yield
       ensure
-        sidekiq_options(old_config)
+        self.sidekiq_options_hash = Sidekiq::DEFAULT_WORKER_OPTIONS
+        sidekiq_options(old_options)
       end
 
+      #
+      # Clears the jobs for this worker and removes all locks
+      #
       def clear
         jobs.each do |job|
-          SidekiqUniqueJobs::Unlockable.delete(job)
+          SidekiqUniqueJobs::Unlockable.unlock(job)
         end
 
         Sidekiq::Queues[queue].clear
@@ -38,25 +71,33 @@ module Sidekiq
       end
     end
 
+    #
+    # Prepends deletion of locks to clear_all
+    #
     module Overrides
-      def self.included(base)
-        base.extend Testing
-        base.class_eval do
-          class << self
-            alias_method :clear_all_orig, :clear_all
-            alias_method :clear_all, :clear_all_ext
-          end
-        end
+      #
+      # Overrides sidekiq_options on the worker class to prepend validation
+      #
+      # @param [Hash] options worker options
+      #
+      # @return [void]
+      #
+      def sidekiq_options(options = {})
+        SidekiqUniqueJobs.validate_worker!(options) if SidekiqUniqueJobs.config.raise_on_config_error
+
+        super(options)
       end
 
-      module Testing
-        def clear_all_ext
-          clear_all_orig
-          SidekiqUniqueJobs::Util.del("*", 1000)
-        end
+      #
+      # Clears all jobs for this worker and removes all locks
+      #
+      def clear_all
+        super
+
+        SidekiqUniqueJobs::Digests.new.delete_by_pattern("*", count: 10_000)
       end
     end
 
-    include Overrides
+    prepend Overrides
   end
 end

data/lib/sidekiq_unique_jobs/timer_task.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  # @see [Concurrent::TimerTask] https://www.rubydoc.info/gems/concurrent-ruby/Concurrent/TimerTask
+  #
+  class TimerTask < ::Concurrent::TimerTask
+    private
+
+    def ns_initialize(opts, &task)
+      set_deref_options(opts)
+
+      self.execution_interval = opts[:execution] || opts[:execution_interval] || EXECUTION_INTERVAL
+      self.timeout_interval = opts[:timeout] || opts[:timeout_interval] || TIMEOUT_INTERVAL
+      @run_now  = opts[:now] || opts[:run_now]
+      @executor = Concurrent::RubySingleThreadExecutor.new
+      @running  = Concurrent::AtomicBoolean.new(false)
+      @task     = task
+      @value    = nil
+
+      self.observers = Concurrent::Collection::CopyOnNotifyObserverSet.new
+    end
+
+    def schedule_next_task(interval = execution_interval)
+      exec_task = ->(completion) { execute_task(completion) }
+      Concurrent::ScheduledTask.execute(interval, args: [Concurrent::Event.new], &exec_task)
+      nil
+    end
+
+    # @!visibility private
+    def execute_task(completion) # rubocop:disable Metrics/MethodLength
+      return nil unless @running.true?
+
+      timeout_task = -> { timeout_task(completion) }
+
+      Concurrent::ScheduledTask.execute(
+        timeout_interval,
+        args: [completion],
+        &timeout_task
+      )
+      @thread_completed = Concurrent::Event.new
+
+      @value = @reason  = nil
+      @executor.post do
+        @value = @task.call(self)
+      rescue Exception => ex # rubocop:disable Lint/RescueException
+        @reason = ex
+      ensure
+        @thread_completed.set
+      end
+
+      @thread_completed.wait
+
+      if completion.try?
+        schedule_next_task
+        time = Time.now
+        observers.notify_observers do
+          [time, value, @reason]
+        end
+      end
+      nil
+    end
+
+    # @!visibility private
+    def timeout_task(completion)
+      return unless @running.true?
+      return unless completion.try?
+
+      @executor.kill
+      @executor.wait_for_termination
+      @executor = Concurrent::RubySingleThreadExecutor.new
+
+      @thread_completed.set
+
+      schedule_next_task
+      observers.notify_observers(Time.now, nil, Concurrent::TimeoutError.new)
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/timing.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  # Handles timing of things
+  #
+  # @author Mikael Henriksson <mikael@mhenrixon.com>
+  module Timing
+    module_function
+
+    #
+    # Used for timing method calls
+    #
+    #
+    # @return [yield return, Float]
+    #
+    def timed
+      start_time = time_source.call
+
+      [yield, time_source.call - start_time]
+    end
+
+    #
+    # Used to get a current representation of time as Integer
+    #
+    #
+    # @return [Integer]
+    #
+    def time_source
+      -> { (clock_stamp * 1000).to_i }
+    end
+
+    #
+    # Returns the current time as float
+    #
+    # @see SidekiqUniqueJobs.now_f
+    #
+    # @return [Float]
+    #
+    def now_f
+      SidekiqUniqueJobs.now_f
+    end
+
+    #
+    # Returns a float representation of the current time.
+    #   Either from Process or Time
+    #
+    #
+    # @return [Float]
+    #
+    def clock_stamp
+      if Process.const_defined?("CLOCK_MONOTONIC")
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      else
+        now_f
+      end
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/unlockable.rb

@@ -4,23 +4,39 @@ module SidekiqUniqueJobs
   # Utility module to help manage unique keys in redis.
   # Useful for deleting keys that for whatever reason wasn't deleted
   #
-  # @author Mikael Henriksson <mikael@zoolutions.se>
+  # @author Mikael Henriksson <mikael@mhenrixon.com>
   module Unlockable
     module_function
 
     # Unlocks a job.
     # @param [Hash] item a Sidekiq job hash
     def unlock(item)
-      SidekiqUniqueJobs::UniqueArgs.digest(item)
+      SidekiqUniqueJobs::Job.add_digest(item)
       SidekiqUniqueJobs::Locksmith.new(item).unlock
     end
 
-    # Deletes a lock regardless of if it was locked or not.
+    # Unlocks a job.
+    # @param [Hash] item a Sidekiq job hash
+    def unlock!(item)
+      SidekiqUniqueJobs::Job.add_digest(item)
+      SidekiqUniqueJobs::Locksmith.new(item).unlock!
+    end
+
+    # Deletes a lock unless it has ttl
     #
     # This is good for situations when a job is locked by another item
     # @param [Hash] item a Sidekiq job hash
     def delete(item)
-      SidekiqUniqueJobs::UniqueArgs.digest(item)
+      SidekiqUniqueJobs::Job.add_digest(item)
+      SidekiqUniqueJobs::Locksmith.new(item).delete
+    end
+
+    # Deletes a lock regardless of if it was locked or has ttl.
+    #
+    # This is good for situations when a job is locked by another item
+    # @param [Hash] item a Sidekiq job hash
+    def delete!(item)
+      SidekiqUniqueJobs::Job.add_digest(item)
       SidekiqUniqueJobs::Locksmith.new(item).delete!
     end
   end