sidekiq-unique-jobs 6.0.7 → 7.1.33

data/lib/sidekiq_unique_jobs/lock_config.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  #
+  # Gathers all configuration for a lock
+  #   which helps reduce the amount of instance variables
+  #
+  # @author Mikael Henriksson <mikael@mhenrixon.com>
+  #
+  class LockConfig
+    #
+    # @!attribute [r] type
+    #   @return [Symbol] the type of lock
+    attr_reader :type
+    #
+    # @!attribute [r] job
+    #   @return [Symbol] the job class
+    attr_reader :job
+    #
+    # @!attribute [r] limit
+    #   @return [Integer] the number of simultaneous locks
+    attr_reader :limit
+    #
+    # @!attribute [r] timeout
+    #   @return [Integer, nil] the time to wait for a lock
+    attr_reader :timeout
+    #
+    # @!attribute [r] ttl
+    #   @return [Integer, nil] the time (in seconds) to live after successful
+    attr_reader :ttl
+    #
+    # @!attribute [r] ttl
+    #   @return [Integer, nil] the time (in milliseconds) to live after successful
+    attr_reader :pttl
+    #
+    # @!attribute [r] lock_info
+    #   @return [Boolean] indicate wether to use lock_info or not
+    attr_reader :lock_info
+    #
+    # @!attribute [r] on_conflict
+    #   @return [Symbol, Hash<Symbol, Symbol>] the strategies to use as conflict resolution
+    attr_reader :on_conflict
+    #
+    # @!attribute [r] errors
+    #   @return [Array<Hash<Symbol, Array<String>] a collection of configuration errors
+    attr_reader :errors
+
+    #
+    # Instantiate a new lock_config based on sidekiq options in worker
+    #
+    # @param [Hash] options sidekiq_options for worker
+    #
+    # @return [LockConfig]
+    #
+    def self.from_worker(options)
+      new(options.deep_stringify_keys)
+    end
+
+    def initialize(job_hash = {})
+      @type        = job_hash[LOCK]&.to_sym
+      @job         = SidekiqUniqueJobs.safe_constantize(job_hash[CLASS])
+      @limit       = job_hash.fetch(LOCK_LIMIT, 1)&.to_i
+      @timeout     = job_hash.fetch(LOCK_TIMEOUT, 0)&.to_i
+      @ttl         = job_hash.fetch(LOCK_TTL) { job_hash.fetch(LOCK_EXPIRATION, nil) }.to_i
+      @pttl        = ttl * 1_000
+      @lock_info   = job_hash.fetch(LOCK_INFO) { SidekiqUniqueJobs.config.lock_info }
+      @on_conflict = job_hash.fetch(ON_CONFLICT, nil)
+      @errors      = job_hash.fetch(ERRORS) { {} }
+
+      @on_client_conflict = job_hash[ON_CLIENT_CONFLICT]
+      @on_server_conflict = job_hash[ON_SERVER_CONFLICT]
+    end
+
+    def lock_info?
+      lock_info
+    end
+
+    #
+    # Indicate if timeout was set
+    #
+    #
+    # @return [true,false]
+    #
+    def wait_for_lock?
+      timeout.nil? || timeout.positive?
+    end
+
+    #
+    # Is the configuration valid?
+    #
+    #
+    # @return [true,false]
+    #
+    def valid?
+      errors.empty?
+    end
+
+    #
+    # Return a nice descriptive message with all validation errors
+    #
+    #
+    # @return [String]
+    #
+    def errors_as_string
+      return if valid?
+
+      @errors_as_string ||= begin
+        error_msg = +"\t"
+        error_msg << errors.map { |key, val| "#{key}: :#{val}" }.join("\n\t")
+        error_msg
+      end
+    end
+
+    # the strategy to use as conflict resolution from sidekiq client
+    def on_client_conflict
+      @on_client_conflict ||= on_conflict["client"] || on_conflict[:client] if on_conflict.is_a?(Hash)
+      @on_client_conflict ||= on_conflict
+    end
+
+    # the strategy to use as conflict resolution from sidekiq server
+    def on_server_conflict
+      @on_server_conflict ||= on_conflict["server"] || on_conflict[:server] if on_conflict.is_a?(Hash)
+      @on_server_conflict ||= on_conflict
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/lock_digest.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "openssl"
+
+module SidekiqUniqueJobs
+  # Handles uniqueness of sidekiq arguments
+  #
+  # @author Mikael Henriksson <mikael@mhenrixon.com>
+  class LockDigest
+    include SidekiqUniqueJobs::Logging
+    include SidekiqUniqueJobs::JSON
+    include SidekiqUniqueJobs::SidekiqWorkerMethods
+
+    #
+    # Generates a new digest
+    #
+    # @param [Hash] item a sidekiq job hash
+    #
+    # @return [String] a unique digest for the given arguments
+    #
+    def self.call(item)
+      new(item).lock_digest
+    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 :lock_args
+    #
+    # @!attribute [r] args
+    #   @return [String] the prefix for the unique key
+    attr_reader :lock_prefix
+
+    # @param [Hash] item a Sidekiq job hash
+    def initialize(item)
+      @item        = item
+      @lock_args   = item[LOCK_ARGS] || item[UNIQUE_ARGS] # TODO: Deprecate UNIQUE_ARGS
+      @lock_prefix = item[LOCK_PREFIX] || item[UNIQUE_PREFIX] # TODO: Deprecate UNIQUE_PREFIX
+      self.job_class = item[CLASS]
+    end
+
+    # Memoized lock_digest
+    # @return [String] a unique digest
+    def lock_digest
+      @lock_digest ||= create_digest
+    end
+
+    # Creates a namespaced unique digest based on the {#digestable_hash} and the {#lock_prefix}
+    # @return [String] a unique digest
+    def create_digest
+      digest = OpenSSL::Digest::MD5.hexdigest(dump_json(digestable_hash.sort))
+      "#{lock_prefix}:#{digest}"
+    end
+
+    # Filter a hash to use for digest
+    # @return [Hash] to use for digest
+    def digestable_hash
+      @item.slice(CLASS, QUEUE, LOCK_ARGS, APARTMENT).tap do |hash|
+        hash.delete(QUEUE) if unique_across_queues?
+        hash.delete(CLASS) if unique_across_workers?
+      end
+    end
+
+    # Checks if we should disregard the queue when creating the unique digest
+    # @return [true, false]
+    def unique_across_queues?
+      item[UNIQUE_ACROSS_QUEUES] || job_options[UNIQUE_ACROSS_QUEUES]
+    end
+
+    # Checks if we should disregard the worker when creating the unique digest
+    # @return [true, false]
+    def unique_across_workers?
+      item[UNIQUE_ACROSS_WORKERS] || job_options[UNIQUE_ACROSS_WORKERS]
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/lock_info.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  #
+  # Class Info provides information about a lock
+  #
+  # @author Mikael Henriksson <mikael@mhenrixon.com>
+  #
+  class LockInfo < Redis::String
+    #
+    # Returns the value for this key as a hash
+    #
+    #
+    # @return [Hash]
+    #
+    def value
+      @value ||= load_json(super)
+    end
+
+    #
+    # Check if this redis string is blank
+    #
+    #
+    # @return [Boolean]
+    #
+    def none?
+      value.nil? || value.empty?
+    end
+
+    #
+    # Check if this redis string has a value
+    #
+    #
+    # @return [Boolean]
+    #
+    def present?
+      !none?
+    end
+
+    #
+    # Quick access to the hash members for the value
+    #
+    # @param [String, Symbol] key the key who's value to retrieve
+    #
+    # @return [Object]
+    #
+    def [](key)
+      value[key.to_s] if value.is_a?(Hash)
+    end
+
+    #
+    # Writes the lock info to redis
+    #
+    # @param [Hash] obj the information to store at key
+    #
+    # @return [Hash]
+    #
+    def set(obj, pipeline = nil)
+      return unless SidekiqUniqueJobs.config.lock_info
+      raise InvalidArgument, "argument `obj` (#{obj}) needs to be a hash" unless obj.is_a?(Hash)
+
+      json = dump_json(obj)
+      @value = load_json(json)
+      super(json, pipeline)
+      value
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/lock_timeout.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  # Calculates timeout and expiration
+  #
+  # @author Mikael Henriksson <mikael@mhenrixon.com>
+  class LockTimeout
+    # includes "SidekiqUniqueJobs::SidekiqWorkerMethods"
+    # @!parse include SidekiqUniqueJobs::SidekiqWorkerMethods
+    include SidekiqUniqueJobs::SidekiqWorkerMethods
+
+    #
+    # Calculates the timeout for a Sidekiq job
+    #
+    # @param [Hash] item sidekiq job hash
+    #
+    # @return [Integer] timeout in seconds
+    #
+    def self.calculate(item)
+      new(item).calculate
+    end
+
+    # @!attribute [r] item
+    #   @return [Hash] the Sidekiq job hash
+    attr_reader :item
+
+    # @param [Hash] item the Sidekiq job hash
+    # @option item [Integer, nil] :lock_ttl the configured lock expiration
+    # @option item [Integer, nil] :lock_timeout the configured lock timeout
+    # @option item [String] :class the class of the sidekiq worker
+    # @option item [Float] :at the unix time the job is scheduled at
+    def initialize(item)
+      @item = item
+      self.job_class = item[CLASS]
+    end
+
+    #
+    # Finds a lock timeout in either of
+    #  default worker options, {default_lock_timeout} or provided worker_options
+    #
+    #
+    # @return [Integer, nil]
+    #
+    def calculate
+      timeout = default_job_options[LOCK_TIMEOUT]
+      timeout = default_lock_timeout if default_lock_timeout
+      timeout = job_options[LOCK_TIMEOUT] if job_options.key?(LOCK_TIMEOUT)
+      timeout
+    end
+
+    #
+    # The configured default_lock_timeout
+    # @see SidekiqUniqueJobs::Config#lock_timeout
+    #
+    #
+    # @return [Integer, nil]
+    #
+    def default_lock_timeout
+      SidekiqUniqueJobs.config.lock_timeout
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/lock_ttl.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  # Calculates timeout and expiration
+  #
+  # @author Mikael Henriksson <mikael@mhenrixon.com>
+  class LockTTL
+    # includes "SidekiqUniqueJobs::SidekiqWorkerMethods"
+    # @!parse include SidekiqUniqueJobs::SidekiqWorkerMethods
+    include SidekiqUniqueJobs::SidekiqWorkerMethods
+
+    #
+    # Computes lock ttl from job arguments, sidekiq_options.
+    #   Falls back to {SidekiqUniqueJobs::Config#lock_ttl}
+    #
+    # @note this method takes into consideration the time
+    #   until a job is scheduled
+    #
+    #
+    # @return [Integer] the number of seconds to live
+    #
+    def self.calculate(item)
+      new(item).calculate
+    end
+
+    # @!attribute [r] item
+    #   @return [Hash] the Sidekiq job hash
+    attr_reader :item
+
+    # @param [Hash] item the Sidekiq job hash
+    # @option item [Integer, nil] :lock_ttl the configured lock expiration
+    # @option item [Integer, nil] :lock_timeout the configured lock timeout
+    # @option item [String] :class the class of the sidekiq worker
+    # @option item [Float] :at the unix time the job is scheduled at
+    def initialize(item)
+      @item = item
+      self.job_class = item[CLASS]
+    end
+
+    #
+    # Calculates the time until the job is scheduled starting from now
+    #
+    #
+    # @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
+
+    # The time a job is scheduled
+    # @return [Float] the exact unix time the job is scheduled at
+    def scheduled_at
+      @scheduled_at ||= item[AT]
+    end
+
+    #
+    # Computes lock ttl from job arguments, sidekiq_options.
+    #   Falls back to {SidekiqUniqueJobs::Config#lock_ttl}
+    #
+    # @note this method takes into consideration the time
+    #   until a job is scheduled
+    #
+    #
+    # @return [Integer] the number of seconds to live
+    #
+    def calculate
+      ttl = item[LOCK_TTL]
+      ttl ||= job_options[LOCK_TTL]
+      ttl ||= item[LOCK_EXPIRATION] # TODO: Deprecate at some point
+      ttl ||= job_options[LOCK_EXPIRATION] # TODO: Deprecate at some point
+      ttl ||= SidekiqUniqueJobs.config.lock_ttl
+      ttl && (ttl.to_i + time_until_scheduled)
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/lock_type.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  # Calculates the lock type
+  #
+  class LockType
+    # includes "SidekiqUniqueJobs::SidekiqWorkerMethods"
+    # @!parse include SidekiqUniqueJobs::SidekiqWorkerMethods
+    include SidekiqUniqueJobs::SidekiqWorkerMethods
+
+    #
+    # Computes lock type from job arguments, sidekiq_options.
+    #
+    # @return [Symbol] the lock type
+    # @return [NilClass] if no lock type is found.
+    #
+    def self.call(item)
+      new(item).call
+    end
+
+    # @!attribute [r] item
+    #   @return [Hash] the Sidekiq job hash
+    attr_reader :item
+
+    # @param [Hash] item the Sidekiq job hash
+    # @option item [Symbol, nil] :lock the type of lock to use.
+    # @option item [String] :class the class of the sidekiq worker
+    def initialize(item)
+      @item = item
+      self.job_class = item[CLASS]
+    end
+
+    def call
+      item[LOCK] || job_options[LOCK] || default_job_options[LOCK]
+    end
+  end
+end