sidekiq-unique-jobs 3.0.11 → 8.0.10

data/lib/sidekiq_unique_jobs/reflectable.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  #
+  # Module Reflectable provides a method to notify subscribers
+  #
+  # @author Mikael Henriksson <mikael@mhenrixon.com>
+  #
+  module Reflectable
+    #
+    # Reflects on specific event
+    #
+    # @param [Symbol] reflection the reflected event
+    # @param [Array] args arguments to provide to reflector
+    #
+    # @return [void]
+    #
+    def reflect(reflection, *args)
+      SidekiqUniqueJobs.reflections.dispatch(reflection, *args)
+      nil
+    rescue UniqueJobsError => ex
+      SidekiqUniqueJobs.logger.error(ex)
+      nil
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/reflections.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  #
+  # Class NotificationCollection provides a collection with known notifications
+  #
+  # @author Mikael Henriksson <mikael@mhenrixon.com>
+  #
+  class Reflections
+    #
+    # @return [Array<Symbol>] list of notifications
+    REFLECTIONS = [
+      :after_unlock_callback_failed,
+      :debug,
+      :duplicate,
+      :error,
+      :execution_failed,
+      :lock_failed,
+      :locked,
+      :reschedule_failed,
+      :rescheduled,
+      :timeout,
+      :unknown_sidekiq_worker,
+      :unlock_failed,
+      :unlocked,
+    ].freeze
+
+    #
+    # @return [Hash<Symbol, Array<Symbol, String>>] a hash with deprecated notifications
+    DEPRECATIONS = {}.freeze
+
+    REFLECTIONS.each do |reflection|
+      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        def #{reflection}(*args, &block)                            # def unlock_failed(*args, &block)
+          raise NoBlockGiven, "block required" unless block_given?  #   raise NoBlockGiven, "block required" unless block_given?
+          @reflections[:#{reflection}] = block                      #   @notifications[:unlock_failed] = block
+        end                                                         # end
+      RUBY
+    end
+
+    def initialize
+      @reflections = {}
+    end
+
+    #
+    # Dispatch a reflected event
+    #
+    # @param [reflection] reflection the reflected event
+    # @param [Array] args the arguments to provide to the block
+    #
+    # @return [void] <description>
+    #
+    def dispatch(reflection, *args) # rubocop:disable Metrics/MethodLength
+      if (block = @reflections[reflection])
+        block.call(*args)
+
+        if DEPRECATIONS.key?(reflection)
+          replacement, removal_version = DEPRECATIONS[reflection]
+          SidekiqUniqueJobs::Deprecation.warn(
+            "#{reflection} is deprecated and will be removed in version #{removal_version}." \
+            " Use #{replacement} instead.",
+          )
+        end
+      elsif misconfigured?(reflection)
+        raise NoSuchNotificationError, reflection
+      end
+
+      nil
+    end
+
+    def configured?(reflection)
+      REFLECTIONS.include?(reflection)
+    end
+
+    def misconfigured?(reflection)
+      !configured?(reflection)
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/rspec/matchers/have_valid_sidekiq_options.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  module RSpec
+    #
+    # Module Matchers provides RSpec matcher for your workers
+    #
+    # @author Mikael Henriksson <mikael@mhenrixon.com>
+    #
+    module Matchers
+      #
+      # Class HaveValidSidekiqOptions validates the unique/lock configuration for a worker.
+      #
+      # @author Mikael Henriksson <mikael@mhenrixon.com>
+      #
+      class HaveValidSidekiqOptions
+        attr_reader :worker, :lock_config, :sidekiq_options
+
+        def matches?(worker)
+          @worker          = worker
+          @sidekiq_options = worker.get_sidekiq_options
+          @lock_config     = SidekiqUniqueJobs.validate_worker(sidekiq_options)
+          lock_config.valid?
+        end
+
+        # :nodoc:
+        def failure_message
+          <<~FAILURE_MESSAGE
+            Expected #{worker} to have valid sidekiq options but found the following problems:
+            #{lock_config.errors_as_string}
+          FAILURE_MESSAGE
+        end
+
+        # :nodoc:
+        def description
+          "have valid sidekiq options"
+        end
+      end
+
+      #
+      # RSpec matcher method for validating that a sidekiq worker has valid unique/lock configuration
+      #
+      #
+      # @return [HaveValidSidekiqOptions] an RSpec matcher
+      #
+      def have_valid_sidekiq_options(*args) # rubocop:disable Naming/PredicateName
+        HaveValidSidekiqOptions.new(*args)
+      end
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/rspec/matchers.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  #
+  # We all know what the hell RSpec is no?
+  #
+  # @author Mikael Henriksson <mikael@mhenrixon.com>
+  #
+  module RSpec
+    #
+    # Module Matchers provides RSpec matcher for your workers
+    #
+    # @author Mikael Henriksson <mikael@mhenrixon.com>
+    #
+    module Matchers
+    end
+  end
+end
+
+if defined?(RSpec)
+  require_relative "matchers/have_valid_sidekiq_options"
+
+  RSpec.configure do |config|
+    config.include SidekiqUniqueJobs::RSpec::Matchers
+  end
+end

data/lib/sidekiq_unique_jobs/script/caller.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  # Interface to dealing with .lua files
+  #
+  # @author Mikael Henriksson <mikael@mhenrixon.com>
+  module Script
+    #
+    # Module Caller provides the convenience method #call_script
+    #
+    # @author Mikael Henriksson <mikael@mhenrixon.com>
+    #
+    module Caller
+      module_function
+
+      # includes "SidekiqUniqueJobs::Connection"
+      # @!parse include SidekiqUniqueJobs::Connection
+      include SidekiqUniqueJobs::Connection
+
+      #
+      # Convenience method to reduce typing,
+      #   calls redis lua scripts.
+      #
+      #
+      # @overload call_script(file_name, keys, argv, conn)
+      #   Call script without options hash
+      #   @param [Symbol] file_name the name of the file
+      #   @param [Array<String>] keys to pass to the the script
+      #   @param [Array<String>] argv arguments to pass to the script
+      #   @param [Redis] conn a redis connection
+      # @overload call_script(file_name, conn, keys:, argv:)
+      #   Call script with options hash
+      #   @param [Symbol] file_name the name of the file
+      #   @param [Redis] conn a redis connection
+      #   @param [Hash] options arguments to pass to the script file
+      #   @option options [Array] :keys to pass to the script
+      #   @option options [Array] :argv arguments to pass to the script
+      #
+      # @return [true,false,String,Integer,Float,nil] returns the return value of the lua script
+      #
+      def call_script(file_name, *args)
+        conn, keys, argv = extract_args(*args)
+        return do_call(file_name, conn, keys, argv) if conn
+
+        pool = defined?(redis_pool) ? redis_pool : nil
+
+        redis(pool) do |new_conn|
+          result = do_call(file_name, new_conn, keys, argv)
+          yield result if block_given?
+          result
+        end
+      end
+
+      # Only used to reduce a little bit of duplication
+      # @see call_script
+      def do_call(file_name, conn, keys, argv)
+        argv = argv.dup.push(now_f, debug_lua, max_history, file_name, redis_version)
+
+        SidekiqUniqueJobs::Script.execute(file_name, conn, keys: keys, argv: normalize_argv(argv))
+      end
+
+      #
+      # Utility method to allow both symbol keys and arguments
+      #
+      # @overload call_script(file_name, keys, argv, conn)
+      #   Call script without options hash
+      #   @param [Symbol] file_name the name of the file
+      #   @param [Array<String>] keys to pass to the the script
+      #   @param [Array<String>] argv arguments to pass to the script
+      #   @param [Redis] conn a redis connection
+      # @overload call_script(file_name, conn, keys:, argv:)
+      #   Call script with options hash
+      #   @param [Symbol] file_name the name of the file
+      #   @param [Redis] conn a redis connection
+      #   @param [Hash] options arguments to pass to the script file
+      #   @option options [Array] :keys to pass to the script
+      #   @option options [Array] :argv arguments to pass to the script
+      #
+      # @return [Array<Redis, Array, Array>] <description>
+      #
+      def extract_args(*args)
+        options = args.extract_options!
+        if options.length.positive?
+          [args.pop, options.fetch(:keys) { [] }, options.fetch(:argv) { [] }]
+        else
+          keys, argv = args.shift(2)
+          keys ||= []
+          argv ||= []
+          [args.pop, keys, argv]
+        end
+      end
+
+      #
+      # @see SidekiqUniqueJobs#now_f
+      #
+      def now_f
+        SidekiqUniqueJobs.now_f
+      end
+
+      #
+      # @see SidekiqUniqueJobs::Config#debug_lua
+      #
+      def debug_lua
+        SidekiqUniqueJobs.config.debug_lua
+      end
+
+      #
+      # @see SidekiqUniqueJobs::Config#max_history
+      #
+      def max_history
+        SidekiqUniqueJobs.config.max_history
+      end
+
+      #
+      # @see SidekiqUniqueJobs::Config#max_history
+      #
+      def redis_version
+        SidekiqUniqueJobs.config.redis_version
+      end
+
+      def normalize_argv(argv)
+        argv.each_with_index do |item, index|
+          case item
+          when FalseClass, NilClass
+            argv[index] = 0
+          when TrueClass
+            argv[index] = 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/script/client.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  module Script
+    # Interface to dealing with .lua files
+    #
+    # @author Mikael Henriksson <mikael@mhenrixon.com>
+    class Client
+      include SidekiqUniqueJobs::Script::Timing
+
+      #
+      # @!attribute [r] logger
+      #   @return [Logger] an instance of a logger
+      attr_reader :logger
+      #
+      # @!attribute [r] file_name
+      #   @return [String] The name of the file to execute
+      attr_reader :config
+      #
+      # @!attribute [r] scripts
+      #   @return [Scripts] the collection with loaded scripts
+      attr_reader :scripts
+
+      def initialize(config)
+        @config  = config
+        @logger  = config.logger
+        @scripts = Scripts.fetch(config.scripts_path)
+      end
+
+      #
+      # Execute a lua script with the provided script_name
+      #
+      # @note this method is recursive if we need to load a lua script
+      #   that wasn't previously loaded.
+      #
+      # @param [Symbol] script_name the name of the script to execute
+      # @param [Redis] conn the redis connection to use for execution
+      # @param [Array<String>] keys script keys
+      # @param [Array<Object>] argv script arguments
+      #
+      # @return value from script
+      #
+      def execute(script_name, conn, keys: [], argv: [])
+        result, elapsed = timed do
+          scripts.execute(script_name, conn, keys: keys, argv: argv)
+        end
+
+        logger.debug("Executed #{script_name}.lua in #{elapsed}ms")
+        result
+      rescue ::RedisClient::CommandError => ex
+        handle_error(script_name, conn, ex) do
+          execute(script_name, conn, keys: keys, argv: argv)
+        end
+      end
+
+      private
+
+      #
+      # Handle errors to allow retrying errors that need retrying
+      #
+      # @param [RedisClient::CommandError] ex exception to handle
+      #
+      # @return [void]
+      #
+      # @yieldreturn [void] yields back to the caller when NOSCRIPT is raised
+      def handle_error(script_name, conn, ex)
+        case ex.message
+        when /NOSCRIPT/
+          handle_noscript(script_name) { return yield }
+        when /BUSY/
+          handle_busy(conn) { return yield }
+        end
+
+        raise unless LuaError.intercepts?(ex)
+
+        script = scripts.fetch(script_name, conn)
+        raise LuaError.new(ex, script)
+      end
+
+      def handle_noscript(script_name)
+        scripts.delete(script_name)
+        yield
+      end
+
+      def handle_busy(conn)
+        scripts.kill(conn)
+      rescue ::RedisClient::CommandError => ex
+        logger.warn(ex)
+      ensure
+        yield
+      end
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/script/config.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  module Script
+    #
+    # Class holding gem configuration
+    #
+    # @author Mikael Henriksson <mikael@mhenrixon.com>
+    class Config
+      #
+      # @!attribute [r] logger
+      #   @return [Logger] a logger to use for debugging
+      attr_reader :logger
+      #
+      # @!attribute [r] scripts_path
+      #   @return [Pathname] a directory with lua scripts
+      attr_reader :scripts_path
+
+      #
+      # Initialize a new instance of {Config}
+      #
+      #
+      def initialize
+        @conn         = RedisClient.new
+        @logger       = Logger.new($stdout)
+        @scripts_path = nil
+      end
+
+      #
+      # Sets a value for scripts_path
+      #
+      # @param [String, Pathname] obj <description>
+      #
+      # @raise [ArgumentError] when directory does not exist
+      # @raise [ArgumentError] when argument isn't supported
+      #
+      # @return [Pathname]
+      #
+      def scripts_path=(obj)
+        raise ArgumentError, "#{obj} should be a Pathname or String" unless obj.is_a?(Pathname) || obj.is_a?(String)
+        raise ArgumentError, "#{obj} does not exist" unless Dir.exist?(obj.to_s)
+
+        @scripts_path =
+          case obj
+          when String
+            Pathname.new(obj)
+          else
+            obj
+          end
+      end
+
+      #
+      # Sets a value for logger
+      #
+      # @param [Logger] obj a logger to use
+      #
+      # @raise [ArgumentError] when given argument isn't a Logger
+      #
+      # @return [Logger]
+      #
+      def logger=(obj)
+        raise ArgumentError, "#{obj} should be a Logger" unless obj.is_a?(Logger)
+
+        @logger = obj
+      end
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/script/dsl.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  module Script
+    # Interface to dealing with .lua files
+    #
+    # @author Mikael Henriksson <mikael@mhenrixon.com>
+    module DSL
+      MUTEX = Mutex.new
+
+      def self.included(base)
+        base.class_eval do
+          extend ClassMethods
+        end
+      end
+
+      #
+      # Module ClassMethods extends the base class with necessary methods
+      #
+      # @author Mikael Henriksson <mikael@zoolutions.se>
+      #
+      module ClassMethods
+        def execute(file_name, conn, keys: [], argv: [])
+          SidekiqUniqueJobs::Script::Client
+            .new(config)
+            .execute(file_name, conn, keys: keys, argv: argv)
+        end
+
+        # Configure the gem
+        #
+        # This is usually called once at startup of an application
+        # @param [Hash] options global gem options
+        # @option options [String, Pathname] :path
+        # @option options [Logger] :logger (default is Logger.new(STDOUT))
+        # @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
+
+        #
+        # The current configuration (See: {.configure} on how to configure)
+        #
+        #
+        # @return [Script::Config] the gem configuration
+        #
+        def config
+          MUTEX.synchronize do
+            @config ||= Config.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/script/logging.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  module Script
+    # Utility module for reducing the number of uses of logger.
+    #
+    # @author Mikael Henriksson <mikael@mhenrixon.com>
+    module Logging
+      def self.included(base)
+        base.send(:extend, self)
+      end
+
+      #
+      # A convenience method for using the configured gem logger
+      #
+      # @see Script#.logger
+      #
+      # @return [Logger]
+      #
+      def logger
+        SidekiqUniqueJobs::Script.logger
+      end
+
+      #
+      # Logs a message at debug level
+      #
+      # @param [String, Exception] message_or_exception the message or exception to log
+      #
+      # @return [void]
+      #
+      # @yield [String, Exception] the message or exception to use for log message
+      #
+      def log_debug(message_or_exception = nil, &block)
+        logger.debug(message_or_exception, &block)
+        nil
+      end
+
+      #
+      # Logs a message at info level
+      #
+      # @param [String, Exception] message_or_exception the message or exception to log
+      #
+      # @return [void]
+      #
+      # @yield [String, Exception] the message or exception to use for log message
+      #
+      def log_info(message_or_exception = nil, &block)
+        logger.info(message_or_exception, &block)
+        nil
+      end
+
+      #
+      # Logs a message at warn level
+      #
+      # @param [String, Exception] message_or_exception the message or exception to log
+      #
+      # @return [void]
+      #
+      # @yield [String, Exception] the message or exception to use for log message
+      #
+      def log_warn(message_or_exception = nil, &block)
+        logger.warn(message_or_exception, &block)
+        nil
+      end
+
+      #
+      # Logs a message at error level
+      #
+      # @param [String, Exception] message_or_exception the message or exception to log
+      #
+      # @return [void]
+      #
+      # @yield [String, Exception] the message or exception to use for log message
+      #
+      def log_error(message_or_exception = nil, &block)
+        logger.error(message_or_exception, &block)
+        nil
+      end
+
+      #
+      # Logs a message at fatal level
+      #
+      # @param [String, Exception] message_or_exception the message or exception to log
+      #
+      # @return [void]
+      #
+      # @yield [String, Exception] the message or exception to use for log message
+      #
+      def log_fatal(message_or_exception = nil, &block)
+        logger.fatal(message_or_exception, &block)
+        nil
+      end
+    end
+  end
+end