sidekiq-limit_fetch 4.4.0 → 4.4.1

data/lib/sidekiq/limit_fetch/global/semaphore.rb

@@ -1,136 +1,141 @@
-module Sidekiq::LimitFetch::Global
-  class Semaphore
-    PREFIX = 'limit_fetch'
+# frozen_string_literal: true
 
-    attr_reader :local_busy
+module Sidekiq
+  module LimitFetch
+    module Global
+      class Semaphore
+        PREFIX = 'limit_fetch'
 
-    def initialize(name)
-      @name = name
-      @lock = Mutex.new
-      @local_busy = 0
-    end
+        attr_reader :local_busy
 
-    def limit
-      value = redis {|it| it.get "#{PREFIX}:limit:#@name" }
-      value.to_i if value
-    end
+        def initialize(name)
+          @name = name
+          @lock = Mutex.new
+          @local_busy = 0
+        end
 
-    def limit=(value)
-      @limit_changed = true
+        def limit
+          value = redis { |it| it.get "#{PREFIX}:limit:#{@name}" }
+          value&.to_i
+        end
 
-      if value
-        redis {|it| it.set "#{PREFIX}:limit:#@name", value }
-      else
-        redis {|it| it.del "#{PREFIX}:limit:#@name" }
-      end
-    end
+        def limit=(value)
+          @limit_changed = true
 
-    def limit_changed?
-      @limit_changed
-    end
+          if value
+            redis { |it| it.set "#{PREFIX}:limit:#{@name}", value }
+          else
+            redis { |it| it.del "#{PREFIX}:limit:#{@name}" }
+          end
+        end
 
-    def process_limit
-      value = redis {|it| it.get "#{PREFIX}:process_limit:#@name" }
-      value.to_i if value
-    end
+        def limit_changed?
+          @limit_changed
+        end
 
-    def process_limit=(value)
-      if value
-        redis {|it| it.set "#{PREFIX}:process_limit:#@name", value }
-      else
-        redis {|it| it.del "#{PREFIX}:process_limit:#@name" }
-      end
-    end
+        def process_limit
+          value = redis { |it| it.get "#{PREFIX}:process_limit:#{@name}" }
+          value&.to_i
+        end
 
-    def acquire
-      Selector.acquire([@name], namespace).size > 0
-    end
+        def process_limit=(value)
+          if value
+            redis { |it| it.set "#{PREFIX}:process_limit:#{@name}", value }
+          else
+            redis { |it| it.del "#{PREFIX}:process_limit:#{@name}" }
+          end
+        end
 
-    def release
-      redis {|it| it.lrem "#{PREFIX}:probed:#@name", 1, Selector.uuid }
-    end
+        def acquire
+          Selector.acquire([@name], namespace).size.positive?
+        end
 
-    def busy
-      redis {|it| it.llen "#{PREFIX}:busy:#@name" }
-    end
+        def release
+          redis { |it| it.lrem "#{PREFIX}:probed:#{@name}", 1, Selector.uuid }
+        end
 
-    def busy_processes
-      redis {|it| it.lrange "#{PREFIX}:busy:#@name", 0, -1 }
-    end
+        def busy
+          redis { |it| it.llen "#{PREFIX}:busy:#{@name}" }
+        end
 
-    def increase_busy
-      increase_local_busy
-      redis {|it| it.rpush "#{PREFIX}:busy:#@name", Selector.uuid }
-    end
+        def busy_processes
+          redis { |it| it.lrange "#{PREFIX}:busy:#{@name}", 0, -1 }
+        end
 
-    def decrease_busy
-      decrease_local_busy
-      redis {|it| it.lrem "#{PREFIX}:busy:#@name", 1, Selector.uuid }
-    end
+        def increase_busy
+          increase_local_busy
+          redis { |it| it.rpush "#{PREFIX}:busy:#{@name}", Selector.uuid }
+        end
 
-    def probed
-      redis {|it| it.llen "#{PREFIX}:probed:#@name" }
-    end
+        def decrease_busy
+          decrease_local_busy
+          redis { |it| it.lrem "#{PREFIX}:busy:#{@name}", 1, Selector.uuid }
+        end
 
-    def probed_processes
-      redis {|it| it.lrange "#{PREFIX}:probed:#@name", 0, -1 }
-    end
+        def probed
+          redis { |it| it.llen "#{PREFIX}:probed:#{@name}" }
+        end
 
-    def pause
-      redis {|it| it.set "#{PREFIX}:pause:#@name", '1' }
-    end
+        def probed_processes
+          redis { |it| it.lrange "#{PREFIX}:probed:#{@name}", 0, -1 }
+        end
 
-    def pause_for_ms ms
-      redis {|it| it.psetex "#{PREFIX}:pause:#@name", ms, 1 }
-    end
+        def pause
+          redis { |it| it.set "#{PREFIX}:pause:#{@name}", '1' }
+        end
 
-    def unpause
-      redis {|it| it.del "#{PREFIX}:pause:#@name" }
-    end
+        def pause_for_ms(milliseconds)
+          redis { |it| it.psetex "#{PREFIX}:pause:#{@name}", milliseconds, 1 }
+        end
 
-    def paused?
-      redis {|it| it.get "#{PREFIX}:pause:#@name" } == '1'
-    end
+        def unpause
+          redis { |it| it.del "#{PREFIX}:pause:#{@name}" }
+        end
 
-    def block
-      redis {|it| it.set "#{PREFIX}:block:#@name", '1' }
-    end
+        def paused?
+          redis { |it| it.get "#{PREFIX}:pause:#{@name}" } == '1'
+        end
 
-    def block_except(*queues)
-      raise ArgumentError if queues.empty?
-      redis {|it| it.set "#{PREFIX}:block:#@name", queues.join(',') }
-    end
+        def block
+          redis { |it| it.set "#{PREFIX}:block:#{@name}", '1' }
+        end
 
-    def unblock
-      redis {|it| it.del "#{PREFIX}:block:#@name" }
-    end
+        def block_except(*queues)
+          raise ArgumentError if queues.empty?
 
-    def blocking?
-      redis {|it| it.get "#{PREFIX}:block:#@name" } == '1'
-    end
+          redis { |it| it.set "#{PREFIX}:block:#{@name}", queues.join(',') }
+        end
 
-    def clear_limits
-      redis do |it|
-        %w(block busy limit pause probed process_limit).each do |key|
-          it.del "#{PREFIX}:#{key}:#@name"
+        def unblock
+          redis { |it| it.del "#{PREFIX}:block:#{@name}" }
         end
-      end
-    end
 
-    def increase_local_busy
-      @lock.synchronize { @local_busy += 1 }
-    end
+        def blocking?
+          redis { |it| it.get "#{PREFIX}:block:#{@name}" } == '1'
+        end
 
-    def decrease_local_busy
-      @lock.synchronize { @local_busy -= 1 }
-    end
+        def clear_limits
+          redis do |it|
+            %w[block busy limit pause probed process_limit].each do |key|
+              it.del "#{PREFIX}:#{key}:#{@name}"
+            end
+          end
+        end
 
-    def local_busy?
-      @local_busy > 0
-    end
+        def increase_local_busy
+          @lock.synchronize { @local_busy += 1 }
+        end
+
+        def decrease_local_busy
+          @lock.synchronize { @local_busy -= 1 }
+        end
+
+        def local_busy?
+          @local_busy.positive?
+        end
 
-    def explain
-      <<-END.gsub(/^ {8}/, '')
+        def explain
+          <<-INFO.gsub(/^ {8}/, '')
         Current sidekiq process: #{Selector.uuid}
 
           All processes:
@@ -153,31 +158,33 @@ module Sidekiq::LimitFetch::Global
 
           Blocking:
         #{blocking?}
-      END
-    end
+          INFO
+        end
 
-    def remove_locks_except!(processes)
-      locked_processes = probed_processes.uniq
-      (locked_processes - processes).each do |dead_process|
-        remove_lock! dead_process
-      end
-    end
+        def remove_locks_except!(processes)
+          locked_processes = probed_processes.uniq
+          (locked_processes - processes).each do |dead_process|
+            remove_lock! dead_process
+          end
+        end
 
-    def remove_lock!(process)
-      redis do |it|
-        it.lrem "#{PREFIX}:probed:#@name", 0, process
-        it.lrem "#{PREFIX}:busy:#@name", 0, process
-      end
-    end
+        def remove_lock!(process)
+          redis do |it|
+            it.lrem "#{PREFIX}:probed:#{@name}", 0, process
+            it.lrem "#{PREFIX}:busy:#{@name}", 0, process
+          end
+        end
 
-    private
+        private
 
-    def redis(&block)
-      Sidekiq.redis(&block)
-    end
+        def redis(&block)
+          Sidekiq.redis(&block)
+        end
 
-    def namespace
-      Sidekiq::LimitFetch::Queues.namespace
+        def namespace
+          Sidekiq::LimitFetch::Queues.namespace
+        end
+      end
     end
   end
 end

data/lib/sidekiq/limit_fetch/instances.rb

@@ -1,23 +1,29 @@
-module Sidekiq::LimitFetch::Instances
-  def self.extended(klass)
-    klass.instance_variable_set :@instances, {}
-  end
+# frozen_string_literal: true
 
-  def new(*args)
-    @instances[args] ||= super
-  end
+module Sidekiq
+  module LimitFetch
+    module Instances
+      def self.extended(klass)
+        klass.instance_variable_set :@instances, {}
+      end
 
-  alias [] new
+      def new(*args)
+        @instances[args] ||= super
+      end
 
-  def instances
-    @instances.values
-  end
+      alias [] new
 
-  def reset_instances!
-    @instances = {}
-  end
+      def instances
+        @instances.values
+      end
+
+      def reset_instances!
+        @instances = {}
+      end
 
-  def delete_instance(name)
-    @instances.delete [name]
+      def delete_instance(name)
+        @instances.delete [name]
+      end
+    end
   end
 end

data/lib/sidekiq/limit_fetch/queues.rb

@@ -1,174 +1,200 @@
-module Sidekiq::LimitFetch::Queues
-  extend self
+# frozen_string_literal: true
+
+module Sidekiq
+  module LimitFetch
+    module Queues
+      extend self
+
+      THREAD_KEY = :acquired_queues
+
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/MethodLength
+      # rubocop:disable Metrics/PerceivedComplexity
+      def start(capsule_or_options)
+        config = Sidekiq::LimitFetch.post_7? ? capsule_or_options.config : capsule_or_options
+
+        @queues = config[:queues].map do |queue|
+          if queue.is_a? Array
+            queue.first
+          else
+            queue
+          end
+        end.uniq
+        @startup_queues = @queues.dup
+
+        if config[:dynamic].is_a? Hash
+          @dynamic         = true
+          @dynamic_exclude = config[:dynamic][:exclude] || []
+        else
+          @dynamic = config[:dynamic]
+          @dynamic_exclude = []
+        end
 
-  THREAD_KEY = :acquired_queues
+        @limits         = config[:limits] || {}
+        @process_limits = config[:process_limits] || {}
+        @blocks         = config[:blocking] || []
 
-  def start(options)
-    if Sidekiq::LimitFetch.post_7?
-      options = options.config
-    end
+        config[:strict] ? strict_order! : weighted_order!
 
-    @queues         = options[:queues]
-    @startup_queues = options[:queues].dup
+        apply_process_limit_to_queues
+        apply_limit_to_queues
+        apply_blocks_to_queues
+      end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/PerceivedComplexity
+
+      def acquire
+        queues = saved
+        queues ||= Sidekiq::LimitFetch.redis_retryable do
+          selector.acquire(ordered_queues, namespace)
+        end
+        save queues
+        queues.map { |it| "queue:#{it}" }
+      end
 
-    if options[:dynamic].is_a? Hash
-      @dynamic         = true
-      @dynamic_exclude = options[:dynamic][:exclude] || []
-    else
-      @dynamic = options[:dynamic]
-      @dynamic_exclude = []
-    end
+      def release_except(full_name)
+        queues = restore
+        queues.delete full_name[/queue:(.*)/, 1] if full_name
+        Sidekiq::LimitFetch.redis_retryable do
+          selector.release queues, namespace
+        end
+      end
 
-    @limits         = options[:limits] || {}
-    @process_limits = options[:process_limits] || {}
-    @blocks         = options[:blocking] || []
+      def dynamic?
+        @dynamic
+      end
 
-    options[:strict] ? strict_order! : weighted_order!
+      def startup_queue?(queue)
+        @startup_queues.include?(queue)
+      end
 
-    apply_process_limit_to_queues
-    apply_limit_to_queues
-    apply_blocks_to_queues
-  end
+      def dynamic_exclude
+        @dynamic_exclude
+      end
 
-  def acquire
-    queues = saved
-    queues ||= Sidekiq::LimitFetch.redis_retryable do
-      selector.acquire(ordered_queues, namespace)
-    end
-    save queues
-    queues.map { |it| "queue:#{it}" }
-  end
+      def add(queues)
+        return unless queues
 
-  def release_except(full_name)
-    queues = restore
-    queues.delete full_name[/queue:(.*)/, 1] if full_name
-    Sidekiq::LimitFetch.redis_retryable do
-      selector.release queues, namespace
-    end
-  end
+        queues.each do |queue|
+          next if @queues.include? queue
 
-  def dynamic?
-    @dynamic
-  end
+          if startup_queue?(queue)
+            apply_process_limit_to_queue(queue)
+            apply_limit_to_queue(queue)
+          end
 
-  def startup_queue?(queue)
-    @startup_queues.include?(queue)
-  end
+          @queues.push queue
+        end
+      end
 
-  def dynamic_exclude
-    @dynamic_exclude
-  end
+      def remove(queues)
+        return unless queues
 
-  def add(queues)
-    return unless queues
-    queues.each do |queue|
-      unless @queues.include? queue
-        if startup_queue?(queue)
-          apply_process_limit_to_queue(queue)
-          apply_limit_to_queue(queue)
-        end
+        queues.each do |queue|
+          next unless @queues.include? queue
 
-        @queues.push queue
+          clear_limits_for_queue(queue)
+          @queues.delete queue
+          Sidekiq::Queue.delete_instance(queue)
+        end
       end
-    end
-  end
 
-  def remove(queues)
-    return unless queues
-    queues.each do |queue|
-      if @queues.include? queue
-        clear_limits_for_queue(queue)
-        @queues.delete queue
-        Sidekiq::Queue.delete_instance(queue)
+      def handle(queues)
+        add(queues - @queues)
+        remove(@queues - queues)
       end
-    end
-  end
 
-  def handle(queues)
-    add(queues - @queues)
-    remove(@queues - queues)
-  end
+      # rubocop:disable Lint/NestedMethodDefinition
+      def strict_order!
+        @queues.uniq!
+        def ordered_queues
+          @queues
+        end
+      end
 
-  def strict_order!
-    @queues.uniq!
-    def ordered_queues; @queues end
-  end
+      def weighted_order!
+        def ordered_queues
+          @queues.shuffle.uniq
+        end
+      end
+      # rubocop:enable Lint/NestedMethodDefinition
+
+      def namespace
+        @namespace ||= Sidekiq.redis do |it|
+          if it.respond_to?(:namespace) && it.namespace
+            "#{it.namespace}:"
+          else
+            ''
+          end
+        end
+      end
 
-  def weighted_order!
-    def ordered_queues; @queues.shuffle.uniq end
-  end
+      private
 
-  def namespace
-    @namespace ||= Sidekiq.redis do |it|
-      if it.respond_to?(:namespace) and it.namespace
-        "#{it.namespace}:"
-      else
-        ''
+      def apply_process_limit_to_queues
+        @queues.uniq.each do |queue_name|
+          apply_process_limit_to_queue(queue_name)
+        end
       end
-    end
-  end
-
-  private
 
-  def apply_process_limit_to_queues
-    @queues.uniq.each do |queue_name|
-      apply_process_limit_to_queue(queue_name)
-    end
-  end
+      def apply_process_limit_to_queue(queue_name)
+        queue = Sidekiq::Queue[queue_name]
+        queue.process_limit = @process_limits[queue_name.to_s] || @process_limits[queue_name.to_sym]
+      end
 
-  def apply_process_limit_to_queue(queue_name)
-    queue = Sidekiq::Queue[queue_name]
-    queue.process_limit = @process_limits[queue_name.to_s] || @process_limits[queue_name.to_sym]
-  end
+      def apply_limit_to_queues
+        @queues.uniq.each do |queue_name|
+          apply_limit_to_queue(queue_name)
+        end
+      end
 
-  def apply_limit_to_queues
-    @queues.uniq.each do |queue_name|
-      apply_limit_to_queue(queue_name)
-    end
-  end
+      def apply_limit_to_queue(queue_name)
+        queue = Sidekiq::Queue[queue_name]
 
-  def apply_limit_to_queue(queue_name)
-    queue = Sidekiq::Queue[queue_name]
+        return if queue.limit_changed?
 
-    unless queue.limit_changed?
-      queue.limit = @limits[queue_name.to_s] || @limits[queue_name.to_sym]
-    end
-  end
+        queue.limit = @limits[queue_name.to_s] || @limits[queue_name.to_sym]
+      end
 
-  def apply_blocks_to_queues
-    @queues.uniq.each do |queue_name|
-      Sidekiq::Queue[queue_name].unblock
-    end
+      def apply_blocks_to_queues
+        @queues.uniq.each do |queue_name|
+          Sidekiq::Queue[queue_name].unblock
+        end
 
-    @blocks.to_a.each do |it|
-      if it.is_a? Array
-        it.each {|name| Sidekiq::Queue[name].block_except it }
-      else
-        Sidekiq::Queue[it].block
+        @blocks.to_a.each do |it|
+          if it.is_a? Array
+            it.each { |name| Sidekiq::Queue[name].block_except it }
+          else
+            Sidekiq::Queue[it].block
+          end
+        end
       end
-    end
-  end
 
-  def clear_limits_for_queue(queue_name)
-    queue = Sidekiq::Queue[queue_name]
-    queue.clear_limits
-  end
+      def clear_limits_for_queue(queue_name)
+        queue = Sidekiq::Queue[queue_name]
+        queue.clear_limits
+      end
 
-  def selector
-    Sidekiq::LimitFetch::Global::Selector
-  end
+      def selector
+        Sidekiq::LimitFetch::Global::Selector
+      end
 
-  def saved
-    Thread.current[THREAD_KEY]
-  end
+      def saved
+        Thread.current[THREAD_KEY]
+      end
 
-  def save(queues)
-    Thread.current[THREAD_KEY] = queues
-  end
+      def save(queues)
+        Thread.current[THREAD_KEY] = queues
+      end
 
-  def restore
-    saved || []
-  ensure
-    save nil
+      def restore
+        saved || []
+      ensure
+        save nil
+      end
+    end
   end
 end