sidekiq-unique-jobs 5.0.11 → 6.0.0.rc1

data/lib/sidekiq_unique_jobs/logging.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  module Logging
+    # :reek:UtilityFunction { enabled: false }
+    def logger
+      SidekiqUniqueJobs.logger
+    end
+
+    def log_debug(message_or_exception = nil, &block)
+      logger.debug(message_or_exception, &block)
+    end
+
+    def log_info(message_or_exception = nil, &block)
+      logger.info(message_or_exception, &block)
+    end
+
+    def log_warn(message_or_exception = nil, &block)
+      logger.warn(message_or_exception, &block)
+    end
+
+    def log_error(message_or_exception = nil, &block)
+      logger.error(message_or_exception, &block)
+    end
+
+    def log_fatal(message_or_exception = nil, &block)
+      logger.fatal(message_or_exception, &block)
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/options_with_fallback.rb

@@ -1,13 +1,28 @@
 # frozen_string_literal: true
 
 module SidekiqUniqueJobs
+  # Shared logic for dealing with options
+  # This class requires 3 things to be defined in the class including it
+  #   1. item (required)
+  #   2. options (can be nil)
+  #   3. worker_class (required, can be anything)
   module OptionsWithFallback
+    LOCKS = {
+      until_and_while_executing: SidekiqUniqueJobs::Lock::UntilAndWhileExecuting,
+      until_executed:            SidekiqUniqueJobs::Lock::UntilExecuted,
+      until_executing:           SidekiqUniqueJobs::Lock::UntilExecuting,
+      until_expired:             SidekiqUniqueJobs::Lock::UntilExpired,
+      until_timeout:             SidekiqUniqueJobs::Lock::UntilExpired,
+      while_executing:           SidekiqUniqueJobs::Lock::WhileExecuting,
+      while_executing_reject:    SidekiqUniqueJobs::Lock::WhileExecutingReject,
+    }.freeze
+
     def self.included(base)
-      base.send(:extend, SidekiqUniqueJobs::OptionsWithFallback::ClassMethods)
+      base.send(:include, SidekiqUniqueJobs::SidekiqWorkerMethods)
     end
 
     def unique_enabled?
-      options[UNIQUE_KEY] || item[UNIQUE_KEY]
+      SidekiqUniqueJobs.config.enabled && lock_type
     end
 
     def unique_disabled?
@@ -19,55 +34,26 @@ module SidekiqUniqueJobs
     end
 
     def lock
-      @lock = lock_class.new(item)
+      @lock ||= lock_class.new(item, @redis_pool)
     end
 
     def lock_class
-      lock_cache[unique_lock.to_sym] ||= Object.const_get("SidekiqUniqueJobs::Lock::#{unique_lock.to_s.classify}")
-    end
-
-    def unique_lock
-      @unique_lock ||=
-        if options.key?(UNIQUE_KEY) && options[UNIQUE_KEY].to_s == 'true'
-          warn('unique: true is no longer valid. Please set it to the type of lock required like: ' \
-               '`unique: :until_executed`')
-          options[UNIQUE_LOCK_KEY] || SidekiqUniqueJobs.default_lock
-        else
-          lock_type || SidekiqUniqueJobs.default_lock
+      @lock_class ||= begin
+        LOCKS.fetch(lock_type.to_sym) do
+          fail UnknownLock, "No implementation for `unique: :#{lock_type}`"
         end
+      end
     end
 
     def lock_type
-      lock_type_from(options) || lock_type_from(item)
-    end
-
-    def lock_type_from(hash, key = UNIQUE_KEY)
-      return nil if hash[key].is_a?(TrueClass)
-      hash[key]
-    end
-
-    def lock_cache
-      self.class.lock_cache
-    end
-
-    def lock_cache=(obj)
-      self.class.lock_cache = obj
+      @lock_type ||= options[UNIQUE_KEY] || item[UNIQUE_KEY]
     end
 
     def options
-      @options ||= worker_class.get_sidekiq_options if worker_class.respond_to?(:get_sidekiq_options)
-      @options ||= Sidekiq.default_worker_options
-      @options ||= {}
-      @options &&= @options.stringify_keys
-    end
-
-    module ClassMethods
-      def lock_cache
-        @lock_cache ||= {}
-      end
-
-      def lock_cache=(obj)
-        @lock_cache = obj
+      @options ||= begin
+        opts = default_worker_options.dup
+        opts.merge!(worker_options) if sidekiq_worker_class?
+        (opts || {}).stringify_keys
       end
     end
   end

data/lib/sidekiq_unique_jobs/scripts.rb

@@ -3,47 +3,48 @@
 require 'pathname'
 require 'digest/sha1'
 require 'concurrent/map'
-require 'sidekiq_unique_jobs/scripts/acquire_lock'
-require 'sidekiq_unique_jobs/scripts/release_lock'
 
 module SidekiqUniqueJobs
-  ScriptError         = Class.new(StandardError)
-  UniqueKeyMissing    = Class.new(ArgumentError)
-  JidMissing          = Class.new(ArgumentError)
-  MaxLockTimeMissing  = Class.new(ArgumentError)
-  UnexpectedValue     = Class.new(StandardError)
-
   module Scripts
     LUA_PATHNAME ||= Pathname.new(__FILE__).dirname.join('../../redis').freeze
-    SOURCE_FILES ||= Dir[LUA_PATHNAME.join('**/*.lua')].compact.freeze
-    DEFINED_METHODS ||= [].freeze
     SCRIPT_SHAS ||= Concurrent::Map.new
 
-    module_function
+    include SidekiqUniqueJobs::Connection
 
-    extend SingleForwardable
-    def_delegators :SidekiqUniqueJobs, :connection, :logger
+    module_function
 
     def call(file_name, redis_pool, options = {})
-      internal_call(file_name, redis_pool, options)
+      execute_script(file_name, redis_pool, options)
     rescue Redis::CommandError => ex
-      handle_error(ex, file_name, redis_pool, options)
+      handle_error(ex, file_name) do
+        call(file_name, redis_pool, options)
+      end
     end
 
-    def internal_call(file_name, redis_pool, options = {})
-      connection(redis_pool) do |conn|
-        SCRIPT_SHAS[file_name] = conn.script(:load, script_source(file_name)) if SCRIPT_SHAS[file_name].nil?
-        conn.evalsha(SCRIPT_SHAS[file_name], options)
+    def execute_script(file_name, redis_pool, options = {})
+      redis(redis_pool) do |conn|
+        sha = script_sha(conn, file_name)
+        conn.evalsha(sha, options)
       end
     end
 
-    def handle_error(exception, file_name, redis_pool, options = {})
-      if exception.message == 'NOSCRIPT No matching script. Please use EVAL.' # rubocop:disable Style/GuardClause
+    def script_sha(conn, file_name)
+      if (sha = SCRIPT_SHAS.get(file_name))
+        return sha
+      end
+
+      sha = conn.script(:load, script_source(file_name))
+      SCRIPT_SHAS.put(file_name, sha)
+      sha
+    end
+
+    def handle_error(ex, file_name)
+      if ex.message == 'NOSCRIPT No matching script. Please use EVAL.'
         SCRIPT_SHAS.delete(file_name)
-        call(file_name, redis_pool, options)
-      else
-        raise ScriptError, "Problem compiling #{file_name}. Invalid LUA syntax?"
+        return yield if block_given?
       end
+
+      raise ScriptError, file_name: file_name, source_exception: ex
     end
 
     def script_source(file_name)

data/lib/sidekiq_unique_jobs/server/middleware.rb

@@ -3,33 +3,25 @@
 module SidekiqUniqueJobs
   module Server
     class Middleware
-      extend Forwardable
-      def_delegators :Sidekiq, :logger
-      def_instance_delegator :@worker, :class, :worker_class
-
       include OptionsWithFallback
 
-      def call(worker, item, queue, redis_pool = nil, &blk)
-        @worker = worker
-        @redis_pool = redis_pool
-        @queue = queue
-        @item = item
-        return yield unless unique_enabled?
-        lock.send(:execute, after_unlock_hook, &blk)
-      end
-
-      private
+      def call(worker_class, item, queue)
+        @worker_class = worker_class
+        @item         = item
+        @queue        = queue
+        return yield if unique_disabled?
 
-      attr_reader :redis_pool, :worker, :item
+        lock.execute(after_unlock_hook) do
+          yield
+        end
+      end
 
       protected
 
-      def after_unlock_hook
-        -> { worker.after_unlock if worker.respond_to?(:after_unlock) }
-      end
+      attr_reader :item
 
-      def reschedule
-        Sidekiq::Client.new(redis_pool).raw_push([item])
+      def after_unlock_hook
+        -> { worker_class.after_unlock if worker_method_defined?(:after_unlock) }
       end
     end
   end

data/lib/sidekiq_unique_jobs/sidekiq_unique_ext.rb

@@ -15,14 +15,14 @@ module Sidekiq
       end
 
       def delete_ext
-        SidekiqUniqueJobs::Unlockable.unlock(item) if delete_orig
+        SidekiqUniqueJobs::Unlockable.delete(item) if delete_orig
       end
 
       private
 
       def remove_job_ext
         remove_job_orig do |message|
-          SidekiqUniqueJobs::Unlockable.unlock(Sidekiq.load_json(message))
+          SidekiqUniqueJobs::Unlockable.delete(Sidekiq.load_json(message))
           yield message
         end
       end
@@ -41,7 +41,7 @@ module Sidekiq
       end
 
       def delete_ext
-        SidekiqUniqueJobs::Unlockable.unlock(item) if delete_orig
+        SidekiqUniqueJobs::Unlockable.delete(item) if delete_orig
       end
     end
     include UniqueExtension
@@ -58,7 +58,7 @@ module Sidekiq
 
       def delete_ext
         delete_orig
-        SidekiqUniqueJobs::Unlockable.unlock(item)
+        SidekiqUniqueJobs::Unlockable.delete(item)
       end
     end
 
@@ -105,7 +105,7 @@ module Sidekiq
       end
 
       def delete_by_value_ext(name, value)
-        SidekiqUniqueJobs::Unlockable.unlock(Sidekiq.load_json(value)) if delete_by_value_orig(name, value)
+        SidekiqUniqueJobs::Unlockable.delete(Sidekiq.load_json(value)) if delete_by_value_orig(name, value)
       end
     end
 

data/lib/sidekiq_unique_jobs/sidekiq_worker_methods.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  module SidekiqWorkerMethods
+    def worker_method_defined?(method_sym)
+      worker_class.respond_to?(method_sym)
+    end
+
+    def worker_options
+      return {} unless sidekiq_worker_class?
+      worker_class.get_sidekiq_options.stringify_keys
+    end
+
+    def sidekiq_worker_class?
+      worker_method_defined?(:get_sidekiq_options)
+    end
+
+    def worker_class
+      @_worker_class ||= worker_class_constantize # rubocop:disable Naming/MemoizedInstanceVariableName
+    end
+
+    # Attempt to constantize a string worker_class argument, always
+    # failing back to the original argument when the constant can't be found
+    #
+    # raises an error for other errors
+    def worker_class_constantize(klazz = @worker_class)
+      return klazz unless klazz.is_a?(String)
+      Object.const_get(klazz)
+    rescue NameError => ex
+      case ex.message
+      when /uninitialized constant/
+        klazz
+      else
+        raise
+      end
+    end
+
+    def default_worker_options
+      Sidekiq.default_worker_options
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/testing.rb

@@ -1,72 +1,62 @@
 # frozen_string_literal: true
 
-require 'sidekiq_unique_jobs/testing/sidekiq_overrides'
-require 'sidekiq_unique_jobs/script_mock'
+# :nocov:
 
-module SidekiqUniqueJobs
-  alias redis_version_real redis_version
-  def redis_version
-    if mocked?
-      '0.0'
-    else
-      redis_version_real
-    end
+require 'sidekiq'
+require 'sidekiq/testing'
+
+module Sidekiq
+  def self.use_options(tmp_config = {})
+    old_config = default_worker_options
+    default_worker_options.clear
+    self.default_worker_options = tmp_config
+
+    yield
+  ensure
+    default_worker_options.clear
+    self.default_worker_options = old_config
   end
 
-  module Scripts
+  module Worker
+    module ClassMethods
+      def use_options(tmp_config = {})
+        old_config = get_sidekiq_options
+        sidekiq_options(tmp_config)
+
+        yield
+      ensure
+        sidekiq_options(old_config)
+      end
+
+      def clear
+        jobs.each do |job|
+          SidekiqUniqueJobs::Unlockable.delete(job)
+        end
+
+        Sidekiq::Queues[queue].clear
+        jobs.clear
+      end
+    end
+
     module Overrides
       def self.included(base)
         base.extend Testing
         base.class_eval do
           class << self
-            alias_method :call_orig, :call
-            alias_method :call, :call_ext
+            alias_method :clear_all_orig, :clear_all
+            alias_method :clear_all, :clear_all_ext
           end
         end
       end
 
       module Testing
-        def call_ext(file_name, redis_pool, options = {})
-          if SidekiqUniqueJobs.mocked?
-            SidekiqUniqueJobs::ScriptMock.call(file_name, redis_pool, options)
-          else
-            call_orig(file_name, redis_pool, options)
-          end
+        def clear_all_ext
+          clear_all_orig
+          SidekiqUniqueJobs::Util.del('*', 1000)
         end
       end
     end
 
     include Overrides
   end
-
-  module Client
-    class Middleware
-      alias call_real call
-      def call(worker_class, item, queue, redis_pool = nil)
-        worker_class = SidekiqUniqueJobs.worker_class_constantize(worker_class)
-
-        if Sidekiq::Testing.inline?
-          call_real(worker_class, item, queue, redis_pool) do
-            _server.call(worker_class.new, item, queue, redis_pool) do
-              yield
-            end
-          end
-        else
-          call_real(worker_class, item, queue, redis_pool) do
-            yield
-          end
-        end
-      end
-
-      def _server
-        SidekiqUniqueJobs::Server::Middleware.new
-      end
-    end
-  end
-
-  class Testing
-    def mocking!
-      require 'sidekiq_unique_jobs/testing/mocking'
-    end
-  end
 end