sidekiq-unique-jobs 4.0.18 → 7.1.28

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)
+      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,127 @@
+# 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.concat([
+                                 now_f,
+                                 debug_lua,
+                                 max_history,
+                                 file_name,
+                                 redis_version,
+                               ])
+        Script.execute(file_name, conn, keys: keys, 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
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/script.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  # Interface to dealing with .lua files
+  #
+  # @author Mikael Henriksson <mikael@mhenrixon.com>
+  module Script
+    include Brpoplpush::RedisScript::DSL
+
+    configure do |config|
+      config.scripts_path = Pathname.new(__FILE__).dirname.join("lua")
+      config.logger       = Sidekiq.logger # TODO: This becomes a little weird
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/server.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  # The unique sidekiq middleware for the server processor
+  #
+  # @author Mikael Henriksson <mikael@mhenrixon.com>
+  class Server
+    DEATH_HANDLER = (lambda do |job, _ex|
+      return unless (digest = job["lock_digest"])
+
+      SidekiqUniqueJobs::Digests.new.delete_by_digest(digest)
+    end).freeze
+    #
+    # Configure the server middleware
+    #
+    #
+    # @return [Sidekiq] the sidekiq configuration
+    #
+    def self.configure(config)
+      config.on(:startup)  { start }
+      config.on(:shutdown) { stop }
+
+      return unless config.respond_to?(:death_handlers)
+
+      config.death_handlers << death_handler
+    end
+
+    #
+    # Start the sidekiq unique jobs server process
+    #
+    #
+    # @return [void]
+    #
+    def self.start
+      SidekiqUniqueJobs::UpdateVersion.call
+      SidekiqUniqueJobs::UpgradeLocks.call
+      SidekiqUniqueJobs::Orphans::Manager.start
+      SidekiqUniqueJobs::Orphans::ReaperResurrector.start
+    end
+
+    #
+    # Stop the sidekiq unique jobs server process
+    #
+    #
+    # @return [void]
+    #
+    def self.stop
+      SidekiqUniqueJobs::Orphans::Manager.stop
+    end
+
+    #
+    # A death handler for dead jobs
+    #
+    #
+    # @return [lambda]
+    #
+    def self.death_handler
+      DEATH_HANDLER
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/sidekiq_unique_ext.rb

@@ -1,151 +1,163 @@
-require 'sidekiq/api'
+# frozen_string_literal: true
 
+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
-          include SidekiqUniqueJobs::Unlockable
-          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
-        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|
-          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 if Gem::Version.new(Sidekiq::VERSION) >= Gem::Version.new('3.1')
+    prepend UniqueExtension
   end
 
+  # See Sidekiq::Api
   class ScheduledSet
-    # rubocop:disable Style/ClassAndModuleCamelCase
-    module UniqueExtension3_0
-      def self.included(base)
-        base.class_eval do
-          include SidekiqUniqueJobs::Unlockable
-          alias_method :delete_orig, :delete
-          alias_method :delete, :delete_ext
-        end
-      end
-
-      def delete_ext(score, jid = nil)
-        item = find_job(jid)
-        unlock(item) if delete_orig(score, jid)
-      end
-
-      def remove_job_ext
-        remove_job_orig do |message|
-          unlock(Sidekiq.load_json(message))
-          yield message
-        end
+    #
+    # 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
+      #
+      #
+      # @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
 
-    module UniqueExtension3_5
-      def self.included(base)
-        base.class_eval do
-          include SidekiqUniqueJobs::Unlockable
-          alias_method :delete_orig, :delete
-          alias_method :delete, :delete_ext
-        end
-      end
-
-      def delete_ext
-        unlock(item) if delete_orig
-      end
+    prepend UniqueExtension
+  end
 
-      def remove_job_ext
-        remove_job_orig do |message|
-          unlock(Sidekiq.load_json(message))
-          yield message
+  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
-    end
-    sidekiq_version = Gem::Version.new(Sidekiq::VERSION)
-    include UniqueExtension3_5 if sidekiq_version >= Gem::Version.new('3.5')
-    include UniqueExtension3_0 if sidekiq_version >= Gem::Version.new('3.0') &&
-                                  sidekiq_version < Gem::Version.new('3.5')
-    # rubocop:enable Style/ClassAndModuleCamelCase
-  end
 
-  class Job
-    module UniqueExtension
-      def self.included(base)
-        base.class_eval do
-          include SidekiqUniqueJobs::Unlockable
-          alias_method :delete_orig, :delete
-          alias_method :delete, :delete_ext
+      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
 
-      def delete_ext
-        unlock(item)
-        delete_orig
-      end
+      prepend UniqueExtension
     end
-
-    include UniqueExtension
   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
-          include SidekiqUniqueJobs::Unlockable
-          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
-          include SidekiqUniqueJobs::Unlockable
-          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)
-        unlock(JSON.parse(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