sidekiq-unique-jobs 6.0.25 → 7.1.33

data/lib/sidekiq_unique_jobs/lock/validator.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  class Lock
+    #
+    # Validator base class to avoid some duplication
+    #
+    # @author Mikael Henriksson <mikael@mhenrixon.com>
+    #
+    class Validator
+      #
+      # @return [Hash] a hash mapping of deprecated keys and their new value
+      DEPRECATED_KEYS = {
+        UNIQUE.to_sym => LOCK.to_sym,
+        UNIQUE_ARGS.to_sym => LOCK_ARGS_METHOD.to_sym,
+        LOCK_ARGS.to_sym => LOCK_ARGS_METHOD.to_sym,
+        UNIQUE_PREFIX.to_sym => LOCK_PREFIX.to_sym,
+      }.freeze
+
+      #
+      # Shorthand for `new(options).validate`
+      #
+      # @param [Hash] options the sidekiq_options for the worker being validated
+      #
+      # @return [LockConfig] the lock configuration with errors if any
+      #
+      def self.validate(options)
+        new(options).validate
+      end
+
+      #
+      # @!attribute [r] lock_config
+      #   @return [LockConfig] the lock configuration for this worker
+      attr_reader :lock_config
+
+      #
+      # Initialize a new validator
+      #
+      # @param [Hash] options the sidekiq_options for the worker being validated
+      #
+      def initialize(options)
+        @options     = options.transform_keys(&:to_sym)
+        @lock_config = LockConfig.new(options)
+        handle_deprecations
+      end
+
+      #
+      # Validate the workers lock configuration
+      #
+      #
+      # @return [LockConfig] the lock configuration with errors if any
+      #
+      def validate
+        case lock_config.type
+        when :while_executing
+          validate_server
+        when :until_executing
+          validate_client
+        else
+          validate_client
+          validate_server
+        end
+
+        lock_config
+      end
+
+      #
+      # Validate deprecated keys
+      #   adds useful information about how to proceed with fixing handle_deprecations
+      #
+      # @return [void]
+      #
+      def handle_deprecations
+        DEPRECATED_KEYS.each do |old, new|
+          next unless @options.key?(old)
+
+          lock_config.errors[old] = "is deprecated, use `#{new}: #{@options[old]}` instead."
+        end
+      end
+
+      #
+      # Validates the client configuration
+      #
+      def validate_client
+        ClientValidator.validate(lock_config)
+      end
+
+      #
+      # Validates the server configuration
+      #
+      def validate_server
+        ServerValidator.validate(lock_config)
+      end
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/lock/while_executing.rb

@@ -9,9 +9,12 @@ module SidekiqUniqueJobs
     # See {#lock} for more information about the client.
     # See {#execute} for more information about the server
     #
-    # @author Mikael Henriksson <mikael@zoolutions.se>
+    # @author Mikael Henriksson <mikael@mhenrixon.com>
     class WhileExecuting < BaseLock
-      RUN_SUFFIX ||= ":RUN"
+      RUN_SUFFIX = ":RUN"
+
+      include SidekiqUniqueJobs::OptionsWithFallback
+      include SidekiqUniqueJobs::Logging::Middleware
 
       # @param [Hash] item the Sidekiq job hash
       # @param [Proc] callback callback to call after unlock
@@ -26,20 +29,29 @@ module SidekiqUniqueJobs
       #   These locks should only ever be created in the server process.
       # @return [true] always returns true
       def lock
-        true
+        job_id = item[JID]
+        yield if block_given?
+
+        job_id
       end
 
       # Executes in the Sidekiq server process.
       #   These jobs are locked in the server process not from the client
       # @yield to the worker class perform method
-      def execute
-        return strategy&.call unless locksmith.lock(item[LOCK_TIMEOUT_KEY])
-
-        yield
-        unlock_with_callback
-      rescue Exception # rubocop:disable Lint/RescueException
-        delete!
-        raise
+      def execute(&block)
+        with_logging_context do
+          executed = locksmith.execute do
+            yield
+            item[JID]
+          ensure
+            unlock_and_callback
+          end
+
+          unless executed
+            reflect(:execution_failed, item)
+            call_strategy(origin: :server, &block)
+          end
+        end
       end
 
       private
@@ -47,7 +59,9 @@ module SidekiqUniqueJobs
       # This is safe as the base_lock always creates a new digest
       #   The append there for needs to be done every time
       def append_unique_key_suffix
-        item[UNIQUE_DIGEST_KEY] = item[UNIQUE_DIGEST_KEY] + RUN_SUFFIX
+        return if (lock_digest = item[LOCK_DIGEST]).end_with?(RUN_SUFFIX)
+
+        item[LOCK_DIGEST] = lock_digest + RUN_SUFFIX
       end
     end
   end

data/lib/sidekiq_unique_jobs/lock/while_executing_reject.rb

@@ -9,12 +9,12 @@ module SidekiqUniqueJobs
     # See {#lock} for more information about the client.
     # See {#execute} for more information about the server
     #
-    # @author Mikael Henriksson <mikael@zoolutions.se>
+    # @author Mikael Henriksson <mikael@mhenrixon.com>
     class WhileExecutingReject < WhileExecuting
       # Overridden with a forced {OnConflict::Reject} strategy
       # @return [OnConflict::Reject] a reject strategy
-      def strategy
-        @strategy ||= OnConflict.find_strategy(:reject).new(item)
+      def server_strategy
+        @server_strategy ||= OnConflict.find_strategy(:reject).new(item, redis_pool)
       end
     end
   end

data/lib/sidekiq_unique_jobs/lock.rb

@@ -0,0 +1,342 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  #
+  # Class Lock provides access to information about a lock
+  #
+  # @author Mikael Henriksson <mikael@mhenrixon.com>
+  #
+  class Lock # rubocop:disable Metrics/ClassLength
+    # includes "SidekiqUniqueJobs::Connection"
+    # @!parse include SidekiqUniqueJobs::Connection
+    include SidekiqUniqueJobs::Connection
+
+    # includes "SidekiqUniqueJobs::Timing"
+    # @!parse include SidekiqUniqueJobs::Timing
+    include SidekiqUniqueJobs::Timing
+
+    # includes "SidekiqUniqueJobs::JSON"
+    # @!parse include SidekiqUniqueJobs::JSON
+    include SidekiqUniqueJobs::JSON
+
+    #
+    # @!attribute [r] key
+    #   @return [String] the entity redis key
+    attr_reader :key
+
+    #
+    # Initialize a locked lock
+    #
+    # @param [String] digest a unique digest
+    # @param [String] job_id a sidekiq JID
+    # @param [Hash] lock_info information about the lock
+    #
+    # @return [Lock] a newly lock that has been locked
+    #
+    def self.create(digest, job_id, lock_info = {})
+      lock = new(digest, time: Timing.now_f)
+      lock.lock(job_id, lock_info)
+      lock
+    end
+
+    #
+    # Initialize a new lock
+    #
+    # @param [String, Key] key either a digest or an instance of a {Key}
+    # @param [Timstamp, Float] time nil optional timestamp to initiate this lock with
+    #
+    def initialize(key, time: nil)
+      @key        = get_key(key)
+      @created_at = time.is_a?(Float) ? time : time.to_f
+    end
+
+    #
+    # Locks a job_id
+    #
+    # @note intended only for testing purposes
+    #
+    # @param [String] job_id a sidekiq JID
+    # @param [Hash] lock_info information about the lock
+    #
+    # @return [void]
+    #
+    def lock(job_id, lock_info = {})
+      redis do |conn|
+        conn.multi do |pipeline|
+          pipeline.set(key.digest, job_id)
+          pipeline.hset(key.locked, job_id, now_f)
+          info.set(lock_info, pipeline)
+          add_digest_to_set(pipeline, lock_info)
+          pipeline.zadd(key.changelog, now_f, changelog_json(job_id, "queue.lua", "Queued"))
+          pipeline.zadd(key.changelog, now_f, changelog_json(job_id, "lock.lua", "Locked"))
+        end
+      end
+    end
+
+    #
+    # Create the :QUEUED key
+    #
+    # @note intended only for testing purposes
+    #
+    # @param [String] job_id a sidekiq JID
+    #
+    # @return [void]
+    #
+    def queue(job_id)
+      redis do |conn|
+        conn.lpush(key.queued, job_id)
+      end
+    end
+
+    #
+    # Create the :PRIMED key
+    #
+    # @note intended only for testing purposes
+    #
+    # @param [String] job_id a sidekiq JID
+    #
+    # @return [void]
+    #
+    def prime(job_id)
+      redis do |conn|
+        conn.lpush(key.primed, job_id)
+      end
+    end
+
+    #
+    # Unlock a specific job_id
+    #
+    # @param [String] job_id a sidekiq JID
+    #
+    # @return [true] when job_id was removed
+    # @return [false] when job_id wasn't locked
+    #
+    def unlock(job_id)
+      locked.del(job_id)
+    end
+
+    #
+    # Deletes all the redis keys for this lock
+    #
+    #
+    # @return [Integer] the number of keys deleted in redis
+    #
+    def del
+      redis do |conn|
+        conn.multi do |pipeline|
+          pipeline.zrem(DIGESTS, key.digest)
+          pipeline.del(key.digest, key.queued, key.primed, key.locked, key.info)
+        end
+      end
+    end
+
+    #
+    # Returns either the time the lock was initialized with or
+    #   the first changelog entry's timestamp
+    #
+    #
+    # @return [Float] a floaty timestamp represantation
+    #
+    def created_at
+      @created_at ||= changelogs.first&.[]("time")
+    end
+
+    #
+    # Returns all job_id's for this lock
+    #
+    # @note a JID can be present in 3 different places
+    #
+    #
+    # @return [Array<String>] an array with JIDs
+    #
+    def all_jids
+      (queued_jids + primed_jids + locked_jids).uniq
+    end
+
+    #
+    # Returns a collection of locked job_id's
+    #
+    # @param [true, false] with_values false provide the timestamp for the lock
+    #
+    # @return [Hash<String, Float>] when given `with_values: true`
+    # @return [Array<String>] when given `with_values: false`
+    #
+    def locked_jids(with_values: false)
+      locked.entries(with_values: with_values)
+    end
+
+    #
+    # Returns the queued JIDs
+    #
+    #
+    # @return [Array<String>] an array with queued job_ids
+    #
+    def queued_jids
+      queued.entries
+    end
+
+    #
+    # Returns the primed JIDs
+    #
+    #
+    # @return [Array<String>] an array with primed job_ids
+    #
+    def primed_jids
+      primed.entries
+    end
+
+    #
+    # Returns all matching changelog entries for this lock
+    #
+    #
+    # @return [Array<Hash>] an array with changelogs
+    #
+    def changelogs
+      changelog.entries(pattern: "*#{key.digest}*")
+    end
+
+    #
+    # The digest key
+    #
+    # @note Used for exists checks to avoid enqueuing
+    #   the same lock twice
+    #
+    #
+    # @return [Redis::String] a string representation of the key
+    #
+    def digest
+      @digest ||= Redis::String.new(key.digest)
+    end
+
+    #
+    # The queued list
+    #
+    #
+    # @return [Redis::List] for queued JIDs
+    #
+    def queued
+      @queued ||= Redis::List.new(key.queued)
+    end
+
+    #
+    # The primed list
+    #
+    #
+    # @return [Redis::List] for primed JIDs
+    #
+    def primed
+      @primed ||= Redis::List.new(key.primed)
+    end
+
+    #
+    # The locked hash
+    #
+    #
+    # @return [Redis::Hash] for locked JIDs
+    #
+    def locked
+      @locked ||= Redis::Hash.new(key.locked)
+    end
+
+    #
+    # Information about the lock
+    #
+    #
+    # @return [Redis::Hash] with lock information
+    #
+    def info
+      @info ||= LockInfo.new(key.info)
+    end
+
+    #
+    # A sorted set with changelog entries
+    #
+    # @see Changelog for more information
+    #
+    #
+    # @return [Changelog]
+    #
+    def changelog
+      @changelog ||= Changelog.new
+    end
+
+    #
+    # A nicely formatted string with information about this lock
+    #
+    #
+    # @return [String]
+    #
+    def to_s
+      <<~MESSAGE
+        Lock status for #{key}
+
+                  value: #{digest.value}
+                   info: #{info.value}
+            queued_jids: #{queued_jids}
+            primed_jids: #{primed_jids}
+            locked_jids: #{locked_jids}
+             changelogs: #{changelogs}
+      MESSAGE
+    end
+
+    #
+    # @see to_s
+    #
+    def inspect
+      to_s
+    end
+
+    private
+
+    #
+    # Ensure the key is a {Key}
+    #
+    # @param [String, Key] key
+    #
+    # @return [Key]
+    #
+    def get_key(key)
+      if key.is_a?(SidekiqUniqueJobs::Key)
+        key
+      else
+        SidekiqUniqueJobs::Key.new(key)
+      end
+    end
+
+    #
+    # Generate a changelog entry for the given arguments
+    #
+    # @param [String] job_id a sidekiq JID
+    # @param [String] script the name of the script generating this entry
+    # @param [String] message a descriptive message for later review
+    #
+    # @return [String] a JSON string matching the Lua script structure
+    #
+    def changelog_json(job_id, script, message)
+      dump_json(
+        digest: key.digest,
+        job_id: job_id,
+        script: script,
+        message: message,
+        time: now_f,
+      )
+    end
+
+    #
+    # Add the digest to the correct sorted set
+    #
+    # @param [Object] pipeline a redis pipeline object for issue commands
+    # @param [Hash] lock_info the lock info relevant to the digest
+    #
+    # @return [nil]
+    #
+    def add_digest_to_set(pipeline, lock_info)
+      digest_string = key.digest
+      if lock_info["lock"] == :until_expired
+        pipeline.zadd(key.expiring_digests, now_f + lock_info["ttl"], digest_string)
+      else
+        pipeline.zadd(key.digests, now_f, digest_string)
+      end
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/lock_args.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  # Handles uniqueness of sidekiq arguments
+  #
+  # @author Mikael Henriksson <mikael@mhenrixon.com>
+  class LockArgs
+    include SidekiqUniqueJobs::Logging
+    include SidekiqUniqueJobs::SidekiqWorkerMethods
+    include SidekiqUniqueJobs::JSON
+
+    # Convenience method for returning a digest
+    # @param [Hash] item a Sidekiq job hash
+    # @return [String] a unique digest
+    def self.call(item)
+      new(item).lock_args
+    end
+
+    # The sidekiq job hash
+    # @return [Hash] the Sidekiq job hash
+    attr_reader :item
+    #
+    # @!attribute [r] args
+    #   @return [Array<Objet>] the arguments passed to `perform_async`
+    attr_reader :args
+
+    # @param [Hash] item a Sidekiq job hash
+    def initialize(item)
+      @item = item
+      @args = item[ARGS]
+      self.job_class = item[CLASS]
+    end
+
+    # The unique arguments to use for creating a lock
+    # @return [Array] the arguments filters by the {#filtered_args} method if {#lock_args_enabled?}
+    def lock_args
+      @lock_args ||= filtered_args || []
+    end
+
+    # Checks if the worker class has enabled lock_args
+    # @return [true, false]
+    def lock_args_enabled?
+      # return false unless lock_args_method_valid?
+
+      lock_args_method
+    end
+
+    # Validate that the lock_args_method is acceptable
+    # @return [true, false]
+    def lock_args_method_valid?
+      [NilClass, TrueClass, FalseClass].none? { |klass| lock_args_method.is_a?(klass) }
+    end
+
+    # Checks if the worker class has disabled lock_args
+    # @return [true, false]
+    def lock_args_disabled?
+      !lock_args_method
+    end
+
+    # Filters unique arguments by proc or symbol
+    # @return [Array] {#filter_by_proc} when {#lock_args_method} is a Proc
+    # @return [Array] {#filter_by_symbol} when {#lock_args_method} is a Symbol
+    # @return [Array] args unfiltered when neither of the above
+    def filtered_args
+      return args if lock_args_disabled?
+
+      json_args = Normalizer.jsonify(args)
+
+      case lock_args_method
+      when Proc
+        filter_by_proc(json_args)
+      when Symbol
+        filter_by_symbol(json_args)
+      end
+    end
+
+    # Filters unique arguments by proc configured in the sidekiq worker
+    # @param [Array] args the arguments passed to the sidekiq worker
+    # @return [Array] with the filtered arguments
+    def filter_by_proc(args)
+      lock_args_method.call(args)
+    end
+
+    # Filters unique arguments by method configured in the sidekiq worker
+    # @param [Array] args the arguments passed to the sidekiq worker
+    # @return [Array] unfiltered unless {#job_method_defined?}
+    # @return [Array] with the filtered arguments
+    def filter_by_symbol(args)
+      return args unless job_method_defined?(lock_args_method)
+
+      job_class.send(lock_args_method, args)
+    rescue ArgumentError
+      raise SidekiqUniqueJobs::InvalidUniqueArguments,
+            given: args,
+            job_class: job_class,
+            lock_args_method: lock_args_method
+    end
+
+    # The method to use for filtering unique arguments
+    def lock_args_method
+      @lock_args_method ||= job_options.slice(LOCK_ARGS_METHOD, UNIQUE_ARGS_METHOD).values.first
+      @lock_args_method ||= :lock_args if job_method_defined?(:lock_args)
+      @lock_args_method ||= :unique_args if job_method_defined?(:unique_args)
+      @lock_args_method ||= default_lock_args_method
+    end
+
+    # The global worker options defined in Sidekiq directly
+    def default_lock_args_method
+      default_job_options[LOCK_ARGS_METHOD] ||
+        default_job_options[UNIQUE_ARGS_METHOD]
+    end
+
+    #
+    # The globally default worker options configured from Sidekiq
+    #
+    #
+    # @return [Hash<String, Object>]
+    #
+    def default_job_options
+      @default_job_options ||= if Sidekiq.respond_to?(:default_job_options)
+        Sidekiq.default_job_options.stringify_keys
+      else
+        Sidekiq.default_worker_options.stringify_keys
+      end
+    end
+  end
+end