sidekiq-throttled 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 427e3b20c7b521948d64ca4d6845c660eaebf278
-  data.tar.gz: 25ccc08885012c0f7269651399d117d1bca07c9c
+  metadata.gz: 1fe478db1a3774d9aeaa83d54658eb39137fa001
+  data.tar.gz: 3bb17c56babff2a8ab46fe18bde97f39482402ac
 SHA512:
-  metadata.gz: a8d5aa36914a6c4a69f6b644defd5c97a34ca38d04c59707b4b74a58d559911509599e51428670d875c1b4a8aef10e8d944be51cdaafbb9b0196cab7ac9b9250
-  data.tar.gz: 06af7fc7818f88df36c017e92c1033429ad782ab3a0c11eb698b531d649efb7cbb294f1e1865bbaa8eb33de4c023a393f6429edca75d4806f4c501ade2a37b21
+  metadata.gz: 81b3a563dc78de58619d964afc2a940c0b0f93789b0e39ed1ea390cb3e1991c0b4445b9572a60464e0dc2d7330251d7a4049a1dbed5111fac42444f0ed146894
+  data.tar.gz: 8be93fdcaa16dfec95b12f91a2bb81c580cc617761308cceaba6c588b9cc0e78e822091fbbee9c56895dbff7d6d1df2255aeed771bc842447da257456fbb5576

data/.coveralls.yml

@@ -0,0 +1 @@
+service_name: travis-ci

data/.travis.yml

@@ -1,22 +1,16 @@
 language: ruby
 rvm:
-  - 2.0
-  - 2.1
-  - 2.2
-  - 2.3.0
+  - 2.2.5
   - 2.3.1
   - ruby-head
-  - jruby-9.0.0.0
-  - jruby-9.0.1.0
+  - jruby-9.0.5.0
   - jruby-head
-  - ruby-head
   - rbx-2
 matrix:
   allow_failures:
-    - rvm: jruby-9.0.0.0
-    - rvm: jruby-9.0.1.0
-    - rvm: jruby-head
     - rvm: ruby-head
+    - rvm: jruby-9.0.5.0
+    - rvm: jruby-head
     - rvm: rbx-2
   fast_finish: true
 gemfile:

data/CHANGES.md

@@ -1,9 +1,23 @@
+## 0.6.0 (2016-08-27)
+
+* [#21](https://github.com/sensortower/sidekiq-throttled/pull/21)
+  Allow pause/unpause queues.
+  ([@ixti])
+
+
 ## 0.5.0 (2016-08-18)
 
 * Drop Sidekiq 3.x support.
   ([@ixti])
 
 
+## 0.4.1 (2016-08-18)
+
+* [#15](https://github.com/sensortower/sidekiq-throttled/pull/15)
+  Fix throttled web UI on older versions of sidekiq.
+  ([@palanglung])
+
+
 ## 0.4.0 (2016-05-17)
 
 * [#14](https://github.com/sensortower/sidekiq-throttled/pull/14)

data/Gemfile

@@ -5,10 +5,10 @@ source "https://rubygems.org"
 gem "appraisal"
 gem "rake"
 gem "rspec"
-gem "rubocop"
+gem "rubocop", "~> 0.42.0", :require => false
 
 group :test do
-  gem "coveralls"
+  gem "coveralls", :require => false
   gem "rack-test"
   gem "simplecov", ">= 0.9"
   gem "sinatra", "~> 1.4", ">= 1.4.6"

data/README.md

@@ -121,8 +121,6 @@ some trouble.
 This library aims to support and is [tested against][travis] the following Ruby
 versions:
 
-* Ruby 2.0.0
-* Ruby 2.1.x
 * Ruby 2.2.x
 * Ruby 2.3.x
 

data/gemfiles/sidekiq_4.0.gemfile

@@ -5,7 +5,7 @@ source "https://rubygems.org"
 gem "appraisal"
 gem "rake"
 gem "rspec"
-gem "rubocop"
+gem "rubocop", "~> 0.42.0", :require => false
 gem "sidekiq", "~> 4.0.0"
 
 group :test do

data/gemfiles/sidekiq_4.1.gemfile

@@ -5,7 +5,7 @@ source "https://rubygems.org"
 gem "appraisal"
 gem "rake"
 gem "rspec"
-gem "rubocop"
+gem "rubocop", "~> 0.42.0", :require => false
 gem "sidekiq", "~> 4.1.0"
 
 group :test do

data/gemfiles/sidekiq_latest.gemfile

@@ -5,7 +5,7 @@ source "https://rubygems.org"
 gem "appraisal"
 gem "rake"
 gem "rspec"
-gem "rubocop"
+gem "rubocop", "~> 0.42.0", :require => false
 gem "sidekiq"
 
 group :test do

data/lib/sidekiq/throttled/communicator/callbacks.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "fiber"
+require "thread"
+
+require "sidekiq/exception_handler"
+
+module Sidekiq
+  module Throttled
+    class Communicator
+      # Callbacks registry and runner. Runs registered callbacks in dedicated
+      # Fiber solving issue with ConnectionPool and Redis client in subscriber
+      # mode.
+      #
+      # Once Redis entered subscriber mode `#subscribe` method, it can't be used
+      # for any command but pub/sub or quit, making it impossible to use for
+      # anything else. ConnectionPool binds reserved client to Thread, thus
+      # nested `#with` calls inside same thread result into a same connection.
+      # That makes it impossible to issue any normal Redis commands from
+      # within listener Thread.
+      #
+      # @private
+      class Callbacks
+        include ExceptionHandler
+
+        # Initializes callbacks registry.
+        def initialize
+          @mutex    = Mutex.new
+          @handlers = Hash.new { |h, k| h[k] = [] }
+        end
+
+        # Registers handler of given event.
+        #
+        # @example
+        #
+        #   callbacks.on "and out comes wolves" do |who|
+        #     puts "#{who} let the dogs out?!"
+        #   end
+        #
+        # @param [#to_s] event
+        # @raise [ArgumentError] if no handler block given
+        # @yield [*args] Runs given block upon `event`
+        # @yieldreturn [void]
+        # @return [self]
+        def on(event, &handler)
+          raise ArgumentError, "No block given" unless handler
+          @mutex.synchronize { @handlers[event.to_s] << handler }
+          self
+        end
+
+        # Runs event handlers with given args.
+        #
+        # @param [#to_s] event
+        # @param [Object] payload
+        # @return [void]
+        def run(event, payload = nil)
+          @mutex.synchronize do
+            Fiber.new do
+              @handlers[event.to_s].each do |callback|
+                begin
+                  callback.call(payload)
+                rescue => e
+                  handle_exception(e, {
+                    :context => "sidekiq:throttled".freeze
+                  })
+                end
+              end
+            end.resume
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/throttled/communicator/listener.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "sidekiq/exception_handler"
+
+module Sidekiq
+  module Throttled
+    class Communicator
+      # Redis subscription listener thread.
+      #
+      # @private
+      class Listener < Thread
+        include ExceptionHandler
+
+        # Starts listener thread.
+        #
+        # @param [String] channel Redis pub/sub channel to listen
+        # @param [Callbacks] callbacks Message callbacks registry
+        def initialize(channel, callbacks)
+          @channel    = channel
+          @callbacks  = callbacks
+          @terminated = false
+          @subscribed = false
+
+          super { listen until @terminated }
+        end
+
+        # Whenever underlying redis client subscribed to pub/sup channel.
+        #
+        # @return [Boolean]
+        def ready?
+          @subscribed
+        end
+
+        # Whenever main loop is still running.
+        #
+        # @return [Boolean]
+        def listening?
+          !@terminated
+        end
+
+        # Stops listener.
+        #
+        # @return [void]
+        def stop
+          # Raising exception while client is in subscription mode makes
+          # redis close connection and thus causing ConnectionPool reopen
+          # it (normal mode). Otherwise subscription mode client will be
+          # pushed back to ConnectionPool causing problems.
+          raise Sidekiq::Shutdown
+        end
+
+        private
+
+        # Wraps {#subscribe} with exception handlers:
+        #
+        # - `Sidekiq::Shutdown` exception marks listener as stopped and returns
+        #   making `while` loop of listener thread terminate.
+        #
+        # - `StandardError` got recorded to the log and swallowed,
+        #   making `while` loop of the listener thread restart.
+        #
+        # - `Exception` is recorded to the log and re-raised.
+        #
+        # @return [void]
+        def listen
+          subscribe
+        rescue Sidekiq::Shutdown
+          @terminated = true
+          @subscribed = false
+        rescue StandardError => e
+          @subscribed = false
+          handle_exception(e, { :context => "sidekiq:throttled".freeze })
+          sleep 1
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          @terminated = true
+          @subscribed = false
+          handle_exception(e, { :context => "sidekiq:throttled".freeze })
+          raise
+        end
+
+        # Subscribes to channel and triggers all registerd handlers for
+        # received messages.
+        #
+        # @note Puts thread's Redis connection to subscription mode and
+        #   locks thread.
+        #
+        # @see http://redis.io/topics/pubsub
+        # @see http://redis.io/commands/subscribe
+        # @see Callbacks#run
+        # @return [void]
+        def subscribe
+          Sidekiq.redis do |conn|
+            conn.subscribe @channel do |on|
+              on.subscribe do
+                @subscribed = true
+                @callbacks.run("ready")
+              end
+
+              on.message do |_channel, data|
+                message, payload = Marshal.load(data)
+                @callbacks.run("message:#{message}", payload)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/throttled/communicator.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "thread"
+require "singleton"
+
+require "sidekiq/exception_handler"
+require "sidekiq/throttled/communicator/listener"
+require "sidekiq/throttled/communicator/callbacks"
+
+module Sidekiq
+  module Throttled
+    # Inter-process communication for sidekiq. It starts listener thread on
+    # sidekiq server and listens for incoming messages.
+    #
+    # @example
+    #
+    #   # Add incoming message handler for server
+    #   Communicator.instance.receive "knock" do |who|
+    #     puts "#{who}'s knocking on the door"
+    #   end
+    #
+    #   # Emit message from console
+    #   Sidekiq.redis do |conn|
+    #     Communicator.instance.transmit(conn, "knock", "ixti")
+    class Communicator
+      include Singleton
+      include ExceptionHandler
+
+      # Redis PUB/SUB channel name
+      #
+      # @see http://redis.io/topics/pubsub
+      CHANNEL_NAME = "sidekiq:throttled".freeze
+      private_constant :CHANNEL_NAME
+
+      # Initializes singleton instance.
+      def initialize
+        @callbacks = Callbacks.new
+        @listener  = nil
+        @mutex     = Mutex.new
+      end
+
+      # Starts listener thread.
+      #
+      # @return [void]
+      def start_listener
+        @mutex.synchronize do
+          @listener ||= Listener.new(CHANNEL_NAME, @callbacks)
+        end
+      end
+
+      # Stops listener thread.
+      #
+      # @return [void]
+      def stop_listener
+        @mutex.synchronize do
+          @listener.stop if @listener
+          @listener = nil
+        end
+      end
+
+      # Configures Sidekiq server to start/stop listener thread.
+      #
+      # @private
+      # @return [void]
+      def setup!
+        Sidekiq.configure_server do |config|
+          config.on(:startup) { start_listener }
+          config.on(:quiet) { stop_listener }
+        end
+      end
+
+      # Transmit message to listeners.
+      #
+      # @example
+      #
+      #   Sidekiq.redis do |conn|
+      #     Communicator.instance.transmit(conn, "knock")
+      #   end
+      #
+      # @param [Redis] redis Redis client
+      # @param [#to_s] message
+      # @param [Object] payload
+      # @return [void]
+      def transmit(redis, message, payload = nil)
+        redis.publish(CHANNEL_NAME, Marshal.dump([message.to_s, payload]))
+      end
+
+      # Add incoming message handler.
+      #
+      # @example
+      #
+      #   Communicator.instance.receive "knock" do |payload|
+      #     # do something upon `knock` message
+      #   end
+      #
+      # @param [#to_s] message
+      # @yield [payload] Runs given block everytime `message` being received.
+      # @yieldparam [Object, nil] payload Payload that was transmitted
+      # @yieldreturn [void]
+      # @return [void]
+      def receive(message, &handler)
+        @callbacks.on("message:#{message}", &handler)
+      end
+
+      # Communicator readiness hook.
+      #
+      # @yield Runs given block every time listener thread subscribes
+      #   to Redis pub/sub channel.
+      # @return [void]
+      def ready(&handler)
+        @callbacks.on("ready", &handler)
+        yield if @listener && @listener.ready?
+      end
+    end
+  end
+end

data/lib/sidekiq/throttled/fetch.rb

@@ -2,18 +2,24 @@
 
 require "sidekiq"
 require "sidekiq/throttled/unit_of_work"
+require "sidekiq/throttled/queues_pauser"
+require "sidekiq/throttled/queue_name"
 
 module Sidekiq
   module Throttled
     # Throttled fetch strategy.
+    #
+    # @private
     class Fetch
       TIMEOUT = 2
       private_constant :TIMEOUT
 
+      # Initializes fetcher instance.
       def initialize(options)
-        @strictly_ordered_queues = options[:strict]
-        @queues = options[:queues].map { |q| "queue:#{q}" }
-        @queues.uniq! if @strictly_ordered_queues
+        @strict = options[:strict]
+        @queues = options[:queues].map { |q| QueueName.expand q }
+
+        @queues.uniq! if @strict
       end
 
       # @return [Sidekiq::Throttled::UnitOfWork, nil]
@@ -25,7 +31,7 @@ module Sidekiq
         return work unless Throttled.throttled? work.job
 
         Sidekiq.redis do |conn|
-          conn.lpush("queue:#{work.queue_name}", work.job)
+          conn.lpush(QueueName.expand(work.queue_name), work.job)
         end
 
         nil
@@ -34,13 +40,19 @@ module Sidekiq
       private
 
       # Tries to pop pair of `queue` and job `message` out of sidekiq queue.
+      #
+      # @see http://redis.io/commands/brpop
       # @return [Array<String, String>, nil]
       def brpop
-        Sidekiq.redis { |conn| conn.brpop(*queues, TIMEOUT) }
-      end
+        queues = (@strict ? @queues : @queues.shuffle.uniq)
+        queues = QueuesPauser.instance.filter queues
 
-      def queues
-        (@strictly_ordered_queues ? @queues : @queues.shuffle.uniq)
+        if queues.empty?
+          sleep TIMEOUT
+          return
+        end
+
+        Sidekiq.redis { |conn| conn.brpop(*queues, TIMEOUT) }
       end
     end
   end

data/lib/sidekiq/throttled/middleware.rb

@@ -5,6 +5,7 @@ require "sidekiq/throttled/registry"
 module Sidekiq
   module Throttled
     # Server middleware that notifies strategy that job was finished.
+    #
     # @private
     class Middleware
       # Called within Sidekiq job processing

data/lib/sidekiq/throttled/queue_name.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Sidekiq
+  module Throttled
+    # Queue name utility belt.
+    #
+    # @private
+    module QueueName
+      # RegExp used to stip out any redisr-namespace prefixes with `queue:`.
+      QUEUE_NAME_PREFIX_RE = /^.*queue:/
+      private_constant :QUEUE_NAME_PREFIX_RE
+
+      class << self
+        # Strips redis-namespace and `queue:` prefix from given queue name.
+        #
+        # @example
+        #
+        #   QueueName.normalize "queue:default"
+        #   # => "default"
+        #
+        #   QueueName.normalize "queue:queue:default"
+        #   # => "default"
+        #
+        #   QueueName.normalize "foo:bar:queue:default"
+        #   # => "default"
+        #
+        # @param [String]
+        # @return [String]
+        def normalize(queue)
+          queue.sub(QUEUE_NAME_PREFIX_RE, "".freeze)
+        end
+
+        # Prepends `queue:` prefix to given `queue` name.
+        #
+        # @note It does not normalizes queue before expanding it, thus
+        #   double-call of this method will potentially do some harm.
+        #
+        # @param [String] queue Queue name
+        # @return [String]
+        def expand(queue)
+          "queue:#{queue}".freeze
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/throttled/queues_pauser.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "set"
+require "singleton"
+
+require "sidekiq/throttled/communicator"
+require "sidekiq/throttled/queue_name"
+
+module Sidekiq
+  module Throttled
+    # Singleton class used to pause queues from being processed.
+    # For the sake of efficiency it uses {Communicator} behind the scene
+    # to notify all processes about paused/resumed queues.
+    #
+    # @private
+    class QueuesPauser
+      include Singleton
+
+      # Redis key of Set with paused queues.
+      #
+      # @return [String]
+      PAUSED_QUEUES = "throttled:X:paused_queues".freeze
+      private_constant :PAUSED_QUEUES
+
+      # {Communicator} message used to notify that queue needs to be paused.
+      #
+      # @return [String]
+      PAUSE_MESSAGE = "pause".freeze
+      private_constant :PAUSE_MESSAGE
+
+      # {Communicator} message used to notify that queue needs to be resumed.
+      #
+      # @return [String]
+      RESUME_MESSAGE = "resume".freeze
+      private_constant :RESUME_MESSAGE
+
+      # Initializes singleton instance.
+      def initialize
+        @paused_queues = Set.new
+        @communicator  = Communicator.instance
+      end
+
+      # Configures Sidekiq server to keep actual list of paused queues.
+      #
+      # @private
+      # @return [void]
+      def setup!
+        Sidekiq.configure_server do
+          @communicator.receive PAUSE_MESSAGE do |queue|
+            @paused_queues << QueueName.expand(queue)
+          end
+
+          @communicator.receive RESUME_MESSAGE do |queue|
+            @paused_queues.delete QueueName.expand(queue)
+          end
+
+          @communicator.ready do
+            @paused_queues.replace paused_queues.map { |q| QueueName.expand q }
+          end
+        end
+      end
+
+      # Returns queues list with paused queues being stripped out.
+      #
+      # @private
+      # @return [Array<String>]
+      def filter(queues)
+        queues - @paused_queues.to_a
+      end
+
+      # Returns list of paused queues.
+      #
+      # @return [Array<String>]
+      def paused_queues
+        Sidekiq.redis { |conn| conn.smembers(PAUSED_QUEUES).to_a }
+      end
+
+      # Pauses given `queue`.
+      #
+      # @param [#to_s] queue
+      # @return [void]
+      def pause!(queue)
+        queue = QueueName.normalize queue.to_s
+
+        Sidekiq.redis do |conn|
+          conn.sadd(PAUSED_QUEUES, queue)
+          @communicator.transmit(conn, PAUSE_MESSAGE, queue)
+        end
+      end
+
+      # Resumes given `queue`.
+      #
+      # @param [#to_s] queue
+      # @return [void]
+      def resume!(queue)
+        queue = QueueName.normalize queue.to_s
+
+        Sidekiq.redis do |conn|
+          conn.srem(PAUSED_QUEUES, queue)
+          @communicator.transmit(conn, RESUME_MESSAGE, queue)
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/throttled/registry.rb

@@ -5,6 +5,8 @@ require "sidekiq/throttled/strategy"
 module Sidekiq
   module Throttled
     # Registred strategies.
+    #
+    # @private
     module Registry
       @strategies = {}
       @aliases    = {}

data/lib/sidekiq/throttled/strategy/concurrency.lua

@@ -1,3 +1,13 @@
-local r, k, l, t, j = redis, KEYS[1], tonumber(ARGV[1]), tonumber(ARGV[2]), ARGV[3]
-if l <= r.call("SCARD", k) and 0 == r.call("SISMEMBER", k, j) then return 1 end
-r.call("SADD", k, j); r.call("EXPIRE", k, t); return 0
+local key = KEYS[1]
+local jid = KEYS[2]
+local lmt = tonumber(ARGV[1])
+local ttl = tonumber(ARGV[2])
+
+if lmt <= redis.call("SCARD", key) and 0 == redis.call("SISMEMBER", key, jid) then
+  return 1
+end
+
+redis.call("SADD", key, jid)
+redis.call("EXPIRE", key, ttl)
+
+return 0

data/lib/sidekiq/throttled/strategy/concurrency.rb

@@ -14,7 +14,7 @@ module Sidekiq
         #
         #     PUSH(@key, @jid)
         #     return 0
-        SCRIPT = Script.new File.read "#{__dir__}/concurrency.lua"
+        SCRIPT = Script.read "#{__dir__}/concurrency.lua"
         private_constant :SCRIPT
 
         # @param [#to_s] strategy_key
@@ -44,7 +44,7 @@ module Sidekiq
 
         # @return [Boolean] whenever job is throttled or not
         def throttled?(jid, *job_args)
-          1 == SCRIPT.eval([key(job_args)], [limit(job_args), @ttl, jid.to_s])
+          1 == SCRIPT.eval([key(job_args), jid.to_s], [limit(job_args), @ttl])
         end
 
         # @return [Integer] Current count of jobs

data/lib/sidekiq/throttled/strategy/script.rb

@@ -31,25 +31,16 @@ module Sidekiq
         attr_reader :digest
 
         # @param [#to_s] source Lua script
-        # @paral [Logger] logger
+        # @param [Logger] logger
         def initialize(source, logger: Sidekiq.logger)
           @source = source.to_s.strip.freeze
           @digest = Digest::SHA1.hexdigest(@source).freeze
           @logger = logger
         end
 
-        # Executes script and returns result of execution
-        def eval(*args)
-          Sidekiq.redis { |conn| conn.evalsha(@digest, *args) }
-        rescue => e
-          raise unless e.message.include? NOSCRIPT
-          load_and_eval(*args)
-        end
-
-        private
-
-        # Loads script into redis cache and executes it.
-        def load_and_eval(*args)
+        # Loads script to redis
+        # @return [void]
+        def bootstrap!
           Sidekiq.redis do |conn|
             digest = conn.script(LOAD, @source)
 
@@ -64,10 +55,28 @@ module Sidekiq
 
               @digest = digest.freeze
             end
+          end
+        end
 
-            conn.evalsha(@digest, *args)
+        # Executes script and returns result of execution
+        # @return Result of script execution
+        def eval(*args)
+          Sidekiq.redis do |conn|
+            begin
+              conn.evalsha(@digest, *args)
+            rescue => e
+              raise unless e.message.include? NOSCRIPT
+              bootstrap!
+              conn.evalsha(@digest, *args)
+            end
           end
         end
+
+        # Reads given file and returns new {Script} with its contents.
+        # @return [Script]
+        def self.read(file)
+          new File.read file
+        end
       end
     end
   end

data/lib/sidekiq/throttled/strategy/threshold.lua

@@ -1,3 +1,14 @@
-local r, k, l, p, t = redis, KEYS[1], tonumber(ARGV[1]), tonumber(ARGV[2]), tonumber(ARGV[3])
-if l <= r.call("LLEN", k) and t - r.call("LINDEX", k, -1) < p then return 1 end
-r.call("LPUSH", k, t); r.call("LTRIM", k, 0, l - 1); r.call("EXPIRE", k, p); return 0
+local key = KEYS[1]
+local lmt = tonumber(ARGV[1])
+local ttl = tonumber(ARGV[2])
+local now = tonumber(ARGV[3])
+
+if lmt <= redis.call("LLEN", key) and now - redis.call("LINDEX", key, -1) < ttl then
+  return 1
+end
+
+redis.call("LPUSH", key, now)
+redis.call("LTRIM", key, 0, lmt - 1)
+redis.call("EXPIRE", key, ttl)
+
+return 0

data/lib/sidekiq/throttled/strategy/threshold.rb

@@ -26,7 +26,7 @@ module Sidekiq
         #
         #     increase!
         #     return 0
-        SCRIPT = Script.new File.read "#{__dir__}/threshold.lua"
+        SCRIPT = Script.read "#{__dir__}/threshold.lua"
         private_constant :SCRIPT
 
         # @param [#to_s] strategy_key

data/lib/sidekiq/throttled/strategy.rb

@@ -7,6 +7,8 @@ require "sidekiq/throttled/strategy/threshold"
 module Sidekiq
   module Throttled
     # Meta-strategy that couples {Concurrency} and {Threshold} strategies.
+    #
+    # @private
     class Strategy
       # @!attribute [r] concurrency
       #   @return [Strategy::Concurrency, nil]

data/lib/sidekiq/throttled/unit_of_work.rb

@@ -2,31 +2,54 @@
 
 require "sidekiq"
 
+require "sidekiq/throttled/queue_name"
+
 module Sidekiq
   module Throttled
+    # BRPOP response envelope.
+    #
+    # @see Throttled::Fetch
+    # @private
     class UnitOfWork
-      QUEUE_NAME_PREFIX_RE = /^.*queue:/
-      private_constant :QUEUE_NAME_PREFIX_RE
-
+      # @return [String] Redis key where job was pulled from
       attr_reader :queue
 
+      # @return [String] Job's JSON payload
       attr_reader :job
 
+      # @param [String] queue Redis key where job was pulled from
+      # @param [String] job Job's JSON payload
       def initialize(queue, job)
         @queue = queue
         @job   = job
       end
 
+      # Callback that is called by `Sidekiq::Processor` when job was
+      # succeccfully processed. Most this is used by `ReliableFetch`
+      # of Sidekiq Pro/Enterprise to remove job from running queue.
+      #
+      # @return [void]
       def acknowledge
         # do nothing
       end
 
+      # Normalized `queue` name.
+      #
+      # @see QueueName.normalize
+      # @return [String]
       def queue_name
-        queue.sub(QUEUE_NAME_PREFIX_RE, "")
+        @queue_name ||= QueueName.normalize queue
       end
 
+      # Pushes job back to the queue.
+      #
+      # @note This is triggered when job was not finished and Sidekiq server
+      #   process was terminated (shutdowned). Thus it should be reverse of
+      #   whatever fetcher was doing to pull the job out of queue.
+      #
+      # @return [void]
       def requeue
-        Sidekiq.redis { |conn| conn.rpush("queue:#{queue_name}", job) }
+        Sidekiq.redis { |conn| conn.rpush(QueueName.expand(queue_name), job) }
       end
     end
   end

data/lib/sidekiq/throttled/version.rb

@@ -3,6 +3,6 @@
 module Sidekiq
   module Throttled
     # Gem version
-    VERSION = "0.5.0".freeze
+    VERSION = "0.6.0".freeze
   end
 end

data/lib/sidekiq/throttled/web/stats.rb

@@ -3,7 +3,6 @@ module Sidekiq
   module Throttled
     module Web
       # Throttle strategy stats generation helper
-      # @private
       class Stats
         TIME_CONVERSION = [
           [60 * 60 * 24,  "day",    "days"],

data/lib/sidekiq/throttled/web.rb

@@ -13,6 +13,7 @@ require "sidekiq/throttled/web/stats"
 module Sidekiq
   module Throttled
     # Provides Sidekiq tab to monitor and reset throttled stats.
+    #
     # @private
     module Web
       class << self

data/lib/sidekiq/throttled.rb

@@ -4,6 +4,8 @@ require "sidekiq"
 
 # internal
 require "sidekiq/version"
+require "sidekiq/throttled/communicator"
+require "sidekiq/throttled/queues_pauser"
 require "sidekiq/throttled/registry"
 require "sidekiq/throttled/worker"
 
@@ -39,8 +41,12 @@ module Sidekiq
   module Throttled
     class << self
       # Hooks throttler into sidekiq.
+      #
       # @return [void]
       def setup!
+        Communicator.instance.setup!
+        QueuesPauser.instance.setup!
+
         Sidekiq.configure_server do |config|
           require "sidekiq/throttled/fetch"
           Sidekiq.options[:fetch] = Sidekiq::Throttled::Fetch
@@ -52,9 +58,25 @@ module Sidekiq
         end
       end
 
-      # @param [String] message JSON payload of job
-      # @return [TrueClass] if job is not allowed to be processed now
-      # @return [FalseClass] otherwise
+      # (see QueuesPauser#pause!)
+      def pause!(queue)
+        QueuesPauser.instance.pause!(queue)
+      end
+
+      # (see QueuesPauser#resume!)
+      def resume!(queue)
+        QueuesPauser.instance.resume!(queue)
+      end
+
+      # (see QueuesPauser#paused_queues)
+      def paused_queues
+        QueuesPauser.instance.paused_queues
+      end
+
+      # Tells whenever job is throttled or not.
+      #
+      # @param [String] message Job's JSON payload
+      # @return [Boolean]
       def throttled?(message)
         message = JSON.parse message
         job = message.fetch("class".freeze) { return false }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-throttled
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Alexey V Zapparov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-08-18 00:00:00.000000000 Z
+date: 2016-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq
@@ -45,6 +45,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".coveralls.yml"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
@@ -60,9 +61,14 @@ files:
 - gemfiles/sidekiq_4.1.gemfile
 - gemfiles/sidekiq_latest.gemfile
 - lib/sidekiq/throttled.rb
+- lib/sidekiq/throttled/communicator.rb
+- lib/sidekiq/throttled/communicator/callbacks.rb
+- lib/sidekiq/throttled/communicator/listener.rb
 - lib/sidekiq/throttled/errors.rb
 - lib/sidekiq/throttled/fetch.rb
 - lib/sidekiq/throttled/middleware.rb
+- lib/sidekiq/throttled/queue_name.rb
+- lib/sidekiq/throttled/queues_pauser.rb
 - lib/sidekiq/throttled/registry.rb
 - lib/sidekiq/throttled/strategy.rb
 - lib/sidekiq/throttled/strategy/concurrency.lua