sidekiq-unique-jobs 6.0.25 → 7.0.0.beta2

data/lib/sidekiq_unique_jobs/sidekiq_worker_methods.rb

@@ -29,28 +29,21 @@ 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
-      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
+      -> { worker_class.after_unlock if worker_method_defined?(:after_unlock) }
     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)
+    def worker_class_constantize(klazz = @worker_class)
+      return klazz unless klazz.is_a?(String)
 
       Object.const_get(klazz)
     rescue NameError => ex
@@ -62,6 +55,12 @@ module SidekiqUniqueJobs
       end
     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,11 +1,26 @@
 # 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
     default_worker_options.clear
@@ -17,20 +32,37 @@ module Sidekiq
     self.default_worker_options = old_config
   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)
 
         yield
       ensure
+        self.sidekiq_options_hash = Sidekiq.default_worker_options
         sidekiq_options(old_config)
       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 +70,25 @@ 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
+      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.del(pattern: "*", count: 1_000)
       end
     end
 
-    include Overrides
+    prepend Overrides
   end
 end

data/lib/sidekiq_unique_jobs/time_calculator.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  # Calculates timeout and expiration
+  #
+  # @author Mikael Henriksson <mikael@zoolutions.se>
+  class TimeCalculator
+    # includes "SidekiqUniqueJobs::SidekiqWorkerMethods"
+    # @!parse include SidekiqUniqueJobs::SidekiqWorkerMethods
+    include SidekiqUniqueJobs::SidekiqWorkerMethods
+
+    # @!attribute [r] item
+    #   @return [Hash] the Sidekiq job hash
+    attr_reader :item
+
+    # @param [Hash] item the Sidekiq job hash
+    # @option item [Integer, nil] :lock_ttl the configured lock expiration
+    # @option item [Integer, nil] :lock_timeout the configured lock timeout
+    # @option item [String] :class the class of the sidekiq worker
+    # @option item [Float] :at the unix time the job is scheduled at
+    def initialize(item)
+      @item         = item
+      @worker_class = item[CLASS]
+    end
+
+    #
+    # Calculates the time until the job is scheduled starting from now
+    #
+    #
+    # @return [Integer] the number of seconds until job is scheduled
+    #
+    def time_until_scheduled
+      return 0 unless scheduled_at
+
+      scheduled_at.to_i - Time.now.utc.to_i
+    end
+
+    # The time a job is scheduled
+    # @return [Float] the exact unix time the job is scheduled at
+    def scheduled_at
+      @scheduled_at ||= item[AT]
+    end
+
+    #
+    # Computes lock ttl from job arguments, sidekiq_options.
+    #   Falls back to {default_lock_ttl}
+    #
+    # @note this method takes into consideration the time
+    #   until a job is scheduled
+    #
+    #
+    # @return [Integer] the number of seconds to live
+    #
+    def lock_ttl
+      @lock_ttl ||= begin
+        ttl = item[LOCK_TTL]
+        ttl ||= worker_options[LOCK_TTL]
+        ttl ||= item[LOCK_EXPIRATION] # TODO: Deprecate at some point
+        ttl ||= worker_options[LOCK_EXPIRATION] # TODO: Deprecate at some point
+        ttl ||= default_lock_ttl
+        ttl && ttl.to_i + time_until_scheduled
+      end
+    end
+
+    #
+    # Finds a lock timeout in either of
+    #  default worker options, {default_lock_timeout} or provided worker_options
+    #
+    #
+    # @return [Integer, nil]
+    #
+    def lock_timeout
+      @lock_timeout = begin
+        timeout = default_worker_options[LOCK_TIMEOUT]
+        timeout = default_lock_timeout if default_lock_timeout
+        timeout = worker_options[LOCK_TIMEOUT] if worker_options.key?(LOCK_TIMEOUT)
+        timeout
+      end
+    end
+
+    #
+    # The configured default_lock_timeout
+    # @see SidekiqUniqueJobs::Config#default_lock_timeout
+    #
+    #
+    # @return [Integer, nil]
+    #
+    def default_lock_timeout
+      SidekiqUniqueJobs.config.default_lock_timeout
+    end
+
+    #
+    # The configured default_lock_ttl
+    # @see SidekiqUniqueJobs::Config#default_lock_ttl
+    #
+    #
+    # @return [Integer, nil]
+    #
+    def default_lock_ttl
+      SidekiqUniqueJobs.config.default_lock_ttl
+    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@zoolutions.se>
+  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
+        Time.now.to_f
+      end
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/unique_args.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require "digest"
-require "openssl"
-require "sidekiq_unique_jobs/normalizer"
-
 module SidekiqUniqueJobs
   # Handles uniqueness of sidekiq arguments
   #
@@ -11,6 +7,7 @@ module SidekiqUniqueJobs
   class UniqueArgs
     include SidekiqUniqueJobs::Logging
     include SidekiqUniqueJobs::SidekiqWorkerMethods
+    include SidekiqUniqueJobs::JSON
 
     # Convenience method for returning a digest
     # @param [Hash] item a Sidekiq job hash
@@ -26,7 +23,7 @@ module SidekiqUniqueJobs
     # @param [Hash] item a Sidekiq job hash
     def initialize(item)
       @item         = item
-      @worker_class = item[CLASS_KEY]
+      @worker_class = item[CLASS]
 
       add_uniqueness_to_item
     end
@@ -34,9 +31,9 @@ module SidekiqUniqueJobs
     # Appends the keys unique_prefix, unique_args and {#unique_digest} to the sidekiq job hash {#item}
     # @return [void]
     def add_uniqueness_to_item
-      item[UNIQUE_PREFIX_KEY] ||= unique_prefix
-      item[UNIQUE_ARGS_KEY]     = unique_args(item[ARGS_KEY])
-      item[UNIQUE_DIGEST_KEY]   = unique_digest
+      item[UNIQUE_PREFIX] ||= unique_prefix
+      item[UNIQUE_ARGS]     = unique_args(item[ARGS])
+      item[UNIQUE_DIGEST]   = unique_digest
     end
 
     # Memoized unique_digest
@@ -48,22 +45,22 @@ module SidekiqUniqueJobs
     # Creates a namespaced unique digest based on the {#digestable_hash} and the {#unique_prefix}
     # @return [String] a unique digest
     def create_digest
-      digest = OpenSSL::Digest::MD5.hexdigest(Sidekiq.dump_json(digestable_hash))
+      digest = Digest::MD5.hexdigest(dump_json(digestable_hash))
       "#{unique_prefix}:#{digest}"
     end
 
     # A prefix to use as namespace for the {#unique_digest}
     # @return [String] a unique digest
     def unique_prefix
-      worker_options[UNIQUE_PREFIX_KEY] || SidekiqUniqueJobs.config.unique_prefix
+      worker_options[UNIQUE_PREFIX] || SidekiqUniqueJobs.config.unique_prefix
     end
 
     # Filter a hash to use for digest
     # @return [Hash] to use for digest
     def digestable_hash
-      @item.slice(CLASS_KEY, QUEUE_KEY, UNIQUE_ARGS_KEY, APARTMENT).tap do |hash|
-        hash.delete(QUEUE_KEY) if unique_across_queues?
-        hash.delete(CLASS_KEY) if unique_across_workers?
+      @item.slice(CLASS, QUEUE, UNIQUE_ARGS).tap do |hash|
+        hash.delete(QUEUE) if unique_across_queues?
+        hash.delete(CLASS) if unique_across_workers?
       end
     end
 
@@ -78,14 +75,13 @@ module SidekiqUniqueJobs
     # Checks if we should disregard the queue when creating the unique digest
     # @return [true, false]
     def unique_across_queues?
-      item[UNIQUE_ACROSS_QUEUES_KEY] || worker_options[UNIQUE_ACROSS_QUEUES_KEY] ||
-        item[UNIQUE_ON_ALL_QUEUES_KEY] || worker_options[UNIQUE_ON_ALL_QUEUES_KEY] # TODO: Remove in v 6.1
+      item[UNIQUE_ACROSS_QUEUES] || worker_options[UNIQUE_ACROSS_QUEUES]
     end
 
     # Checks if we should disregard the worker when creating the unique digest
     # @return [true, false]
     def unique_across_workers?
-      item[UNIQUE_ACROSS_WORKERS_KEY] || worker_options[UNIQUE_ACROSS_WORKERS_KEY]
+      item[UNIQUE_ACROSS_WORKERS] || worker_options[UNIQUE_ACROSS_WORKERS]
     end
 
     # Checks if the worker class has been enabled for unique_args?
@@ -130,21 +126,23 @@ module SidekiqUniqueJobs
       return args unless worker_method_defined?(unique_args_method)
 
       worker_class.send(unique_args_method, args)
-    rescue ArgumentError => ex
-      log_fatal(ex)
-      args
+    rescue ArgumentError
+      raise SidekiqUniqueJobs::InvalidUniqueArguments,
+            given: args,
+            worker_class: worker_class,
+            unique_args_method: unique_args_method
     end
 
     # The method to use for filtering unique arguments
     def unique_args_method
-      @unique_args_method ||= worker_options[UNIQUE_ARGS_KEY]
+      @unique_args_method ||= worker_options[UNIQUE_ARGS]
       @unique_args_method ||= :unique_args if worker_method_defined?(:unique_args)
       @unique_args_method ||= default_unique_args_method
     end
 
     # The global worker options defined in Sidekiq directly
     def default_unique_args_method
-      Sidekiq.default_worker_options.stringify_keys[UNIQUE_ARGS_KEY]
+      Sidekiq.default_worker_options.stringify_keys[UNIQUE_ARGS]
     end
   end
 end

data/lib/sidekiq_unique_jobs/unlockable.rb

@@ -12,14 +12,23 @@ module SidekiqUniqueJobs
     # @param [Hash] item a Sidekiq job hash
     def unlock(item)
       SidekiqUniqueJobs::UniqueArgs.digest(item)
-      SidekiqUniqueJobs::Locksmith.new(item).unlock
+      SidekiqUniqueJobs::Locksmith.new(item).unlock!
     end
 
-    # Deletes a lock regardless of if it was locked or not.
+    # 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::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::UniqueArgs.digest(item)
       SidekiqUniqueJobs::Locksmith.new(item).delete!
     end