sidekiq-unique-jobs 6.0.24 → 7.0.4

data/lib/sidekiq_unique_jobs/lock/base_lock.rb

@@ -5,10 +5,21 @@ module SidekiqUniqueJobs
     # Abstract base class for locks
     #
     # @abstract
-    # @author Mikael Henriksson <mikael@zoolutions.se>
+    # @author Mikael Henriksson <mikael@mhenrixon.com>
     class BaseLock
       include SidekiqUniqueJobs::Logging
 
+      #
+      # Validates that the sidekiq_options for the worker is valid
+      #
+      # @param [Hash] options the sidekiq_options given to the worker
+      #
+      # @return [void]
+      #
+      def self.validate_options(options = {})
+        Validator.validate(options)
+      end
+
       # @param [Hash] item the Sidekiq job hash
       # @param [Proc] callback the callback to use after unlock
       # @param [Sidekiq::RedisConnection, ConnectionPool] redis_pool the redis connection
@@ -16,21 +27,24 @@ module SidekiqUniqueJobs
         @item       = item
         @callback   = callback
         @redis_pool = redis_pool
-        add_uniqueness_when_missing # Used to ease testing
+        @attempt    = 0
+        prepare_item # Used to ease testing
+        @lock_config = LockConfig.new(item)
       end
 
-      # Handles locking of sidekiq jobs.
-      #   Will call a conflict strategy if lock can't be achieved.
-      # @return [String] the sidekiq job id
-      def lock
-        @attempt = 0
-        return item[JID_KEY] if locked?
-
-        if (token = locksmith.lock(item[LOCK_TIMEOUT_KEY]))
-          token
-        else
-          call_strategy
-        end
+      #
+      # Locks a sidekiq job
+      #
+      # @note Will call a conflict strategy if lock can't be achieved.
+      #
+      # @return [String, nil] the locked jid when properly locked, else nil.
+      #
+      # @yield to the caller when given a block
+      #
+      def lock(&block)
+        return call_strategy unless (locked_token = locksmith.lock(&block))
+
+        locked_token
       end
 
       # Execute the job in the Sidekiq server processor
@@ -43,7 +57,7 @@ module SidekiqUniqueJobs
       # @return [String] sidekiq job id when successful
       # @return [false] when unsuccessful
       def unlock
-        locksmith.unlock(item[JID_KEY]) # Only signal to release the lock
+        locksmith.unlock # Only signal to release the lock
       end
 
       # Deletes the job from redis if it is locked.
@@ -61,75 +75,77 @@ module SidekiqUniqueJobs
       # @return [true] when this jid has locked the job
       # @return [false] when this jid has not locked the job
       def locked?
-        locksmith.locked?(item[JID_KEY])
+        locksmith.locked?
+      end
+
+      #
+      # The lock manager/client
+      #
+      # @api private
+      # @return [SidekiqUniqueJobs::Locksmith] the locksmith for this sidekiq job
+      #
+      def locksmith
+        @locksmith ||= SidekiqUniqueJobs::Locksmith.new(item, redis_pool)
       end
 
       private
 
-      def add_uniqueness_when_missing
-        return if item.key?(UNIQUE_DIGEST_KEY)
+      def prepare_item
+        return if item.key?(LOCK_DIGEST)
 
         # The below should only be done to ease testing
         # in production this will be done by the middleware
-        SidekiqUniqueJobs::Job.add_uniqueness(item)
+        SidekiqUniqueJobs::Job.prepare(item)
       end
 
       def call_strategy
         @attempt += 1
-        strategy.call { lock if replace? }
+        client_strategy.call { lock if replace? }
       end
 
       def replace?
-        strategy.replace? && attempt < 2
+        client_strategy.replace? && attempt < 2
       end
 
-      # The sidekiq job hash
-      # @return [Hash] the Sidekiq job hash
+      # @!attribute [r] item
+      #   @return [Hash<String, Object>] the Sidekiq job hash
       attr_reader :item
-
-      # The sidekiq redis pool
-      # @return [Sidekiq::RedisConnection, ConnectionPool, NilClass] the redis connection
+      # @!attribute [r] lock_config
+      #   @return [LockConfig] a lock configuration
+      attr_reader :lock_config
+      # @!attribute [r] redis_pool
+      #   @return [Sidekiq::RedisConnection, ConnectionPool, NilClass] the redis connection
       attr_reader :redis_pool
-
-      # The sidekiq job hash
-      # @return [Proc] the callback to use after unlock
+      # @!attribute [r] callback
+      #   @return [Proc] the block to call after unlock
       attr_reader :callback
-
-      # The current attempt to lock the job
-      # @return [Integer] the numerical value of the attempt
+      # @!attribute [r] attempt
+      #   @return [Integer] the current locking attempt
       attr_reader :attempt
 
-      # The interface to the locking mechanism
-      # @return [SidekiqUniqueJobs::Locksmith]
-      def locksmith
-        @locksmith ||= SidekiqUniqueJobs::Locksmith.new(item, redis_pool)
-      end
-
-      def with_cleanup
-        yield
-      rescue Sidekiq::Shutdown
-        log_info("Sidekiq is shutting down, the job `should` be put back on the queue. Keeping the lock!")
-        raise
-      else
-        unlock_with_callback
-      end
-
       def unlock_with_callback
         return log_warn("might need to be unlocked manually") unless unlock
 
         callback_safely
+        item[JID]
       end
 
       def callback_safely
         callback&.call
-        item[JID_KEY]
+        item[JID]
       rescue StandardError
         log_warn("unlocked successfully but the #after_unlock callback failed!")
         raise
       end
 
-      def strategy
-        @strategy ||= OnConflict.find_strategy(item[ON_CONFLICT_KEY]).new(item)
+      def client_strategy
+        @client_strategy ||=
+          OnConflict.find_strategy(lock_config.on_client_conflict).new(item, redis_pool)
+      end
+
+      def server_strategy
+        @server_strategy ||=
+          OnConflict.find_strategy(lock_config.on_server_conflict).new(item, redis_pool)
       end
     end
   end

data/lib/sidekiq_unique_jobs/lock/client_validator.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  class Lock
+    #
+    # Validates the sidekiq options for the Sidekiq client process
+    #
+    # @author Mikael Henriksson <mikael@mhenrixon.com>
+    #
+    class ClientValidator
+      #
+      # @return [Array<Symbol>] a collection of invalid conflict resolutions
+      INVALID_ON_CONFLICTS = [:raise, :reject, :reschedule].freeze
+
+      #
+      # Validates the sidekiq options for the Sidekiq client process
+      #
+      #
+      def self.validate(lock_config)
+        on_conflict = lock_config.on_client_conflict
+        return lock_config unless INVALID_ON_CONFLICTS.include?(on_conflict)
+
+        lock_config.errors[:on_client_conflict] = "#{on_conflict} is incompatible with the client process"
+        lock_config
+      end
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/lock/server_validator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  class Lock
+    #
+    # Validates the sidekiq options for the Sidekiq server process
+    #
+    # @author Mikael Henriksson <mikael@mhenrixon.com>
+    #
+    class ServerValidator
+      #
+      # @return [Array<Symbol>] a collection of invalid conflict resolutions
+      INVALID_ON_CONFLICTS = [:replace].freeze
+
+      #
+      # Validates the sidekiq options for the Sidekiq server process
+      #
+      #
+      def self.validate(lock_config)
+        on_conflict = lock_config.on_server_conflict
+        return lock_config unless INVALID_ON_CONFLICTS.include?(on_conflict)
+
+        lock_config.errors[:on_server_conflict] = "#{on_conflict} is incompatible with the server process"
+      end
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/lock/until_and_while_executing.rb

@@ -11,7 +11,7 @@ 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 UntilAndWhileExecuting < BaseLock
       # Executes in the Sidekiq server process
       # @yield to the worker class perform method
@@ -21,26 +21,23 @@ module SidekiqUniqueJobs
             runtime_lock.execute { return yield }
           end
         else
-          log_warn "couldn't unlock digest: #{item[UNIQUE_DIGEST_KEY]} #{item[JID_KEY]}"
+          log_warn "couldn't unlock digest: #{item[LOCK_DIGEST]} #{item[JID]}"
         end
-      ensure
-        runtime_lock.delete!
-      end
-
-      def runtime_lock
-        @runtime_lock ||= SidekiqUniqueJobs::Lock::WhileExecuting.new(item, callback, redis_pool)
       end
 
       private
 
       def lock_on_failure
         yield
-        runtime_lock.delete!
       rescue Exception # rubocop:disable Lint/RescueException
-        log_error("Failed to execute job, restoring lock")
+        log_error("Runtime lock failed to execute job, restoring server lock")
         lock
         raise
       end
+
+      def runtime_lock
+        @runtime_lock ||= SidekiqUniqueJobs::Lock::WhileExecuting.new(item, callback, redis_pool)
+      end
     end
   end
 end

data/lib/sidekiq_unique_jobs/lock/until_executed.rb

@@ -6,18 +6,18 @@ module SidekiqUniqueJobs
     # - Locks on perform_in or perform_async
     # - Unlocks after yielding to the worker's perform method
     #
-    # @author Mikael Henriksson <mikael@zoolutions.se>
+    # @author Mikael Henriksson <mikael@mhenrixon.com>
     class UntilExecuted < BaseLock
       OK ||= "OK"
 
       # Executes in the Sidekiq server process
       # @yield to the worker class perform method
       def execute
-        if locked?
-          with_cleanup { yield }
-        else
-          log_warn "the unique_key: #{item[UNIQUE_DIGEST_KEY]} is not locked, allowing job to silently complete"
-          nil
+        lock do
+          yield
+          unlock_with_callback
+          callback_safely
+          item[JID]
         end
       end
     end

data/lib/sidekiq_unique_jobs/lock/until_executing.rb

@@ -6,7 +6,7 @@ module SidekiqUniqueJobs
     # - Locks on perform_in or perform_async
     # - Unlocks before yielding to the worker's perform method
     #
-    # @author Mikael Henriksson <mikael@zoolutions.se>
+    # @author Mikael Henriksson <mikael@mhenrixon.com>
     class UntilExecuting < BaseLock
       # Executes in the Sidekiq server process
       # @yield to the worker class perform method

data/lib/sidekiq_unique_jobs/lock/until_expired.rb

@@ -2,29 +2,12 @@
 
 module SidekiqUniqueJobs
   class Lock
-    # Locks jobs until the lock has expired
-    # - Locks on perform_in or perform_async
-    # - Unlocks when the expiration is hit
     #
-    # See {#lock} for more information about the client.
-    # See {#execute} for more information about the server
+    # UntilExpired locks until the job expires
     #
-    # @author Mikael Henriksson <mikael@zoolutions.se>
-    class UntilExpired < BaseLock
-      # Prevents these locks from being unlocked
-      # @return [true] always returns true
-      def unlock
-        true
-      end
-
-      # Executes in the Sidekiq server process
-      # @yield to the worker class perform method
-      def execute
-        return unless locked?
-
-        yield
-        # this lock does not handle after_unlock since we don't know when that would happen
-      end
+    # @author Mikael Henriksson <mikael@mhenrixon.com>
+    #
+    class UntilExpired < UntilExecuted
     end
   end
 end

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