sidekiq-limit_fetch 4.4.0 → 4.4.1

data/lib/sidekiq/limit_fetch/unit_of_work.rb

@@ -1,32 +1,36 @@
+# frozen_string_literal: true
+
 module Sidekiq
-  class LimitFetch::UnitOfWork < BasicFetch::UnitOfWork
-    def initialize(queue, job)
-      if post_6_5?
-        super(queue, job, Sidekiq)
-      else
-        super
+  module LimitFetch
+    class UnitOfWork < BasicFetch::UnitOfWork
+      def initialize(queue, job)
+        if post_6_5?
+          super(queue, job, Sidekiq)
+        else
+          super
+        end
+        redis_retryable { Queue[queue_name].increase_busy }
       end
-      redis_retryable { Queue[queue_name].increase_busy }
-    end
 
-    def acknowledge
-      redis_retryable { Queue[queue_name].decrease_busy }
-      redis_retryable { Queue[queue_name].release }
-    end
+      def acknowledge
+        redis_retryable { Queue[queue_name].decrease_busy }
+        redis_retryable { Queue[queue_name].release }
+      end
 
-    def requeue
-      super
-      acknowledge
-    end
+      def requeue
+        super
+        acknowledge
+      end
 
-    private
+      private
 
-    def post_6_5?
-      Gem::Version.new(Sidekiq::VERSION) >= Gem::Version.new('6.5.0')
-    end
+      def post_6_5?
+        Gem::Version.new(Sidekiq::VERSION) >= Gem::Version.new('6.5.0')
+      end
 
-    def redis_retryable(&block)
-      Sidekiq::LimitFetch.redis_retryable(&block)
+      def redis_retryable(&block)
+        Sidekiq::LimitFetch.redis_retryable(&block)
+      end
     end
   end
 end

data/lib/sidekiq/limit_fetch.rb

@@ -1,91 +1,95 @@
+# frozen_string_literal: true
+
 require 'forwardable'
 require 'sidekiq'
 require 'sidekiq/manager'
 require 'sidekiq/api'
 
-module Sidekiq::LimitFetch
-  autoload :UnitOfWork, 'sidekiq/limit_fetch/unit_of_work'
+module Sidekiq
+  module LimitFetch
+    autoload :UnitOfWork, 'sidekiq/limit_fetch/unit_of_work'
 
-  require_relative 'limit_fetch/instances'
-  require_relative 'limit_fetch/queues'
-  require_relative 'limit_fetch/global/semaphore'
-  require_relative 'limit_fetch/global/selector'
-  require_relative 'limit_fetch/global/monitor'
-  require_relative 'extensions/queue'
-  require_relative 'extensions/manager'
+    require_relative 'limit_fetch/instances'
+    require_relative 'limit_fetch/queues'
+    require_relative 'limit_fetch/global/semaphore'
+    require_relative 'limit_fetch/global/selector'
+    require_relative 'limit_fetch/global/monitor'
+    require_relative 'extensions/queue'
+    require_relative 'extensions/manager'
 
-  TIMEOUT = Sidekiq::BasicFetch::TIMEOUT
+    TIMEOUT = Sidekiq::BasicFetch::TIMEOUT
 
-  extend self
+    extend self
 
-  def post_7?
-    @post_7 ||= Gem::Version.new(Sidekiq::VERSION) >= Gem::Version.new('7.0.0')
-  end
+    def post_7?
+      @post_7 ||= Gem::Version.new(Sidekiq::VERSION) >= Gem::Version.new('7.0.0')
+    end
 
-  RedisBaseConnectionError = post_7? ? RedisClient::ConnectionError : Redis::BaseConnectionError
-  RedisCommandError = post_7? ? RedisClient::CommandError : Redis::CommandError
+    def post_6_5?
+      @post_6_5 ||= Gem::Version.new(Sidekiq::VERSION) >= Gem::Version.new('6.5.0')
+    end
 
-  def new(_)
-    self
-  end
+    RedisBaseConnectionError = post_7? ? RedisClient::ConnectionError : Redis::BaseConnectionError
+    RedisCommandError = post_7? ? RedisClient::CommandError : Redis::CommandError
 
-  def retrieve_work
-    queue, job = redis_brpop(Queues.acquire)
-    Queues.release_except(queue)
-    UnitOfWork.new(queue, job) if job
-  end
+    def new(_)
+      self
+    end
 
-  def config
-    # Post 6.5, Sidekiq.options is deprecated and replaced with passing Sidekiq directly
-    post_6_5? ? Sidekiq : Sidekiq.options
-  end
+    def retrieve_work
+      queue, job = redis_brpop(Queues.acquire)
+      Queues.release_except(queue)
+      UnitOfWork.new(queue, job) if job
+    end
 
-  # Backwards compatibility for sidekiq v6.1.0
-  # @see https://github.com/mperham/sidekiq/pull/4602
-  def bulk_requeue(*args)
-    if Sidekiq::BasicFetch.respond_to?(:bulk_requeue) # < 6.1.0
-      Sidekiq::BasicFetch.bulk_requeue(*args)
-    else # 6.1.0+
-      Sidekiq::BasicFetch.new(config).bulk_requeue(*args)
+    def config
+      # Post 6.5, Sidekiq.options is deprecated and replaced with passing Sidekiq directly
+      post_6_5? ? Sidekiq : Sidekiq.options
     end
-  end
 
-  def redis_retryable
-    yield
-  rescue RedisBaseConnectionError
-    sleep TIMEOUT
-    retry
-  rescue RedisCommandError => error
-    # If Redis was restarted and is still loading its snapshot,
-    # then we should treat this as a temporary connection error too.
-    if error.message =~ /^LOADING/
+    # Backwards compatibility for sidekiq v6.1.0
+    # @see https://github.com/mperham/sidekiq/pull/4602
+    def bulk_requeue(*args)
+      if Sidekiq::BasicFetch.respond_to?(:bulk_requeue) # < 6.1.0
+        Sidekiq::BasicFetch.bulk_requeue(*args)
+      else # 6.1.0+
+        Sidekiq::BasicFetch.new(post_7? ? Sidekiq.default_configuration.default_capsule : config).bulk_requeue(*args)
+      end
+    end
+
+    def redis_retryable
+      yield
+    rescue RedisBaseConnectionError
       sleep TIMEOUT
       retry
-    else
-      raise
-    end
-  end
+    rescue RedisCommandError => e
+      # If Redis was restarted and is still loading its snapshot,
+      # then we should treat this as a temporary connection error too.
+      raise unless e.message =~ /^LOADING/
 
-  private
+      sleep TIMEOUT
+      retry
+    end
 
-  def post_6_5?
-    @post_6_5 ||= Gem::Version.new(Sidekiq::VERSION) >= Gem::Version.new('6.5.0')
-  end
+    private
 
-  def redis_brpop(queues)
-    if queues.empty?
-      sleep TIMEOUT  # there are no queues to handle, so lets sleep
-      []             # and return nothing
-    else
-      redis_retryable do
-        Sidekiq.redis do |it|
-          if post_7?
-            it.blocking_call(false, "brpop", *queues, TIMEOUT)
-          else
-            it.brpop(*queues, timeout: TIMEOUT)
+    # rubocop:disable Metrics/MethodLength
+    def redis_brpop(queues)
+      if queues.empty?
+        sleep TIMEOUT  # there are no queues to handle, so lets sleep
+        []             # and return nothing
+      else
+        redis_retryable do
+          Sidekiq.redis do |it|
+            if post_7?
+              it.blocking_call(false, 'brpop', *queues, TIMEOUT)
+            else
+              it.brpop(*queues, timeout: TIMEOUT)
+            end
           end
         end
       end
     end
+    # rubocop:enable Metrics/MethodLength
   end
 end

data/lib/sidekiq-limit_fetch.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 require_relative 'sidekiq/limit_fetch'

data/sidekiq-limit_fetch.gemspec

@@ -1,24 +1,32 @@
+# frozen_string_literal: true
+
+require 'English'
 Gem::Specification.new do |gem|
   gem.name          = 'sidekiq-limit_fetch'
-  gem.version       = '4.4.0'
+  gem.version       = '4.4.1'
   gem.license       = 'MIT'
   gem.authors       = ['Dean Perry']
   gem.email         = 'dean@deanpcmad.com'
   gem.summary       = 'Sidekiq strategy to support queue limits'
   gem.homepage      = 'https://github.com/deanpcmad/sidekiq-limit_fetch'
-  gem.description   = "Sidekiq strategy to restrict number of workers which are able to run specified queues simultaneously."
+  gem.description   = 'Sidekiq strategy to restrict number of workers which are able to run specified ' \
+                      'queues simultaneously.'
+
+  gem.metadata['homepage_uri'] = gem.homepage
+  gem.metadata['source_code_uri'] = 'https://github.com/deanpcmad/sidekiq-limit_fetch'
+  gem.metadata['changelog_uri'] = 'https://github.com/deanpcmad/sidekiq-limit_fetch/blob/master/CHANGELOG.md'
+  gem.metadata['rubygems_mfa_required'] = 'true'
 
-  gem.metadata["homepage_uri"] = gem.homepage
-  gem.metadata["source_code_uri"] = "https://github.com/deanpcmad/sidekiq-limit_fetch"
-  gem.metadata["changelog_uri"] = "https://github.com/deanpcmad/sidekiq-limit_fetch/blob/master/CHANGELOG.md"
+  gem.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  gem.require_paths = %w[lib]
 
-  gem.files         = `git ls-files`.split($/)
-  gem.test_files    = gem.files.grep %r{^spec/}
-  gem.require_paths = %w(lib)
+  gem.required_ruby_version = '>= 2.7.0'
 
   gem.add_dependency 'sidekiq', '>= 6'
-  gem.add_development_dependency 'redis-namespace', '~> 1.5', '>= 1.5.2'
   gem.add_development_dependency 'appraisal'
-  gem.add_development_dependency 'rspec'
   gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'redis-namespace', '~> 1.5', '>= 1.5.2'
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'rubocop'
+  gem.add_development_dependency 'simplecov'
 end

data/spec/sidekiq/extensions/manager_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+RSpec.describe Sidekiq::Manager do
+  let(:capsule_or_options) do
+    if Sidekiq::LimitFetch.post_7?
+      Sidekiq.default_configuration.default_capsule
+    elsif Sidekiq::LimitFetch.post_6_5?
+      Sidekiq
+    else
+      Sidekiq.options
+    end
+  end
+
+  it 'can be instantiated' do
+    expect(described_class).to be < Sidekiq::Manager::InitLimitFetch
+    manager = described_class.new(capsule_or_options)
+    expect(manager).to respond_to(:start)
+  end
+end

data/spec/sidekiq/extensions/queue_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 RSpec.describe Sidekiq::Queue do
   context 'singleton' do
     shared_examples :constructor do

data/spec/sidekiq/limit_fetch/global/monitor_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 RSpec.describe Sidekiq::LimitFetch::Global::Monitor do
   let(:monitor) { described_class.start! ttl, timeout }
   let(:ttl) { 1 }
@@ -12,11 +14,11 @@ RSpec.describe Sidekiq::LimitFetch::Global::Monitor do
 
     it 'should remove invalidated old locks' do
       2.times { queue.acquire }
-      sleep 2*ttl
+      sleep ttl * 2
       expect(queue.probed).to eq 2
 
       allow(described_class).to receive(:update_heartbeat)
-      sleep 2*ttl
+      sleep ttl * 2
       expect(queue.probed).to eq 0
     end
 
@@ -26,61 +28,86 @@ RSpec.describe Sidekiq::LimitFetch::Global::Monitor do
       Sidekiq.redis do |it|
         it.del Sidekiq::LimitFetch::Global::Monitor::PROCESS_SET
       end
-      sleep 2*ttl
+      sleep ttl * 2
       expect(queue.probed).to eq 0
     end
-
   end
 
   context 'dynamic queue' do
     let(:limits) do
       {
         'queue1' => 3,
-        'queue2' => 3,
+        'queue2' => 3
       }
     end
     let(:queues) { %w[queue1 queue2] }
     let(:queue) { Sidekiq::LimitFetch::Queues }
-    let(:options) do
-      {
-        limits: limits,
-        queues: queues,
-      }
-    end
 
-    it 'should add dynamic queue' do
-      queue.start(options.merge({ dynamic: true }))
-      monitor
+    let(:config) { Sidekiq::Config.new(options) }
+    let(:capsule) do
+      config.capsule('default') do |cap|
+        cap.concurrency = 1
+        cap.queues = config[:queues]
+      end
+    end
 
-      expect(queue.instance_variable_get(:@queues)).not_to include('queue3')
+    let(:capsule_or_options) do
+      Sidekiq::LimitFetch.post_7? ? capsule : options
+    end
 
-      Sidekiq.redis do |it|
-        it.sadd 'queues', 'queue3'
+    context 'without excluded queue' do
+      let(:options) do
+        {
+          limits: limits,
+          queues: queues,
+          dynamic: true
+        }
       end
 
-      sleep 2*ttl
-      expect(queue.instance_variable_get(:@queues)).to include('queue3')
+      it 'should add dynamic queue' do
+        queue.start(capsule_or_options)
+        monitor
 
-      Sidekiq.redis do |it|
-        it.srem 'queues', 'queue3'
+        expect(queue.instance_variable_get(:@queues)).not_to include('queue3')
+
+        Sidekiq.redis do |it|
+          it.sadd 'queues', 'queue3'
+        end
+
+        sleep ttl * 2
+        expect(queue.instance_variable_get(:@queues)).to include('queue3')
+
+        Sidekiq.redis do |it|
+          it.srem 'queues', 'queue3'
+        end
       end
     end
 
-    it 'should exclude excluded dynamic queue' do
-      queue.start(options.merge({ dynamic: { exclude: ['queue4'] } }))
-      monitor
+    context 'with excluded queue' do
+      let(:options) do
+        {
+          limits: limits,
+          queues: queues,
+          dynamic: { exclude: ['queue4'] }
+        }
+      end
 
-      expect(queue.instance_variable_get(:@queues)).not_to include('queue4')
+      it 'should exclude excluded dynamic queue' do
+        queue.start(capsule_or_options)
+        monitor
 
-      Sidekiq.redis do |it|
-        it.sadd 'queues', 'queue4'
-      end
+        expect(queue.instance_variable_get(:@queues)).not_to include('queue4')
 
-      sleep 2*ttl
-      expect(queue.instance_variable_get(:@queues)).not_to include('queue4')
+        Sidekiq.redis do |it|
+          it.sadd 'queues', 'queue4'
+        end
 
-      Sidekiq.redis do |it|
-        it.srem 'queues', 'queue4'
+        sleep ttl * 2
+        expect(queue.instance_variable_get(:@queues)).not_to include('queue4')
+
+        Sidekiq.redis do |it|
+          it.srem 'queues', 'queue4'
+        end
       end
     end
   end

data/spec/sidekiq/limit_fetch/queues_spec.rb

@@ -1,19 +1,35 @@
+# frozen_string_literal: true
+
 RSpec.describe Sidekiq::LimitFetch::Queues do
   let(:queues)         { %w[queue1 queue2] }
-  let(:limits)         {{ 'queue1' => 3 }}
+  let(:limits)         { { 'queue1' => 3 } }
   let(:strict)         { true }
-  let(:blocking)       {}
-  let(:process_limits) {{ 'queue2' => 3 }}
+  let(:blocking)       { nil }
+  let(:process_limits) { { 'queue2' => 3 } }
 
   let(:options) do
-    { queues:   queues,
-      limits:   limits,
-      strict:   strict,
+    { queues: queues,
+      limits: limits,
+      strict: strict,
       blocking: blocking,
       process_limits: process_limits }
   end
 
-  before { subject.start options }
+  let(:config) { Sidekiq::Config.new(options) }
+  let(:capsule) do
+    config.capsule('default') do |cap|
+      cap.concurrency = 1
+      cap.queues = config[:queues]
+    end
+  end
+
+  let(:capsule_or_options) do
+    Sidekiq::LimitFetch.post_7? ? capsule : options
+  end
+
+  before do
+    subject.start(capsule_or_options)
+  end
 
   def in_thread(&block)
     thr = Thread.new(&block)
@@ -51,36 +67,36 @@ RSpec.describe Sidekiq::LimitFetch::Queues do
   end
 
   it 'should release queues' do
-    in_thread {
+    in_thread do
       subject.acquire
       subject.release_except nil
-    }
+    end
     expect(Sidekiq::Queue['queue1'].probed).to eq 0
     expect(Sidekiq::Queue['queue2'].probed).to eq 0
   end
 
   it 'should release queues except selected' do
-    in_thread {
+    in_thread do
       subject.acquire
       subject.release_except 'queue:queue1'
-    }
+    end
     expect(Sidekiq::Queue['queue1'].probed).to eq 1
     expect(Sidekiq::Queue['queue2'].probed).to eq 0
   end
 
   it 'should release when no queues was acquired' do
-    queues.each {|name| Sidekiq::Queue[name].pause }
-    in_thread {
+    queues.each { |name| Sidekiq::Queue[name].pause }
+    in_thread do
       subject.acquire
       expect { subject.release_except nil }.not_to raise_exception
-    }
+    end
   end
 
   context 'blocking' do
-    let(:blocking) { %w(queue1) }
+    let(:blocking) { %w[queue1] }
 
     it 'should acquire blocking queues' do
-      3.times { in_thread { subject.acquire  } }
+      3.times { in_thread { subject.acquire } }
       expect(Sidekiq::Queue['queue1'].probed).to eq 3
       expect(Sidekiq::Queue['queue2'].probed).to eq 1
     end
@@ -101,11 +117,11 @@ RSpec.describe Sidekiq::LimitFetch::Queues do
     let(:strict) { false }
 
     it 'should retrieve weighted queues' do
-      expect(subject.ordered_queues).to match_array(%w(queue1 queue2))
+      expect(subject.ordered_queues).to match_array(%w[queue1 queue2])
     end
   end
 
   it 'with strict flag should retrieve strictly ordered queues' do
-    expect(subject.ordered_queues).to eq %w(queue1 queue2)
+    expect(subject.ordered_queues).to eq %w[queue1 queue2]
   end
 end

data/spec/sidekiq/limit_fetch/semaphore_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 RSpec.describe 'semaphore' do
   let(:name) { 'default' }
   subject { Sidekiq::LimitFetch::Global::Semaphore.new name }

data/spec/sidekiq/limit_fetch_spec.rb

@@ -1,12 +1,22 @@
+# frozen_string_literal: true
+
 Thread.abort_on_exception = true
 
 RSpec.describe Sidekiq::LimitFetch do
-  let(:options) {{ queues: queues, limits: limits }}
-  let(:queues) { %w(queue1 queue1 queue2 queue2) }
-  let(:limits) {{ 'queue1' => 1, 'queue2' => 2 }}
+  let(:options) { { queues: queues, limits: limits } }
+  let(:queues) { %w[queue1 queue1 queue2 queue2] }
+  let(:limits) { { 'queue1' => 1, 'queue2' => 2 } }
+  let(:config) { Sidekiq::Config.new(options) }
+  let(:capsule) do
+    config.capsule('default') do |cap|
+      cap.concurrency = 1
+      cap.queues = config[:queues]
+    end
+  end
+  let(:capsule_or_config) { Sidekiq::LimitFetch.post_7? ? capsule : options }
 
   before do
-    subject::Queues.start options
+    subject::Queues.start(capsule_or_config)
 
     Sidekiq.redis do |it|
       it.del 'queue:queue1'

data/spec/spec_helper.rb

@@ -1,3 +1,8 @@
+# frozen_string_literal: true
+
+require 'simplecov'
+SimpleCov.start
+
 require 'sidekiq/limit_fetch'
 
 if Sidekiq::LimitFetch.post_7?
@@ -6,7 +11,7 @@ if Sidekiq::LimitFetch.post_7?
   end
 else
   Sidekiq.logger = nil
-  Sidekiq.redis = { namespace: ENV['namespace'] }
+  Sidekiq.redis = { namespace: ENV.fetch('namespace', nil) }
 end
 
 RSpec.configure do |config|
@@ -16,7 +21,7 @@ RSpec.configure do |config|
   config.before do
     Sidekiq::Queue.reset_instances!
     Sidekiq.redis do |it|
-      clean_redis = ->(queue) do
+      clean_redis = lambda do |queue|
         it.pipelined do |pipeline|
           pipeline.del "limit_fetch:limit:#{queue}"
           pipeline.del "limit_fetch:process_limit:#{queue}"
@@ -28,7 +33,7 @@ RSpec.configure do |config|
       end
 
       clean_redis.call(name) if defined?(name)
-      queues.each(&clean_redis) if defined?(queues) and queues.is_a? Array
+      queues.each(&clean_redis) if defined?(queues) && queues.is_a?(Array)
     end
   end
 end