sidekiq-pauzer 1.0.0.alpha → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b38aee70ca050a4c5c0f8c41d81bae5b755bb4a73fd1b5ddb7b365fb61ba3f40
-  data.tar.gz: e233b4b60fc065a12c29f809ad196f763f05a54d7bec640c338dce6ec2c62984
+  metadata.gz: b31cb662c56453b04bebf1a887af9515aa0d86a74f9c9e0c6bb79513c499ed7e
+  data.tar.gz: c57e7667afcabea723ffdb57f5ae38f53ab756c22f2952bb1344d660df806bd4
 SHA512:
-  metadata.gz: 8e106b6c3e162eafddf56da121c6d3af3319928a145c1991f9c09ceeb54751eb68a15f716731e5bf2feb15fd785a7062ce19db5523a79b8a3be2e1889af39c94
-  data.tar.gz: 1db224ec249b5729e903a0ad8fc9f58235e8a39c5bc39f00a2e11a426c3a0ec20fb216faa5bf144ef20bbfa93f4dc94d8599546ab46052724142a89420e29a07
+  metadata.gz: 5456887979763bf5c4c741fa2dec95c4454222f77d65f212f4472a68dd248880a7b18687a6df999d9c6c25291d01027c01c4fed4630948d579cd9f2174f8635e
+  data.tar.gz: af94a161c39ff35abd29aa35a110c69d25144fd7b3d54b63bae65c64053694813e1eb7a8741e35182342b9e3c9b8de041290e8f46ffc3da6e34b6f489988365b

data/README.adoc

@@ -34,6 +34,25 @@ Sidekiq.configure_server do |config|
 end
 ----
 
+=== API
+
+This gem enhances Sidekiq's Queue API with:
+
+[source, ruby]
+----
+Sidekiq::Queue.new("critical").paused? # => true|false
+Sidekiq::Queue.new("critical").pause!
+Sidekiq::Queue.new("critical").unpause!
+----
+
+Those translates to:
+
+[source, ruby]
+----
+Sidekiq::Pauzer.paused?("critical") # => true|false
+Sidekiq::Pauzer.pause!("critical")
+Sidekiq::Pauzer.unpause!("critical")
+----
 
 === Adding Pause/Resume Button to the Queues Tab
 
@@ -47,7 +66,39 @@ require "sidekiq/pauzer/web"
 ----
 
 NOTE: If you are using custom Sidekiq views path, then you will need to call
-  (after requiring `sidekiq/pauzer/web`): `Sidekiq::Pauzer.unpatch_views!`.
+  (after requiring `sidekiq/pauzer/web`): `Sidekiq::Pauzer::Web.unpatch_views!`.
+
+
+== Supported Ruby Versions
+
+This library aims to support and is tested against the following Ruby versions:
+
+* Ruby 2.7.x
+* Ruby 3.0.x
+* Ruby 3.1.x
+* Ruby 3.2.x
+
+If something doesn't work on one of these versions, it's a bug.
+
+This library may inadvertently work (or seem to work) on other Ruby versions,
+however support will only be provided for the versions listed above.
+
+If you would like this library to support another Ruby version or
+implementation, you may volunteer to be a maintainer. Being a maintainer
+entails making sure all tests run and pass on that implementation. When
+something breaks on your implementation, you will be responsible for providing
+patches in a timely fashion. If critical issues for a particular implementation
+exist at the time of a major release, support for that Ruby version may be
+dropped.
+
+
+== Supported Sidekiq Versions
+
+This library aims to support and work with following Sidekiq versions:
+
+* Sidekiq 6.5.x
+* Sidekiq 7.0.x
+* Sidekiq 7.1.x
 
 
 == Development

data/lib/sidekiq/pauzer/adapters/redis.rb

@@ -13,15 +13,15 @@ module Sidekiq
             false
           end
 
-          def pause!(redis, key, queue)
+          def add(redis, key, queue)
             redis.sadd(key, queue)
           end
 
-          def unpause!(redis, key, queue)
+          def remove(redis, key, queue)
             redis.srem(key, queue)
           end
 
-          def paused_queues(redis, key)
+          def list(redis, key)
             # Cursor is not atomic, so there may be duplicates because of
             # concurrent update operations
             # See: https://redis.io/commands/scan/#scan-guarantees

data/lib/sidekiq/pauzer/adapters/redis_client.rb

@@ -1,31 +1,30 @@
 # frozen_string_literal: true
 
+require_relative "../runtime"
+
 module Sidekiq
   module Pauzer
     module Adapters
       # redis-client adapter
       module RedisClient
-        SIDEKIQ_SEVEN   = Gem::Version.new("7.0.0").freeze
-        SIDEKIQ_VERSION = Gem::Version.new(Sidekiq::VERSION).freeze
-
         class << self
           def adapts?(redis)
-            return true if SIDEKIQ_SEVEN <= SIDEKIQ_VERSION
+            return true if Runtime::SIDEKIQ_SEVEN
             return true if defined?(::RedisClient) && redis.is_a?(::RedisClient)
             return true if defined?(::RedisClient::Decorator::Client) && redis.is_a?(::RedisClient::Decorator::Client)
 
             false
           end
 
-          def pause!(redis, key, queue)
+          def add(redis, key, queue)
             redis.call("SADD", key, queue)
           end
 
-          def unpause!(redis, key, queue)
+          def remove(redis, key, queue)
             redis.call("SREM", key, queue)
           end
 
-          def paused_queues(redis, key)
+          def list(redis, key)
             # Cursor is not atomic, so there may be duplicates because of
             # concurrent update operations
             # See: https://redis.io/commands/scan/#scan-guarantees

data/lib/sidekiq/pauzer/basic_fetch.rb

@@ -3,37 +3,47 @@
 require "sidekiq"
 require "sidekiq/fetch"
 
+require_relative "./runtime"
+
 module Sidekiq
   module Pauzer
     # Default Sidekiq's BasicFetch infused with Pauzer
     class BasicFetch < Sidekiq::BasicFetch
       private
 
-      if Gem::Version.new("7.0.0") <= Gem::Version.new(Sidekiq::VERSION)
+      if Runtime::SIDEKIQ_SEVEN
         def queues_cmd
-          if @strictly_ordered_queues
-            @queues - Pauzer.paused_queues
-          else
-            permute = (@queues - Pauzer.paused_queues)
-            permute.shuffle!
-            permute.uniq!
-            permute
-          end
+          queues =
+            if @strictly_ordered_queues
+              @queues
+            else
+              permute = @queues.dup
+              permute.shuffle!
+              permute.uniq!
+              permute
+            end
+
+          excluding_paused(queues)
         end
       else
         def queues_cmd
-          if @strictly_ordered_queues
-            *queues, timeout = @queues
+          queues =
+            if @strictly_ordered_queues
+              @queues[0...-1]
+            else
+              permute = @queues.dup
+              permute.shuffle!
+              permute.uniq!
+              permute
+            end
 
-            (queues - Pauzer.paused_queues) << timeout
-          else
-            permute = (@queues - Pauzer.paused_queues)
-            permute.shuffle!
-            permute.uniq!
-            permute << { timeout: Sidekiq::BasicFetch::TIMEOUT }
-          end
+          excluding_paused(queues) << { timeout: Sidekiq::BasicFetch::TIMEOUT }
         end
       end
+
+      def excluding_paused(queues)
+        queues - Pauzer.paused_queue_names.map { |name| "queue:#{name}" }
+      end
     end
   end
 end

data/lib/sidekiq/pauzer/patches/queue.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "sidekiq"
+require "sidekiq/api"
+
+module Sidekiq
+  module Pauzer
+    module Patches
+      # @private
+      module Queue
+        def self.apply!
+          Sidekiq::Queue.prepend(self)
+        end
+
+        def paused?
+          Pauzer.paused?(name)
+        end
+
+        def pause!
+          Pauzer.pause!(name)
+          nil
+        end
+
+        def unpause!
+          Pauzer.unpause!(name)
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/pauzer/patches/web_action.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "erb"
+
+require "sidekiq"
+require "sidekiq/web"
+
+module Sidekiq
+  module Pauzer
+    module Patches
+      # @private
+      module WebAction
+        PAUZER_QUEUES_TEMPLATE =
+          ERB.new(File.read(File.expand_path("../../../../web/views/queues.erb", __dir__))).src
+
+        class << self
+          def apply!
+            revert!
+
+            Sidekiq::WebAction.class_eval <<-RUBY, __FILE__, __LINE__ + 1 # rubocop:disable Style/DocumentDynamicEvalDefinition
+              def _erb_queues
+                #{PAUZER_QUEUES_TEMPLATE}
+              end
+            RUBY
+          end
+
+          def revert!
+            Sidekiq::WebAction.remove_method(:_erb_queues) if Sidekiq::WebAction.method_defined?(:_erb_queues)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/pauzer/patches/web_application.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "sidekiq"
+require "sidekiq/web"
+
+module Sidekiq
+  module Pauzer
+    module Patches
+      # @private
+      module WebApplication
+        class << self
+          def apply!
+            remove_theirs_queue_update_route
+            register_ours_queue_update_route
+          end
+
+          private
+
+          def remove_theirs_queue_update_route
+            Sidekiq::WebApplication
+              .instance_variable_get(:@routes)
+              .fetch(Sidekiq::WebRouter::POST)
+              .delete_if { |route| route.pattern == "/queues/:name" }
+          end
+
+          def register_ours_queue_update_route # rubocop:disable Metrics/MethodLength
+            Sidekiq::WebApplication.class_exec do
+              post "/queues/:name" do
+                queue = Sidekiq::Queue.new(route_params[:name])
+
+                if params["pause"]
+                  queue.pause!
+                elsif params["unpause"]
+                  queue.unpause!
+                else
+                  queue.clear
+                end
+
+                redirect "#{root_path}queues"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/pauzer/queues.rb

@@ -12,12 +12,10 @@ module Sidekiq
 
       class Refresher < Concurrent::TimerTask; end
 
-      QUEUE_PREFIX = "queue:"
-
       # @param config [Config]
       def initialize(config)
         @mutex     = Mutex.new
-        @queues    = []
+        @names     = []
         @redis_key = config.redis_key
         @refresher = initialize_refresher(config.refresh_rate)
       end
@@ -25,39 +23,41 @@ module Sidekiq
       def each(&block)
         return to_enum __method__ unless block
 
-        @mutex.synchronize { @queues.dup }.each(&block)
+        @mutex.synchronize { @names.dup }.each(&block)
 
         self
       end
 
-      def pause!(queue)
-        queue = normalize_queue_name(queue)
-
-        Sidekiq.redis { |conn| Adapters[conn].pause!(conn, @redis_key, queue) }
+      # @param name [#to_s]
+      def pause!(name)
+        Sidekiq.redis { |conn| Adapters[conn].add(conn, @redis_key, name.to_s) }
 
         refresh
       end
 
-      def unpause!(queue)
-        queue = normalize_queue_name(queue)
-
-        Sidekiq.redis { |conn| Adapters[conn].unpause!(conn, @redis_key, queue) }
+      # @param name [#to_s]
+      def unpause!(name)
+        Sidekiq.redis { |conn| Adapters[conn].remove(conn, @redis_key, name.to_s) }
 
         refresh
       end
 
-      def paused?(queue)
-        include?(normalize_queue_name(queue))
+      # @param name [#to_s]
+      # @return [Boolean]
+      def paused?(name)
+        include?(name.to_s)
       end
 
       def start_refresher
         @refresher.execute
-        nil
+
+        self
       end
 
       def stop_refresher
         @refresher.shutdown
-        nil
+
+        self
       end
 
       def refresher_running?
@@ -74,19 +74,13 @@ module Sidekiq
 
       def refresh
         @mutex.synchronize do
-          paused_queues = Sidekiq.redis do |conn|
-            Adapters[conn].paused_queues(conn, @redis_key)
-          end
+          names = Sidekiq.redis { |conn| Adapters[conn].list(conn, @redis_key) }
 
-          @queues.replace(paused_queues)
+          @names.replace(names)
         end
 
         self
       end
-
-      def normalize_queue_name(queue)
-        queue.dup.delete_prefix(QUEUE_PREFIX)
-      end
     end
   end
 end

data/lib/sidekiq/pauzer/runtime.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "sidekiq"
+
+module Sidekiq
+  module Pauzer
+    module Runtime
+      SIDEKIQ_SEVEN = Gem::Version.new("7.0.0") <= Gem::Version.new(Sidekiq::VERSION)
+    end
+  end
+end

data/lib/sidekiq/pauzer/version.rb

@@ -2,6 +2,6 @@
 
 module Sidekiq
   module Pauzer
-    VERSION = "1.0.0.alpha"
+    VERSION = "1.1.0"
   end
 end

data/lib/sidekiq/pauzer/web.rb

@@ -1,46 +1,17 @@
 # frozen_string_literal: true
 
-require "erb"
-require "sidekiq"
-require "sidekiq/web"
-
-require_relative "../pauzer"
+require_relative "./patches/web_action"
+require_relative "./patches/web_application"
 
 module Sidekiq
   module Pauzer
-    def self.unpatch_views!
-      WebAction.remove_method(:_erb_queues)
-    end
-  end
-
-  class WebApplication
-    @routes[Sidekiq::WebRouter::POST].delete_if do |web_route|
-      web_route.pattern == "/queues/:name"
-    end
-
-    post "/queues/:name" do
-      queue = Sidekiq::Queue.new(route_params[:name])
-
-      if params["pause"]
-        queue.pause!
-      elsif params["unpause"]
-        queue.unpause!
-      else
-        queue.clear
+    module Web
+      def self.unpatch_views!
+        Patches::WebAction.revert!
       end
-
-      redirect "#{root_path}queues"
     end
   end
-
-  class WebAction
-    PAUZER_QUEUES_TEMPLATE =
-      ERB.new(File.read(File.expand_path("../../../web/views/queues.erb", __dir__))).src
-
-    class_eval <<-RUBY, __FILE__, __LINE__ + 1 # rubocop:disable Style/DocumentDynamicEvalDefinition
-      def _erb_queues
-        #{PAUZER_QUEUES_TEMPLATE}
-      end
-    RUBY
-  end
 end
+
+Sidekiq::Pauzer::Patches::WebAction.apply!
+Sidekiq::Pauzer::Patches::WebApplication.apply!

data/lib/sidekiq/pauzer.rb

@@ -6,6 +6,7 @@ require "sidekiq/api"
 
 require_relative "./pauzer/basic_fetch"
 require_relative "./pauzer/config"
+require_relative "./pauzer/patches/queue"
 require_relative "./pauzer/queues"
 require_relative "./pauzer/version"
 
@@ -28,57 +29,123 @@ module Sidekiq
   module Pauzer
     MUTEX = Mutex.new
 
-    @config = Config.new
+    @config = Config.new.freeze
     @queues = Queues.new(@config)
 
     class << self
       extend Forwardable
 
-      def_delegators :@queues, :pause!, :unpause!, :paused?
+      # @!attribute [r] redis_key
+      #   @see Config#redis_key
+      #   @return [String]
+      def_delegators :@config, :redis_key
+
+      # @example
+      #   Sidekiq::Pauzer.pause!("minor")
+      #   Sidekiq::Pauzer.paused?("minor") # => true
+      #
+      # @param (see Queues#pause!)
+      # @return [void]
+      def pause!(name)
+        @queues.pause!(name)
+
+        nil
+      end
+
+      # @example
+      #   Sidekiq::Pauzer.pause!("minor")
+      #   Sidekiq::Pauzer.paused?("minor") # => true
+      #   Sidekiq::Pauzer.unpause!("minor")
+      #   Sidekiq::Pauzer.paused?("minor") # => false
+      #
+      # @param (see Queues#unpause!)
+      # @return [void]
+      def unpause!(name)
+        @queues.unpause!(name)
+
+        nil
+      end
+
+      # @example
+      #   Sidekiq::Pauzer.pause!("minor")
+      #   Sidekiq::Pauzer.paused?("minor")  # => true
+      #   Sidekiq::Pauzer.paused?("threat") # => false
+      #
+      # @see Queues#paused?
+      def paused?(name)
+        @queues.paused?(name)
+      end
 
+      # @example
+      #   Sidekiq::Pauzer.pause!("minor")
+      #   Sidekiq::Pauzer.paused_queue_names # => ["minor"]
+      #
+      # @return [Array<String>]
+      def paused_queue_names
+        @queues.to_a
+      end
+
+      # @deprecated Use {.paused_queue_names} instead.
+      #   Will be removed in ‹2.0.0›.
+      #
+      # @example
+      #   Sidekiq::Pauzer.pause!("minor")
+      #   Sidekiq::Pauzer.paused_queues # => ["queue:minor"]
+      #
+      # @return [Array<String>]
       def paused_queues
-        @queues.map { |queue| "#{Queues::QUEUE_PREFIX}#{queue}" }
+        @queues.map { |name| "queue:#{name}" }
       end
 
+      # Yields `config` for a block.
+      #
+      # @example
+      #   Sidekiq::Pauzer.configure do |config|
+      #     config.refresh_rate = 42
+      #   end
+      #
+      # @yieldparam config [Config]
       def configure
         MUTEX.synchronize do
-          yield @config
+          config = @config.dup
+
+          yield config
+
+          @config = config.freeze
+
+          self
         ensure
-          start_refresher = @queues.refresher_running?
-          @queues.stop_refresher
-          @queues = Queues.new(@config)
-          @queues.start_refresher if start_refresher
+          reinit_queues
         end
       end
 
       def startup
         MUTEX.synchronize { @queues.start_refresher }
+
+        self
       end
 
       def shutdown
         MUTEX.synchronize { @queues.stop_refresher }
-      end
-    end
-  end
-
-  class Queue
-    remove_method :paused?
 
-    def paused?
-      Pauzer.paused?(name)
-    end
+        self
+      end
 
-    def pause!
-      Pauzer.pause!(name)
-    end
+      private
 
-    def unpause!
-      Pauzer.unpause!(name)
+      def reinit_queues
+        start_refresher = @queues.refresher_running?
+        @queues.stop_refresher
+        @queues = Queues.new(@config)
+        @queues.start_refresher if start_refresher
+      end
     end
   end
 
   configure_server do |config|
-    config.on(:startup) { Pauzer.startup }
+    config.on(:startup)  { Pauzer.startup }
     config.on(:shutdown) { Pauzer.shutdown }
   end
 end
+
+Sidekiq::Pauzer::Patches::Queue.apply!

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-pauzer
 version: !ruby/object:Gem::Version
-  version: 1.0.0.alpha
+  version: 1.1.0
 platform: ruby
 authors:
 - Alexey Zapparov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-05-03 00:00:00.000000000 Z
+date: 2023-05-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -53,7 +53,11 @@ files:
 - lib/sidekiq/pauzer/adapters/redis_client.rb
 - lib/sidekiq/pauzer/basic_fetch.rb
 - lib/sidekiq/pauzer/config.rb
+- lib/sidekiq/pauzer/patches/queue.rb
+- lib/sidekiq/pauzer/patches/web_action.rb
+- lib/sidekiq/pauzer/patches/web_application.rb
 - lib/sidekiq/pauzer/queues.rb
+- lib/sidekiq/pauzer/runtime.rb
 - lib/sidekiq/pauzer/version.rb
 - lib/sidekiq/pauzer/web.rb
 - web/views/queues.erb
@@ -62,9 +66,9 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://gitlab.com/ixti/sidekiq-pauzer
-  source_code_uri: https://gitlab.com/ixti/sidekiq-pauzer/tree/v1.0.0.alpha
+  source_code_uri: https://gitlab.com/ixti/sidekiq-pauzer/tree/v1.1.0
   bug_tracker_uri: https://gitlab.com/ixti/sidekiq-pauzer/issues
-  changelog_uri: https://gitlab.com/ixti/sidekiq-pauzer/blob/v1.0.0.alpha/CHANGES.md
+  changelog_uri: https://gitlab.com/ixti/sidekiq-pauzer/blob/v1.1.0/CHANGES.md
   rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
@@ -77,9 +81,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.4.10
 signing_key: