sidekiq-unique-jobs 3.0.14 → 4.0.0

data/lib/sidekiq_unique_jobs/connectors.rb

@@ -1,16 +0,0 @@
-require 'sidekiq_unique_jobs/connectors/testing'
-require 'sidekiq_unique_jobs/connectors/redis_pool'
-require 'sidekiq_unique_jobs/connectors/sidekiq_redis'
-
-module SidekiqUniqueJobs
-  module Connectors
-    CONNECTOR_TYPES = [Testing, RedisPool, SidekiqRedis]
-
-    def self.connection(redis_pool = nil, &block)
-      CONNECTOR_TYPES.each do |connector|
-        had_connection = connector.connection(redis_pool, &block)
-        break if had_connection
-      end
-    end
-  end
-end

data/lib/sidekiq_unique_jobs/connectors/redis_pool.rb

@@ -1,11 +0,0 @@
-module SidekiqUniqueJobs
-  module Connectors
-    class RedisPool
-      def self.connection(redis_pool = nil, &block)
-        return if redis_pool.nil?
-        redis_pool.with(&block)
-        true
-      end
-    end
-  end
-end

data/lib/sidekiq_unique_jobs/connectors/sidekiq_redis.rb

@@ -1,9 +0,0 @@
-module SidekiqUniqueJobs
-  module Connectors
-    class SidekiqRedis
-      def self.connection(_redis_pool = nil, &block)
-        Sidekiq.redis(&block)
-      end
-    end
-  end
-end

data/lib/sidekiq_unique_jobs/connectors/testing.rb

@@ -1,11 +0,0 @@
-module SidekiqUniqueJobs
-  module Connectors
-    class Testing
-      def self.connection(_redis_pool = nil)
-        return unless SidekiqUniqueJobs.config.inline_testing_enabled?
-        yield SidekiqUniqueJobs.redis_mock
-        true
-      end
-    end
-  end
-end

data/lib/sidekiq_unique_jobs/inline_testing.rb

@@ -1,12 +0,0 @@
-begin
-  require 'mock_redis'
-rescue LoadError
-  raise 'To test using Sidekiq::Testing.inline!' \
-        ' Please add `gem "mock_redis" to your gemfile.'
-end
-
-module SidekiqUniqueJobs
-  def self.redis_mock
-    @redis_mock ||= MockRedis.new
-  end
-end

data/lib/sidekiq_unique_jobs/middleware/client/strategies/testing_inline.rb

@@ -1,25 +0,0 @@
-require 'sidekiq_unique_jobs/middleware/server/unique_jobs'
-
-module SidekiqUniqueJobs
-  module Middleware
-    module Client
-      module Strategies
-        class TestingInline < Unique
-          def self.elegible?
-            SidekiqUniqueJobs.config.inline_testing_enabled?
-          end
-
-          def review
-            _middleware.call(worker_class.new, item, queue, redis_pool) do
-              super
-            end
-          end
-
-          def _middleware
-            SidekiqUniqueJobs::Middleware::Server::UniqueJobs.new
-          end
-        end
-      end
-    end
-  end
-end

data/lib/sidekiq_unique_jobs/middleware/client/strategies/unique.rb

@@ -1,105 +0,0 @@
-require 'digest'
-require 'sidekiq_unique_jobs/connectors'
-
-REQUIRE_FILES = lambda do
-  if SidekiqUniqueJobs.config.testing_enabled? && Sidekiq::Testing.fake?
-    require 'sidekiq_unique_jobs/sidekiq_test_overrides'
-  end
-end
-
-module SidekiqUniqueJobs
-  module Middleware
-    module Client
-      module Strategies
-        class Unique
-          def self.elegible?
-            true
-          end
-
-          def self.review(worker_class, item, queue, redis_pool = nil, log_duplicate_payload = false)
-            new(worker_class, item, queue, redis_pool, log_duplicate_payload).review do
-              yield
-            end
-          end
-
-          def initialize(worker_class, item, queue, redis_pool = nil, log_duplicate_payload = false)
-            @worker_class = SidekiqUniqueJobs.worker_class_constantize(worker_class)
-            @item = item
-            @queue = queue
-            @redis_pool = redis_pool
-            @log_duplicate_payload = log_duplicate_payload
-            REQUIRE_FILES.call
-          end
-
-          def review
-            item['unique_hash'] = payload_hash
-
-            unless unique_for_connection?
-              Sidekiq.logger.warn "payload is not unique #{item}" if @log_duplicate_payload
-              return
-            end
-
-            yield
-          end
-
-          private
-
-          attr_reader :item, :worker_class, :redis_pool, :queue, :log_duplicate_payload
-
-          def unique_for_connection?
-            send("#{storage_method}_unique_for?")
-          end
-
-          def storage_method
-            SidekiqUniqueJobs.config.unique_storage_method
-          end
-
-          def old_unique_for?
-            unique = nil
-            connection do |conn|
-              conn.watch(payload_hash)
-              pid = conn.get(payload_hash).to_i
-              if pid == 1 || (pid == 2 && item['at'])
-                # if the job is already queued, or is already scheduled and
-                # we're trying to schedule again, abort
-                conn.unwatch
-              else
-                unique = conn.multi do
-                  # set value of 2 for scheduled jobs, 1 for queued jobs.
-                  conn.setex(payload_hash, expires_at, item['at'] ? 2 : 1)
-                end
-              end
-            end
-            unique
-          end
-
-          def new_unique_for?
-            connection do |conn|
-              return conn.set(payload_hash, item['at'] ? 2 : 1, nx: true, ex: expires_at)
-            end
-          end
-
-          def expires_at
-            # if the job was previously scheduled and is now being queued,
-            # or we've never seen it before
-            ex = unique_job_expiration || SidekiqUniqueJobs.config.default_expiration
-            ex = ((Time.at(item['at']) - Time.now.utc) + ex).to_i if item['at']
-            ex
-          end
-
-          def connection(&block)
-            SidekiqUniqueJobs::Connectors.connection(redis_pool, &block)
-          end
-
-          def payload_hash
-            SidekiqUniqueJobs::PayloadHelper.get_payload(item['class'], item['queue'], item['args'])
-          end
-
-          def unique_job_expiration
-            worker_class.get_sidekiq_options['unique_job_expiration']
-          end
-        end
-      end
-    end
-  end
-end

data/lib/sidekiq_unique_jobs/middleware/client/unique_jobs.rb

@@ -1,43 +0,0 @@
-require 'sidekiq_unique_jobs/middleware/client/strategies/unique'
-require 'sidekiq_unique_jobs/middleware/client/strategies/testing_inline'
-
-module SidekiqUniqueJobs
-  module Middleware
-    module Client
-      class UniqueJobs
-        STRATEGIES = [
-          Strategies::TestingInline,
-          Strategies::Unique
-        ]
-
-        attr_reader :item, :worker_class, :redis_pool
-
-        def call(worker_class, item, queue, redis_pool = nil)
-          @worker_class = SidekiqUniqueJobs.worker_class_constantize(worker_class)
-          @item = item
-          @redis_pool = redis_pool
-
-          if unique_enabled?
-            strategy.review(worker_class, item, queue, redis_pool, log_duplicate_payload?) { yield }
-          else
-            yield
-          end
-        end
-
-        private
-
-        def unique_enabled?
-          worker_class.get_sidekiq_options['unique'] || item['unique']
-        end
-
-        def log_duplicate_payload?
-          worker_class.get_sidekiq_options['log_duplicate_payload'] || item['log_duplicate_payload']
-        end
-
-        def strategy
-          STRATEGIES.detect(&:elegible?)
-        end
-      end
-    end
-  end
-end

data/lib/sidekiq_unique_jobs/middleware/server/unique_jobs.rb

@@ -1,69 +0,0 @@
-require 'digest'
-require 'sidekiq_unique_jobs/connectors'
-
-module SidekiqUniqueJobs
-  module Middleware
-    module Server
-      class UniqueJobs
-        attr_reader :unlock_order, :redis_pool
-
-        def call(worker, item, _queue, redis_pool = nil)
-          operative = true
-          @redis_pool = redis_pool
-          decide_unlock_order(worker.class)
-          lock_key = payload_hash(item)
-          unlock(lock_key) if before_yield?
-          yield
-        rescue Sidekiq::Shutdown
-          operative = false
-          raise
-        ensure
-          unlock(lock_key) if after_yield? && operative
-        end
-
-        def decide_unlock_order(klass)
-          @unlock_order = if unlock_order_configured?(klass)
-                            klass.get_sidekiq_options['unique_unlock_order']
-                          else
-                            default_unlock_order
-                          end
-        end
-
-        def unlock_order_configured?(klass)
-          klass.respond_to?(:get_sidekiq_options) &&
-            !klass.get_sidekiq_options['unique_unlock_order'].nil?
-        end
-
-        def default_unlock_order
-          SidekiqUniqueJobs.config.default_unlock_order
-        end
-
-        def before_yield?
-          unlock_order == :before_yield
-        end
-
-        def after_yield?
-          unlock_order == :after_yield
-        end
-
-        protected
-
-        def payload_hash(item)
-          SidekiqUniqueJobs::PayloadHelper.get_payload(item['class'], item['queue'], item['args'])
-        end
-
-        def unlock(payload_hash)
-          connection { |c| c.del(payload_hash) }
-        end
-
-        def logger
-          Sidekiq.logger
-        end
-
-        def connection(&block)
-          SidekiqUniqueJobs::Connectors.connection(redis_pool, &block)
-        end
-      end
-    end
-  end
-end

data/lib/sidekiq_unique_jobs/payload_helper.rb

@@ -1,42 +0,0 @@
-module SidekiqUniqueJobs
-  class PayloadHelper
-    def self.config
-      SidekiqUniqueJobs.config
-    end
-
-    def self.get_payload(klass, queue, *args)
-      unique_on_all_queues = false
-      if config.unique_args_enabled
-        worker_class = klass.constantize
-        args = yield_unique_args(worker_class, *args)
-        unique_on_all_queues =
-          worker_class.get_sidekiq_options['unique_on_all_queues']
-      end
-      md5_arguments = { class: klass, args: args }
-      md5_arguments[:queue] = queue unless unique_on_all_queues
-      "#{config.unique_prefix}:" \
-        "#{Digest::MD5.hexdigest(Sidekiq.dump_json(md5_arguments))}"
-    end
-
-    def self.yield_unique_args(worker_class, args)
-      unique_args = worker_class.get_sidekiq_options['unique_args']
-      filtered_args(worker_class, unique_args, args)
-    rescue NameError
-      # fallback to not filtering args when class can't be instantiated
-      args
-    end
-
-    def self.filtered_args(worker_class, unique_args, args)
-      case unique_args
-      when Proc
-        unique_args.call(args)
-      when Symbol
-        if worker_class.respond_to?(unique_args)
-          worker_class.send(unique_args, *args)
-        end
-      else
-        args
-      end
-    end
-  end
-end

data/lib/sidekiq_unique_jobs/sidekiq_test_overrides.rb

@@ -1,101 +0,0 @@
-require 'sidekiq/testing'
-
-module Sidekiq
-  module Worker
-    module ClassMethods
-      module Overrides
-        def self.included(base)
-          override_methods(base) unless base.method_defined?(:execute_job)
-
-          base.class_eval do
-            alias_method :execute_job_orig, :execute_job
-            alias_method :execute_job, :execute_job_ext
-
-            alias_method :clear_orig, :clear
-            alias_method :clear, :clear_ext
-          end
-        end
-
-        def execute_job_ext(worker, args)
-          execute_job_orig(worker, args)
-          payload_hash = SidekiqUniqueJobs::PayloadHelper.get_payload(
-            worker.class.name,
-            get_sidekiq_options['queue'],
-            args
-          )
-          Sidekiq.redis { |conn| conn.del(payload_hash) }
-        end
-
-        def clear_ext
-          payload_hashes = jobs.map { |job| job['unique_hash'] }
-          clear_orig
-          return if payload_hashes.empty?
-
-          Sidekiq.redis { |conn| conn.del(*payload_hashes) }
-        end
-
-        # Disable rubocop because methods are lifted directly out of Sidekiq
-        # rubocop:disable all
-        def override_methods(base)
-          base.class_eval do
-            define_method(:drain) do
-              while job = jobs.shift do
-                worker = new
-                worker.jid = job['jid']
-                execute_job(worker, job['args'])
-              end
-            end
-
-            define_method(:perform_one) do
-              raise(EmptyQueueError, "perform_one called with empty job queue") if jobs.empty?
-              job = jobs.shift
-              worker = new
-              worker.jid = job['jid']
-              execute_job(worker, job['args'])
-            end
-
-            define_method(:execute_job) do |worker, args|
-              worker.perform(*args)
-            end
-          end
-        end
-        # rubocop:enable all
-
-        module_function :override_methods
-        private_class_method :override_methods
-      end
-
-      include Overrides
-    end
-  end
-end
-
-module Sidekiq
-  module Worker
-    module Overrides
-      def self.included(base)
-        base.extend ClassMethods
-
-        base.class_eval do
-          class << self
-            alias_method :clear_all_orig, :clear_all
-            alias_method :clear_all, :clear_all_ext
-          end
-        end
-      end
-
-      module ClassMethods
-        def clear_all_ext
-          clear_all_orig
-          unique_prefix = SidekiqUniqueJobs.config.unique_prefix
-          unique_keys = Sidekiq.redis { |conn| conn.keys("#{unique_prefix}*") }
-          return if unique_keys.empty?
-
-          Sidekiq.redis { |conn| conn.del(*unique_keys) }
-        end
-      end
-    end
-
-    include Overrides
-  end
-end