sidekiq-unique-jobs 6.0.0.rc6 → 6.0.0.rc7

data/lib/sidekiq_unique_jobs/lock/while_executing_reject.rb

@@ -2,74 +2,27 @@
 
 module SidekiqUniqueJobs
   class Lock
+    # Locks jobs while executing
+    #   Locks from the server process
+    #   Unlocks after the server is done processing
+    #
+    # See {#lock} for more information about the client.
+    # See {#execute} for more information about the server
+    #
+    # @author Mikael Henriksson <mikael@zoolutions.se>
     class WhileExecutingReject < WhileExecuting
+      # Executes in the Sidekiq server process
+      # @yield to the worker class perform method
       def execute
-        return reject unless locksmith.lock(item[LOCK_TIMEOUT_KEY])
+        return strategy.call unless locksmith.lock(item[LOCK_TIMEOUT_KEY])
 
-        with_cleanup { yield if block_given? }
+        with_cleanup { yield }
       end
 
-      # Private below here, keeping public due to testing reasons
-
-      def reject
-        log_debug { "Rejecting job with jid: #{item[JID_KEY]} already running" }
-        send_to_deadset
-      end
-
-      def send_to_deadset
-        log_info { "Adding dead #{item[CLASS_KEY]} job #{item[JID_KEY]}" }
-
-        if deadset_kill?
-          deadset_kill
-        else
-          push_to_deadset
-        end
-      end
-
-      def deadset_kill?
-        deadset.respond_to?(:kill)
-      end
-
-      def deadset_kill
-        if kill_with_options?
-          kill_job_with_options
-        else
-          kill_job_without_options
-        end
-      end
-
-      def kill_with_options?
-        Sidekiq::DeadSet.instance_method(:kill).arity > 1
-      end
-
-      def kill_job_without_options
-        deadset.kill(payload)
-      end
-
-      def kill_job_with_options
-        deadset.kill(payload, notify_failure: false)
-      end
-
-      def deadset
-        @deadset ||= Sidekiq::DeadSet.new
-      end
-
-      def push_to_deadset
-        Sidekiq.redis do |conn|
-          conn.multi do
-            conn.zadd('dead', current_time, payload)
-            conn.zremrangebyscore('dead', '-inf', current_time - Sidekiq::DeadSet.timeout)
-            conn.zremrangebyrank('dead', 0, -Sidekiq::DeadSet.max_jobs)
-          end
-        end
-      end
-
-      def current_time
-        @current_time ||= Time.now.to_f
-      end
-
-      def payload
-        @payload ||= Sidekiq.dump_json(item)
+      # Overridden with a forced {OnConflict::Reject} strategy
+      # @return [OnConflict::Reject] a reject strategy
+      def strategy
+        @strategy ||= OnConflict.find_strategy(:reject).new(item)
       end
     end
   end

data/lib/sidekiq_unique_jobs/locksmith.rb

@@ -1,12 +1,20 @@
 # frozen_string_literal: true
 
 module SidekiqUniqueJobs
+  # Lock manager class that handles all the various locks
+  #
+  # @author Mikael Henriksson <mikael@zoolutions.se>
   class Locksmith # rubocop:disable ClassLength
     API_VERSION = '1'
     EXPIRES_IN = 10
 
     include SidekiqUniqueJobs::Connection
 
+    # @param [Hash] item a Sidekiq job hash
+    # @option item [Integer] :lock_expiration the configured expiration
+    # @option item [String] :jid the sidekiq job id
+    # @option item [String] :unique_digest the unique digest (See: {UniqueArgs#unique_digest})
+    # @param [Sidekiq::RedisConnection, ConnectionPool] redis_pool the redis connection
     def initialize(item, redis_pool = nil)
       @concurrency   = 1 # removed in a0cff5bc42edbe7190d6ede7e7f845074d2d7af6
       @expiration    = item[LOCK_EXPIRATION_KEY]
@@ -15,38 +23,51 @@ module SidekiqUniqueJobs
       @redis_pool    = redis_pool
     end
 
+    # Creates the necessary keys in redis to attempt a lock
+    # @return [String] the Sidekiq job_id
     def create
       Scripts.call(
         :create,
         redis_pool,
-        keys: [exists_key, grabbed_key, available_key, version_key, unique_digest],
+        keys: [exists_key, grabbed_key, available_key, version_key, UNIQUE_SET, unique_digest],
         argv: [jid, expiration, API_VERSION, concurrency],
       )
     end
 
+    # Checks if the exists key is created in redis
+    # @return [true, false]
     def exists?
       redis(redis_pool) { |conn| conn.exists(exists_key) }
     end
 
+    # The number of available resourced for this lock
+    # @return [Integer] the number of available resources
     def available_count
       return concurrency unless exists?
 
       redis(redis_pool) { |conn| conn.llen(available_key) }
     end
 
+    # Deletes the lock unless it has an expiration set
     def delete
-      return unless expiration.nil?
+      return if expiration
       delete!
     end
 
+    # Deletes the lock regardless of if it has an expiration set
     def delete!
       Scripts.call(
         :delete,
         redis_pool,
-        keys: [exists_key, grabbed_key, available_key, version_key, unique_digest],
+        keys: [exists_key, grabbed_key, available_key, version_key, UNIQUE_SET, unique_digest],
       )
     end
 
+    # Create a lock for the item
+    # @param [Integer] timeout the number of seconds to wait for a lock.
+    #   nil means wait indefinitely
+    # @yield the block to execute if a lock is successful
+    # @return the Sidekiq job_id (jid)
     def lock(timeout = nil, &block)
       create
 
@@ -57,23 +78,34 @@ module SidekiqUniqueJobs
     end
     alias wait lock
 
+    # Removes the lock keys from Redis
+    # @return [false] unless locked?
+    # @return [String] Sidekiq job_id (jid) if successful
     def unlock
       return false unless locked?
       signal(jid)
     end
 
+    # Removes the lock keys from Redis
+    # @param [String] token the unique token to check for a lock.
+    #   nil will default to the jid provided in the initializer
+    # @return [true, false]
     def locked?(token = nil)
       token ||= jid
       redis(redis_pool) { |conn| conn.hexists(grabbed_key, token) }
     end
 
+    # Signal that the token should be released
+    # @param [String] token the unique token to check for a lockk.
+    #   nil will default to the jid provided in the initializer.
+    # @return [Integer] the number of available lock resources
     def signal(token = nil)
       token ||= jid
 
       Scripts.call(
         :signal,
         redis_pool,
-        keys: [exists_key, grabbed_key, available_key, version_key, unique_digest],
+        keys: [exists_key, grabbed_key, available_key, version_key, UNIQUE_SET, unique_digest],
         argv: [token, expiration],
       )
     end
@@ -140,12 +172,3 @@ module SidekiqUniqueJobs
     end
   end
 end
-
-require 'sidekiq_unique_jobs/lock/base_lock'
-require 'sidekiq_unique_jobs/lock/until_executed'
-require 'sidekiq_unique_jobs/lock/until_executing'
-require 'sidekiq_unique_jobs/lock/until_expired'
-require 'sidekiq_unique_jobs/lock/while_executing'
-require 'sidekiq_unique_jobs/lock/while_executing_reject'
-require 'sidekiq_unique_jobs/lock/while_executing_requeue'
-require 'sidekiq_unique_jobs/lock/until_and_while_executing'

data/lib/sidekiq_unique_jobs/logging.rb

@@ -1,28 +1,51 @@
 # frozen_string_literal: true
 
 module SidekiqUniqueJobs
+  # Utility module for reducing the number of uses of logger.
+  #
+  # @author Mikael Henriksson <mikael@zoolutions.se>
   module Logging
-    # :reek:UtilityFunction { enabled: false }
+    # A convenience method for using the configured logger
     def logger
       SidekiqUniqueJobs.logger
     end
 
+    # Logs a message at debug level
+    # @param message_or_exception [String, Exception] the message or exception to log
+    # @yield the message or exception to use for log message
+    #   Used for compatibility with logger
     def log_debug(message_or_exception = nil, &block)
       logger.debug(message_or_exception, &block)
     end
 
+    # Logs a message at info level
+    # @param message_or_exception [String, Exception] the message or exception to log
+    # @yield the message or exception to use for log message
+    #   Used for compatibility with logger
     def log_info(message_or_exception = nil, &block)
       logger.info(message_or_exception, &block)
     end
 
+    # Logs a message at warn level
+    # @param message_or_exception [String, Exception] the message or exception to log
+    # @yield the message or exception to use for log message
+    #   Used for compatibility with logger
     def log_warn(message_or_exception = nil, &block)
       logger.warn(message_or_exception, &block)
     end
 
+    # Logs a message at error level
+    # @param message_or_exception [String, Exception] the message or exception to log
+    # @yield the message or exception to use for log message
+    #   Used for compatibility with logger
     def log_error(message_or_exception = nil, &block)
       logger.error(message_or_exception, &block)
     end
 
+    # Logs a message at fatal level
+    # @param message_or_exception [String, Exception] the message or exception to log
+    # @yield the message or exception to use for log message
+    #   Used for compatibility with logger
     def log_fatal(message_or_exception = nil, &block)
       logger.fatal(message_or_exception, &block)
     end

data/lib/sidekiq_unique_jobs/normalizer.rb

@@ -3,7 +3,13 @@
 require 'json'
 
 module SidekiqUniqueJobs
+  # Normalizes hashes by dumping them to json and loading them from json
+  #
+  # @author Mikael Henriksson <mikael@zoolutions.se>
   module Normalizer
+    # Changes hash to a json compatible hash
+    # @param [Hash] args
+    # @return [Hash] a json compatible hash
     def self.jsonify(args)
       Sidekiq.load_json(Sidekiq.dump_json(args))
     end

data/lib/sidekiq_unique_jobs/on_conflict.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'on_conflict/strategy'
+require_relative 'on_conflict/null_strategy'
+require_relative 'on_conflict/log'
+require_relative 'on_conflict/raise'
+require_relative 'on_conflict/reject'
+require_relative 'on_conflict/reschedule'
+
+module SidekiqUniqueJobs
+  module OnConflict
+    STRATEGIES = {
+      log: OnConflict::Log,
+      raise: OnConflict::Raise,
+      reject: OnConflict::Reject,
+      reschedule: OnConflict::Reschedule,
+    }.freeze
+
+    # returns OnConflict::NullStrategy when no other could be found
+    def self.find_strategy(strategy)
+      STRATEGIES.fetch(strategy.to_s.to_sym) { OnConflict::NullStrategy }
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/on_conflict/log.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  module OnConflict
+    # Strategy to log information about conflict
+    #
+    # @author Mikael Henriksson <mikael@zoolutions.se>
+    class Log < OnConflict::Strategy
+      include SidekiqUniqueJobs::Logging
+
+      # Logs an informational message about that the job was not unique
+      def call
+        log_info(
+          "skipping job with id (#{item[JID_KEY]}) " \
+          "because unique_digest: (#{item[UNIQUE_DIGEST_KEY]}) already exists",
+        )
+      end
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/on_conflict/null_strategy.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  module OnConflict
+    # Default conflict strategy class that does nothing
+    #
+    # @author Mikael Henriksson <mikael@zoolutions.se>
+    class NullStrategy < OnConflict::Strategy
+      # Do nothing on conflict
+      # @return [nil]
+      def call
+        # NOOP
+      end
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/on_conflict/raise.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  module OnConflict
+    # Strategy to raise an error on conflict
+    #
+    # @author Mikael Henriksson <mikael@zoolutions.se>
+    class Raise < OnConflict::Strategy
+      # Raise an error on conflict.
+      #   This will cause Sidekiq to retry the job
+      # @raise [SidekiqUniqueJobs::Conflict]
+      def call
+        fail SidekiqUniqueJobs::Conflict, item
+      end
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/on_conflict/reject.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  module OnConflict
+    # Strategy to send jobs to dead queue
+    #
+    # @author Mikael Henriksson <mikael@zoolutions.se>
+    class Reject < OnConflict::Strategy
+      # Send jobs to dead queue
+      def call
+        log_debug { "Rejecting job with jid: #{item[JID_KEY]}" }
+        send_to_deadset
+      end
+
+      def send_to_deadset
+        log_info { "Adding dead #{item[CLASS_KEY]} job #{item[JID_KEY]}" }
+
+        if deadset_kill?
+          deadset_kill
+        else
+          push_to_deadset
+        end
+      end
+
+      def deadset_kill?
+        deadset.respond_to?(:kill)
+      end
+
+      def deadset_kill
+        if kill_with_options?
+          kill_job_with_options
+        else
+          kill_job_without_options
+        end
+      end
+
+      def kill_with_options?
+        Sidekiq::DeadSet.instance_method(:kill).arity > 1
+      end
+
+      def kill_job_without_options
+        deadset.kill(payload)
+      end
+
+      def kill_job_with_options
+        deadset.kill(payload, notify_failure: false)
+      end
+
+      def deadset
+        @deadset ||= Sidekiq::DeadSet.new
+      end
+
+      def push_to_deadset
+        Sidekiq.redis do |conn|
+          conn.multi do
+            conn.zadd('dead', current_time, payload)
+            conn.zremrangebyscore('dead', '-inf', current_time - Sidekiq::DeadSet.timeout)
+            conn.zremrangebyrank('dead', 0, -Sidekiq::DeadSet.max_jobs)
+          end
+        end
+      end
+
+      def current_time
+        @current_time ||= Time.now.to_f
+      end
+
+      def payload
+        @payload ||= Sidekiq.dump_json(item)
+      end
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/on_conflict/reschedule.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  module OnConflict
+    # Strategy to reschedule job on conflict
+    #
+    # @author Mikael Henriksson <mikael@zoolutions.se>
+    class Reschedule < OnConflict::Strategy
+      include SidekiqUniqueJobs::SidekiqWorkerMethods
+
+      # @param [Hash] item sidekiq job hash
+      def initialize(item)
+        super
+        @worker_class = item[CLASS_KEY]
+      end
+
+      # Create a new job from the current one.
+      #   This will mess up sidekiq stats because a new job is created
+      def call
+        worker_class&.perform_in(5, *item[ARGS_KEY]) if sidekiq_worker_class?
+      end
+    end
+  end
+end