sidekiq-unique-jobs 6.0.24 → 7.0.4

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/script/caller.rb

@@ -0,0 +1,125 @@
+# 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|
+          do_call(file_name, new_conn, keys, argv)
+        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/server.rb

@@ -0,0 +1,48 @@
+# 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
+
+    def self.start
+      SidekiqUniqueJobs::UpdateVersion.call
+      SidekiqUniqueJobs::UpgradeLocks.call
+      SidekiqUniqueJobs::Orphans::Manager.start
+    end
+
+    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

@@ -2,113 +2,140 @@
 
 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
-          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
-        SidekiqUniqueJobs::Unlockable.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|
-          SidekiqUniqueJobs::Unlockable.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
+    prepend UniqueExtension
   end
 
+  # See Sidekiq::Api
   class ScheduledSet
+    #
+    # 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
-          alias_method :delete_orig, :delete
-          alias_method :delete, :delete_ext
-        end
-      end
-
-      def delete_ext
-        SidekiqUniqueJobs::Unlockable.unlock(item) if delete_orig
+      #
+      # 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
-    include UniqueExtension
+
+    prepend UniqueExtension
   end
 
+  # See Sidekiq::Api
   class Job
+    #
+    # 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
-          alias_method :delete_orig, :delete
-          alias_method :delete, :delete_ext
-        end
-      end
-
-      def delete_ext
-        delete_orig
-        SidekiqUniqueJobs::Unlockable.unlock(item)
+      #
+      # Wraps the original method to ensure locks for the job are deleted
+      #
+      def delete
+        SidekiqUniqueJobs::Unlockable.delete!(item)
+        super
       end
     end
 
-    include UniqueExtension
+    prepend 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
-          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
-          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)
-        SidekiqUniqueJobs::Unlockable.unlock(Sidekiq.load_json(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

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>
+# @author Mikael Henriksson <mikael@mhenrixon.com>
 module SidekiqUniqueJobs
   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,59 @@ 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
+    redis { |conn| conn.info("server")["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
 end