sidekiq-unique-jobs 6.0.6 → 6.0.25

data/lib/sidekiq_unique_jobs/scripts.rb

@@ -1,29 +1,35 @@
 # frozen_string_literal: true
 
-require 'pathname'
-require 'digest/sha1'
-require 'concurrent/map'
+require "pathname"
+require "digest/sha1"
+require "concurrent/map"
 
 module SidekiqUniqueJobs
   # Interface to dealing with .lua files
   #
   # @author Mikael Henriksson <mikael@zoolutions.se>
   module Scripts
-    LUA_PATHNAME ||= Pathname.new(__FILE__).dirname.join('../../redis').freeze
+    LUA_PATHNAME ||= Pathname.new(__FILE__).dirname.join("../../redis").freeze
     SCRIPT_SHAS ||= Concurrent::Map.new
 
     include SidekiqUniqueJobs::Connection
 
     module_function
 
+    #
     # Call a lua script with the provided file_name
+    #
+    # @note this method is recursive if we need to load a lua script
+    #   that wasn't previously loaded.
+    #
     # @param [Symbol] file_name the name of the lua script
     # @param [Sidekiq::RedisConnection, ConnectionPool] redis_pool the redis connection
     # @param [Hash] options arguments to pass to the script file
     # @option options [Array] :keys the array of keys to pass to the script
     # @option options [Array] :argv the array of arguments to pass to the script
-    # @note this method is recursive if we need to load a lua script
-    #   that wasn't previously loaded.
+    #
+    # @return value from script
+    #
     def call(file_name, redis_pool, options = {})
       execute_script(file_name, redis_pool, options)
     rescue Redis::CommandError => ex
@@ -32,12 +38,17 @@ module SidekiqUniqueJobs
       end
     end
 
+    #
     # Execute the script file
+    #
     # @param [Symbol] file_name the name of the lua script
     # @param [Sidekiq::RedisConnection, ConnectionPool] redis_pool the redis connection
     # @param [Hash] options arguments to pass to the script file
     # @option options [Array] :keys the array of keys to pass to the script
     # @option options [Array] :argv the array of arguments to pass to the script
+    #
+    # @return value from script (evalsha)
+    #
     def execute_script(file_name, redis_pool, options = {})
       redis(redis_pool) do |conn|
         sha = script_sha(conn, file_name)
@@ -45,10 +56,15 @@ module SidekiqUniqueJobs
       end
     end
 
+    #
     # Return sha of already loaded lua script or load it and return the sha
+    #
     # @param [Sidekiq::RedisConnection] conn the redis connection
     # @param [Symbol] file_name the name of the lua script
     # @return [String] sha of the script file
+    #
+    # @return [String] the sha of the script
+    #
     def script_sha(conn, file_name)
       if (sha = SCRIPT_SHAS.get(file_name))
         return sha
@@ -59,12 +75,17 @@ module SidekiqUniqueJobs
       sha
     end
 
-    # Return sha of already loaded lua script or load it and return the sha
+    #
+    # Handle errors to allow retrying errors that need retrying
+    #
     # @param [Redis::CommandError] ex exception to handle
     # @param [Symbol] file_name the name of the lua script
-    # @raise [ScriptError] when the error isn't handled
+    #
+    # @return [void]
+    #
+    # @yieldreturn [void] yields back to the caller when NOSCRIPT is raised
     def handle_error(ex, file_name)
-      if ex.message == 'NOSCRIPT No matching script. Please use EVAL.'
+      if ex.message == "NOSCRIPT No matching script. Please use EVAL."
         SCRIPT_SHAS.delete(file_name)
         return yield if block_given?
       end
@@ -72,16 +93,24 @@ module SidekiqUniqueJobs
       raise ScriptError, file_name: file_name, source_exception: ex
     end
 
+    #
     # Reads the lua file from disk
+    #
     # @param [Symbol] file_name the name of the lua script
+    #
     # @return [String] the content of the lua file
+    #
     def script_source(file_name)
       script_path(file_name).read
     end
 
+    #
     # Construct a Pathname to a lua script
+    #
     # @param [Symbol] file_name the name of the lua script
+    #
     # @return [Pathname] the full path to the gems lua script
+    #
     def script_path(file_name)
       LUA_PATHNAME.join("#{file_name}.lua")
     end

data/lib/sidekiq_unique_jobs/server/middleware.rb

@@ -6,28 +6,40 @@ module SidekiqUniqueJobs
     #
     # @author Mikael Henriksson <mikael@zoolutions.se>
     class Middleware
+      include Logging
       include OptionsWithFallback
 
-      # Runs the server middleware
-      #   Used from Sidekiq::Processor#process
+      #
+      #
+      # Runs the server middleware (used from Sidekiq::Processor#process)
+      #
       # @param [Sidekiq::Worker] worker_class
       # @param [Hash] item a sidekiq job hash
       # @param [String] queue name of the queue
+      #
+      # @see https://github.com/mperham/sidekiq/wiki/Job-Format
+      # @see https://github.com/mperham/sidekiq/wiki/Middleware
+      #
       # @yield when uniqueness is disabled
-      # @yield when the lock class executes successfully
+      # @yield when the lock is acquired
       def call(worker_class, item, queue)
         @worker_class = worker_class
         @item         = item
         @queue        = queue
         return yield if unique_disabled?
 
-        lock.execute do
-          yield
+        SidekiqUniqueJobs::Job.add_uniqueness(item)
+        SidekiqUniqueJobs.with_context(logging_context(self.class, item)) do
+          lock.execute do
+            yield
+          end
         end
       end
 
-      protected
+      private
 
+      # The sidekiq job hash
+      # @return [Hash] the Sidekiq job hash
       attr_reader :item
     end
   end

data/lib/sidekiq_unique_jobs/sidekiq_unique_ext.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'sidekiq/api'
+require "sidekiq/api"
 
 module Sidekiq
   class SortedEntry

data/lib/sidekiq_unique_jobs/sidekiq_unique_jobs.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+#
+# Contains configuration and utility methods that belongs top level
+#
+# @author Mikael Henriksson <mikael@zoolutions.se>
+module SidekiqUniqueJobs
+  include SidekiqUniqueJobs::Connection
+
+  module_function
+
+  Config = Concurrent::MutableStruct.new(
+    :default_lock_timeout,
+    :enabled,
+    :unique_prefix,
+    :logger,
+  )
+
+  # The current configuration (See: {.configure} on how to configure)
+  def config
+    # Arguments here need to match the definition of the new class (see above)
+    @config ||= Config.new(
+      0,
+      true,
+      "uniquejobs",
+      Sidekiq.logger,
+    )
+  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
+  end
+
+  # Set a new logger
+  # @param [Logger] other a new logger
+  def logger=(other)
+    config.logger = other
+  end
+
+  # Change global configuration while yielding
+  # @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
+    configure(tmp_config)
+    yield
+    configure(old_config)
+  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 [true,false] :enabled (default is true)
+  # @option options [String] :unique_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
+
+  def redis_version
+    @redis_version ||= redis { |conn| conn.info("server")["redis_version"] }
+  end
+end

data/lib/sidekiq_unique_jobs/sidekiq_worker_methods.rb

@@ -15,6 +15,7 @@ module SidekiqUniqueJobs
     # @return [Hash] of the worker class sidekiq options
     def worker_options
       return {} unless sidekiq_worker_class?
+
       worker_class.get_sidekiq_options.stringify_keys
     end
 
@@ -28,21 +29,29 @@ module SidekiqUniqueJobs
     # The Sidekiq::Worker implementation
     # @return [Sidekiq::Worker]
     def worker_class
-      @_worker_class ||= worker_class_constantize # rubocop:disable Naming/MemoizedInstanceVariableName
+      @_worker_class ||= worker_class_constantize(@worker_class) # 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 = @worker_class)
-      return klazz unless klazz.is_a?(String)
+    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

data/lib/sidekiq_unique_jobs/testing.rb

@@ -2,8 +2,8 @@
 
 # :nocov:
 
-require 'sidekiq'
-require 'sidekiq/testing'
+require "sidekiq"
+require "sidekiq/testing"
 
 module Sidekiq
   def self.use_options(tmp_config = {})
@@ -52,7 +52,7 @@ module Sidekiq
       module Testing
         def clear_all_ext
           clear_all_orig
-          SidekiqUniqueJobs::Util.del('*', 1000)
+          SidekiqUniqueJobs::Util.del("*", 1000)
         end
       end
     end

data/lib/sidekiq_unique_jobs/timeout/calculator.rb

@@ -25,6 +25,7 @@ module SidekiqUniqueJobs
       # @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
 
@@ -39,7 +40,7 @@ module SidekiqUniqueJobs
         @lock_expiration ||= begin
           expiration = item[LOCK_EXPIRATION_KEY]
           expiration ||= worker_options[LOCK_EXPIRATION_KEY]
-          expiration && expiration + time_until_scheduled
+          expiration && expiration.to_i + time_until_scheduled
         end
       end
 

data/lib/sidekiq_unique_jobs/timeout.rb

@@ -5,4 +5,4 @@ module SidekiqUniqueJobs
   end
 end
 
-require 'sidekiq_unique_jobs/timeout/calculator'
+require "sidekiq_unique_jobs/timeout/calculator"

data/lib/sidekiq_unique_jobs/unique_args.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-require 'digest'
-require 'sidekiq_unique_jobs/normalizer'
+require "digest"
+require "openssl"
+require "sidekiq_unique_jobs/normalizer"
 
 module SidekiqUniqueJobs
   # Handles uniqueness of sidekiq arguments
@@ -47,7 +48,7 @@ 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 = Digest::MD5.hexdigest(Sidekiq.dump_json(digestable_hash))
+      digest = OpenSSL::Digest::MD5.hexdigest(Sidekiq.dump_json(digestable_hash))
       "#{unique_prefix}:#{digest}"
     end
 
@@ -60,7 +61,7 @@ module SidekiqUniqueJobs
     # 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).tap do |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?
       end
@@ -70,6 +71,7 @@ module SidekiqUniqueJobs
     # @return [Array] the arguments filters by the {#filtered_args} method if {#unique_args_enabled?}
     def unique_args(args)
       return filtered_args(args) if unique_args_enabled?
+
       args
     end
 
@@ -99,6 +101,7 @@ module SidekiqUniqueJobs
     # @return [Array] args unfiltered when neither of the above
     def filtered_args(args)
       return args if args.empty?
+
       json_args = Normalizer.jsonify(args)
 
       case unique_args_method

data/lib/sidekiq_unique_jobs/util.rb

@@ -7,11 +7,11 @@ module SidekiqUniqueJobs
   # @author Mikael Henriksson <mikael@zoolutions.se>
   module Util
     DEFAULT_COUNT     = 1_000
-    SCAN_PATTERN      = '*'
+    SCAN_PATTERN      = "*"
 
     include SidekiqUniqueJobs::Logging
     include SidekiqUniqueJobs::Connection
-    extend self # rubocop:disable Style/ModuleFunction
+    extend self
 
     # Find unique keys in redis
     #
@@ -20,6 +20,7 @@ module SidekiqUniqueJobs
     # @return [Array<String>] an array with active unique keys
     def keys(pattern = SCAN_PATTERN, count = DEFAULT_COUNT)
       return redis(&:keys) if pattern.nil?
+
       redis { |conn| conn.scan_each(match: prefix(pattern), count: count).to_a }
     end
 
@@ -43,7 +44,8 @@ module SidekiqUniqueJobs
     # @param [Integer] count the maximum number of keys to delete
     # @return [Integer] the number of keys deleted
     def del(pattern = SCAN_PATTERN, count = 0)
-      raise ArgumentError, 'Please provide a number of keys to delete greater than zero' if count.zero?
+      raise ArgumentError, "Please provide a number of keys to delete greater than zero" if count.zero?
+
       pattern = suffix(pattern)
 
       log_debug { "Deleting keys by: #{pattern}" }
@@ -84,11 +86,13 @@ module SidekiqUniqueJobs
     def prefix(key)
       return key if unique_prefix.nil?
       return key if key.start_with?("#{unique_prefix}:")
+
       "#{unique_prefix}:#{key}"
     end
 
     def suffix(key)
-      return "#{key}*" unless key.end_with?(':*')
+      return "#{key}*" unless key.end_with?(":*")
+
       key
     end
 

data/lib/sidekiq_unique_jobs/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SidekiqUniqueJobs
-  VERSION = '6.0.6'
+  VERSION = "6.0.25"
 end

data/lib/sidekiq_unique_jobs/version_check.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  #
+  # Handles checking if a version is compliant with given constraint
+  #
+  # @author Mikael Henriksson <mikael@zoolutions.se>
+  #
+  class VersionCheck
+    PATTERN = /(?<operator1>[<>=]+)?\s?(?<version1>(\d+.?)+)(\s+&&\s+)?(?<operator2>[<>=]+)?\s?(?<version2>(\d+.?)+)?/m.freeze # rubocop:disable Layout/LineLength
+
+    #
+    # Checks if a version is consrtaint is satisfied
+    #
+    # @example A satisfied constraint
+    #   VersionCheck.satisfied?("5.0.0", ">= 4.0.0") #=> true
+    #
+    # @example An unsatisfied constraint
+    #   VersionCheck.satisfied?("5.0.0", "<= 4.0.0") #=> false
+    #
+    #
+    # @param [String] version a version string `5.0.0`
+    # @param [String] constraint a version constraint `>= 5.0.0 <= 5.1.1`
+    #
+    # @return [<type>] <description>
+    #
+    def self.satisfied?(version, constraint)
+      new(version, constraint).satisfied?
+    end
+
+    #
+    # @!attribute [r] version
+    #   @return [String] a version string `5.0.0`
+    attr_reader :version
+    #
+    # @!attribute [r] match
+    #   @return [String] a version constraint `>= 5.0.0 <= 5.1.1`
+    attr_reader :match
+
+    #
+    # Initialize a new VersionCheck instance
+    #
+    # @param [String] version a version string `5.0.0`
+    # @param [String] constraint a version constraint `>= 5.0.0 <= 5.1.1`
+    #
+    def initialize(version, constraint)
+      @version   = Gem::Version.new(version)
+      @match     = PATTERN.match(constraint.to_s)
+
+      raise ArgumentError, "A version (eg. 5.0) is required to compare against" unless @version
+      raise ArgumentError, "At least one operator and version is required (eg. >= 5.1)" unless constraint
+    end
+
+    #
+    # Checks if all constraints were met
+    #
+    #
+    # @return [true,false]
+    #
+    def satisfied?
+      constraints.all? do |expected, operator|
+        compare(expected, operator)
+      end
+    end
+
+    private
+
+    def compare(expected, operator)
+      Gem::Version.new(version).send(operator, Gem::Version.new(expected))
+    end
+
+    def constraints
+      result = { version_one => operator_one }
+      result[version_two] = operator_two if version_two
+
+      result
+    end
+
+    def version_one
+      match[:version1]
+    end
+
+    def operator_one
+      match[:operator1]
+    end
+
+    def version_two
+      match[:version2]
+    end
+
+    def operator_two
+      match[:operator2]
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/web/helpers.rb

@@ -3,7 +3,7 @@
 module SidekiqUniqueJobs
   module Web
     module Helpers
-      VIEW_PATH = File.expand_path('../web/views', __dir__)
+      VIEW_PATH = File.expand_path("../web/views", __dir__)
 
       def unique_template(name)
         File.open(File.join(VIEW_PATH, "#{name}.erb")).read
@@ -19,8 +19,9 @@ module SidekiqUniqueJobs
 
         params.merge(options).map do |key, value|
           next unless SAFE_CPARAMS.include?(key)
+
           "#{key}=#{CGI.escape(value.to_s)}"
-        end.compact.join('&')
+        end.compact.join("&")
       end
 
       def redirect_to(subpath)
@@ -35,10 +36,10 @@ module SidekiqUniqueJobs
 
       def safe_relative_time(time)
         time = if time.is_a?(Numeric)
-                 Time.at(time)
-               else
-                 Time.parse(time)
-               end
+          Time.at(time)
+        else
+          Time.parse(time)
+        end
 
         relative_time(time)
       end

data/lib/sidekiq_unique_jobs/web/views/unique_digests.erb

@@ -38,5 +38,9 @@
         </tr>
       <% end %>
     </table>
+
+    <form action="<%= root_path %>unique_digests/delete_all" method="get">
+      <input class="btn btn-danger btn-xs" type="submit" name="delete_all" value="<%= t('DeleteAll') %>" data-confirm="<%= t('AreYouSure') %>" />
+    </form>
   </div>
 <% end %>

data/lib/sidekiq_unique_jobs/web.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
 begin
-  require 'sidekiq/web'
-rescue LoadError # rubocop:disable Lint/HandleExceptions
+  require "delegate"
+  require "rack"
+  require "sidekiq/web"
+rescue LoadError
   # client-only usage
 end
 
-require_relative 'web/helpers'
+require_relative "web/helpers"
 
 module SidekiqUniqueJobs
   # Utility module to help manage unique keys in redis.
@@ -19,27 +21,32 @@ module SidekiqUniqueJobs
         include Web::Helpers
       end
 
-      app.get '/unique_digests' do
-        @filter         = params[:filter] || '*'
-        @filter         = '*' if @filter == ''
+      app.get "/unique_digests" do
+        @filter         = params[:filter] || "*"
+        @filter         = "*" if @filter == ""
         @count          = (params[:count] || 100).to_i
         @current_cursor = params[:cursor]
         @prev_cursor    = params[:prev_cursor]
         @total_size, @next_cursor, @unique_digests =
-          Digests.page(pattern: @filter, cursor: @current_cursor, page_size: @count)
+          SidekiqUniqueJobs::Digests.page(pattern: @filter, cursor: @current_cursor, page_size: @count)
 
         erb(unique_template(:unique_digests))
       end
 
-      app.get '/unique_digests/:digest' do
+      app.get "/unique_digests/delete_all" do
+        SidekiqUniqueJobs::Digests.delete_by_pattern("*", count: SidekiqUniqueJobs::Digests.count)
+        redirect_to :unique_digests
+      end
+
+      app.get "/unique_digests/:digest" do
         @digest = params[:digest]
-        @unique_keys = Util.keys("#{@digest}*", 1000)
+        @unique_keys = SidekiqUniqueJobs::Util.keys("#{@digest}*", 1000)
 
         erb(unique_template(:unique_digest))
       end
 
-      app.get '/unique_digests/:digest/delete' do
-        Digests.del(digest: params[:digest])
+      app.get "/unique_digests/:digest/delete" do
+        SidekiqUniqueJobs::Digests.delete_by_digest(params[:digest])
         redirect_to :unique_digests
       end
     end
@@ -48,6 +55,6 @@ end
 
 if defined?(Sidekiq::Web)
   Sidekiq::Web.register SidekiqUniqueJobs::Web
-  Sidekiq::Web.tabs['Unique Digests'] = 'unique_digests'
+  Sidekiq::Web.tabs["Unique Digests"] = "unique_digests"
   # Sidekiq::Web.settings.locales << File.join(File.dirname(__FILE__), 'locales')
 end