sidekiq-limit_fetch 1.6 → 1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a1422602115c90e1d7d70f170d00eb90bf2970d3
-  data.tar.gz: ebe990f7f327c3d7d6a6c8e0ed168db9333147a2
+  metadata.gz: 4c5121de39e03363b90b64633028f65ed5cf6983
+  data.tar.gz: 935a28cd47181070776e71fe60db08165cab2ffe
 SHA512:
-  metadata.gz: df8ccaaf84855dc0501ec30d7845ada4f2b806472c029175c3a874b129bf95fc69c449a4b5f8c038447b5352c33df6767ff10cf43d14c1696f8174b361595932
-  data.tar.gz: 8b3519ae107315273f22708035e17441bb040e01152e52b1fcb51c92bcf4696b46034a431613b360a6e738523635831ed747d210075b0bf6a8769368c7383f44
+  metadata.gz: 09f48f0e5dce160c809b4fdad660f35c0fe2ac27ee3f6d850d094fc2e995adc70c3915cefb2ff4bc3a3aea2785c4f2a5edf3ca65c0692aea923dfbcd8ccdb2f4
+  data.tar.gz: a4d226be6b1df6fad9ab438dfd60e8e29235c89540f209c3399c5dd3ef24781184e653af3ae7cdbc67d08104f3a8fa16d6a44084ca36ecf3780d14e024579d78

data/lib/sidekiq/extensions/queue.rb

@@ -3,20 +3,17 @@ module Sidekiq
     extend LimitFetch::Singleton, Forwardable
 
     def_delegators :lock,
-      :limit,     :limit=,
-      :acquire,   :release,
-      :pause,     :unpause,
-      :block,     :unblock,
-      :paused?,   :blocking?,
-      :unblocked, :block_except,
-      :busy
+      :limit,         :limit=,
+      :acquire,       :release,
+      :pause,         :unpause,
+      :block,         :unblock,
+      :paused?,       :blocking?,
+      :unblocked,     :block_except,
+      :probed,        :busy,
+      :increase_busy, :decrease_busy
 
     def lock
-      @lock ||= mode::Semaphore.new name
-    end
-
-    def mode
-      Sidekiq.options[:local] ? LimitFetch::Local : LimitFetch::Global
+      @lock ||= LimitFetch::Global::Semaphore.new name
     end
   end
 end

data/lib/sidekiq/limit_fetch.rb

@@ -6,8 +6,6 @@ class Sidekiq::LimitFetch
 
   require_relative 'limit_fetch/singleton'
   require_relative 'limit_fetch/queues'
-  require_relative 'limit_fetch/local/semaphore'
-  require_relative 'limit_fetch/local/selector'
   require_relative 'limit_fetch/global/semaphore'
   require_relative 'limit_fetch/global/selector'
   require_relative 'limit_fetch/global/monitor'
@@ -20,7 +18,7 @@ class Sidekiq::LimitFetch
   end
 
   def initialize(options)
-    Global::Monitor.start! unless options[:local]
+    Global::Monitor.start!
     @queues = Queues.new options
   end
 

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

@@ -37,8 +37,10 @@ module Sidekiq::LimitFetch::Global
           next if it.get heartbeat_key processor
 
           it.del processor_key processor
-          it.keys('limit_fetch:busy:*').each do |queue|
-            it.lrem queue, 0, processor
+          %w(limit_fetch:probed:* limit_fetch:busy:*).each do |pattern|
+            it.keys(pattern).each do |queue|
+              it.lrem queue, 0, processor
+            end
           end
         end
       end

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

@@ -60,7 +60,7 @@ module Sidekiq::LimitFetch::Global
 
         for _, queue in ipairs(queues) do
           if not blocking_mode or unblocked[queue] then
-            local busy_key    = namespace..'busy:'..queue
+            local probed_key  = namespace..'probed:'..queue
             local pause_key   = namespace..'pause:'..queue
             local paused      = redis.call('get', pause_key)
 
@@ -72,7 +72,7 @@ module Sidekiq::LimitFetch::Global
               local can_block = redis.call('get', block_key)
 
               if can_block or queue_limit then
-                queue_locks = redis.call('llen', busy_key)
+                queue_locks = redis.call('llen', probed_key)
               end
 
               blocking_mode = can_block and queue_locks > 0
@@ -84,7 +84,7 @@ module Sidekiq::LimitFetch::Global
               end
 
               if not queue_limit or queue_limit > queue_locks then
-                redis.call('rpush', busy_key, worker_name)
+                redis.call('rpush', probed_key, worker_name)
                 table.insert(available, queue)
               end
             end
@@ -102,8 +102,8 @@ module Sidekiq::LimitFetch::Global
         local queues      = ARGV
 
         for _, queue in ipairs(queues) do
-          local busy_key = namespace..'busy:'..queue
-          redis.call('lrem', busy_key, 1, worker_name)
+          local probed_key = namespace..'probed:'..queue
+          redis.call('lrem', probed_key, 1, worker_name)
         end
       LUA
     end

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

@@ -23,13 +23,25 @@ module Sidekiq::LimitFetch::Global
     end
 
     def release
-      Selector.release [@name]
+      redis {|it| it.lrem "#{PREFIX}:probed:#@name", 1, Selector.uuid }
     end
 
     def busy
       redis {|it| it.llen "#{PREFIX}:busy:#@name" }
     end
 
+    def increase_busy
+      redis {|it| it.rpush "#{PREFIX}:busy:#@name", Selector.uuid }
+    end
+
+    def decrease_busy
+      redis {|it| it.lrem "#{PREFIX}:busy:#@name", 1, Selector.uuid }
+    end
+
+    def probed
+      redis {|it| it.llen "#{PREFIX}:probed:#@name" }
+    end
+
     def pause
       redis {|it| it.set "#{PREFIX}:pause:#@name", true }
     end

data/lib/sidekiq/limit_fetch/queues.rb

@@ -1,19 +1,17 @@
 class Sidekiq::LimitFetch
   class Queues
     THREAD_KEY = :acquired_queues
-    attr_reader :selector
 
     def initialize(options)
       @queues = options[:queues]
       options[:strict] ? strict_order! : weighted_order!
 
-      set_selector options[:local]
       set_limits options[:limits]
       set_blocks options[:blocking]
     end
 
     def acquire
-      @selector.acquire(ordered_queues)
+      selector.acquire(ordered_queues)
         .tap {|it| save it }
         .map {|it| "queue:#{it}" }
     end
@@ -21,13 +19,13 @@ class Sidekiq::LimitFetch
     def release_except(full_name)
       queues = restore
       queues.delete full_name[/queue:(.*)/, 1] if full_name
-      @selector.release queues
+      selector.release queues
     end
 
     private
 
-    def set_selector(local)
-      @selector = local ? Local::Selector : Global::Selector
+    def selector
+      Global::Selector
     end
 
     def set_limits(limits)

data/lib/sidekiq/limit_fetch/unit_of_work.rb

@@ -1,6 +1,12 @@
 module Sidekiq
   class LimitFetch::UnitOfWork < BasicFetch::UnitOfWork
+    def initialize(queue, message)
+      super
+      Queue[queue_name].increase_busy
+    end
+
     def acknowledge
+      Queue[queue_name].decrease_busy
       Queue[queue_name].release
     end
 

data/sidekiq-limit_fetch.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |gem|
   gem.name          = 'sidekiq-limit_fetch'
-  gem.version       = '1.6'
+  gem.version       = '1.7'
   gem.authors       = 'brainopia'
   gem.email         = 'brainopia@evilmartians.com'
   gem.summary       = 'Sidekiq strategy to support queue limits'

data/spec/sidekiq/extensions/queue_spec.rb

@@ -28,73 +28,61 @@ describe Sidekiq::Queue do
       let(:name) { 'example' }
       let(:queue) { Sidekiq::Queue[name] }
 
-      shared_examples_for :lock do
-        it 'should be available' do
-          queue.acquire.should be
-        end
-
-        it 'should be pausable' do
-          queue.pause
-          queue.acquire.should_not be
-        end
-
-        it 'should be continuable' do
-          queue.pause
-          queue.unpause
-          queue.acquire.should be
-        end
+      it 'should be available' do
+        queue.acquire.should be
+      end
 
-        it 'should be limitable' do
-          queue.limit = 1
-          queue.acquire.should be
-          queue.acquire.should_not be
-        end
+      it 'should be pausable' do
+        queue.pause
+        queue.acquire.should_not be
+      end
 
-        it 'should be resizable' do
-          queue.limit = 0
-          queue.acquire.should_not be
-          queue.limit = nil
-          queue.acquire.should be
-        end
+      it 'should be continuable' do
+        queue.pause
+        queue.unpause
+        queue.acquire.should be
+      end
 
-        it 'should be countable' do
-          queue.limit = 3
-          5.times { queue.acquire }
-          queue.busy.should == 3
-        end
+      it 'should be limitable' do
+        queue.limit = 1
+        queue.acquire.should be
+        queue.acquire.should_not be
+      end
 
-        it 'should be releasable' do
-          queue.acquire
-          queue.busy.should == 1
-          queue.release
-          queue.busy.should == 0
-        end
+      it 'should be resizable' do
+        queue.limit = 0
+        queue.acquire.should_not be
+        queue.limit = nil
+        queue.acquire.should be
+      end
 
-        it 'should tell if paused' do
-          queue.should_not be_paused
-          queue.pause
-          queue.should be_paused
-          queue.unpause
-          queue.should_not be_paused
-        end
+      it 'should be countable' do
+        queue.limit = 3
+        5.times { queue.acquire }
+        queue.probed.should == 3
+      end
 
-        it 'should tell if blocking' do
-          queue.should_not be_blocking
-          queue.block
-          queue.should be_blocking
-          queue.unblock
-          queue.should_not be_blocking
-        end
+      it 'should be releasable' do
+        queue.acquire
+        queue.probed.should == 1
+        queue.release
+        queue.probed.should == 0
       end
 
-      context 'global' do
-        before(:all) { Sidekiq.options[:local] = false }
-        it_behaves_like :lock
+      it 'should tell if paused' do
+        queue.should_not be_paused
+        queue.pause
+        queue.should be_paused
+        queue.unpause
+        queue.should_not be_paused
       end
 
-      context 'local' do
-        before(:all) { Sidekiq.options[:local] = true }
-        it_behaves_like :lock
+      it 'should tell if blocking' do
+        queue.should_not be_blocking
+        queue.block
+        queue.should be_blocking
+        queue.unblock
+        queue.should_not be_blocking
       end
     end
   end

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

@@ -7,17 +7,6 @@ describe Sidekiq::LimitFetch::Global::Monitor do
   let(:name) { 'default' }
 
   before :each do
-    # namespaces = [
-    #   described_class::PROCESSOR_NAMESPACE,
-    #   described_class::HEARTBEAT_NAMESPACE
-    # ]
-
-    # Sidekiq.redis do |it|
-    #   namespaces.flat_map {|namespace|
-    #     it.keys(namespace + '*')
-    #   }.each {|key| it.del key }
-    # end
-
     monitor
   end
 
@@ -31,11 +20,11 @@ describe Sidekiq::LimitFetch::Global::Monitor do
     it 'should remove invalidated old locks' do
       2.times { queue.acquire }
       sleep 2*ttl
-      queue.busy.should == 2
+      queue.probed.should == 2
 
       described_class.stub :update_heartbeat
       sleep 2*ttl
-      queue.busy.should == 0
+      queue.probed.should == 0
     end
   end
 end

data/spec/sidekiq/limit_fetch/queues_spec.rb

@@ -6,97 +6,72 @@ describe Sidekiq::LimitFetch::Queues do
   let(:queues)   { %w[queue1 queue2] }
   let(:limits)   {{ 'queue1' => 3 }}
   let(:strict)   { true }
-  let(:local)    {}
   let(:blocking) {}
 
   let(:options) do
     { queues:   queues,
       limits:   limits,
       strict:   strict,
-      local:    local,
       blocking: blocking }
   end
 
-  after(:each ) do
-    Thread.current[:available_queues] = nil
+  it 'should acquire queues' do
+    subject.acquire
+    Sidekiq::Queue['queue1'].probed.should == 1
+    Sidekiq::Queue['queue2'].probed.should == 1
   end
 
-  shared_examples_for :selector do
-    it 'should acquire queues' do
-      subject.acquire
-      Sidekiq::Queue['queue1'].busy.should == 1
-      Sidekiq::Queue['queue2'].busy.should == 1
-    end
-
-    it 'should acquire dynamically blocking queues' do
-      subject.acquire
-      Sidekiq::Queue['queue1'].busy.should == 1
-      Sidekiq::Queue['queue2'].busy.should == 1
-
-      Sidekiq::Queue['queue1'].block
-
-      subject.acquire
-      Sidekiq::Queue['queue1'].busy.should == 2
-      Sidekiq::Queue['queue2'].busy.should == 1
-    end
-
-    it 'should block except given queues' do
-      Sidekiq::Queue['queue1'].block_except 'queue2'
-      subject.acquire
-      Sidekiq::Queue['queue1'].busy.should == 1
-      Sidekiq::Queue['queue2'].busy.should == 1
-
-      Sidekiq::Queue['queue1'].block_except 'queue404'
-      subject.acquire
-      Sidekiq::Queue['queue1'].busy.should == 2
-      Sidekiq::Queue['queue2'].busy.should == 1
-    end
+  it 'should acquire dynamically blocking queues' do
+    subject.acquire
+    Sidekiq::Queue['queue1'].probed.should == 1
+    Sidekiq::Queue['queue2'].probed.should == 1
 
-    it 'should release queues' do
-      subject.acquire
-      subject.release_except nil
-      Sidekiq::Queue['queue1'].busy.should == 0
-      Sidekiq::Queue['queue2'].busy.should == 0
-    end
+    Sidekiq::Queue['queue1'].block
 
-    it 'should release queues except selected' do
-      subject.acquire
-      subject.release_except 'queue:queue1'
-      Sidekiq::Queue['queue1'].busy.should == 1
-      Sidekiq::Queue['queue2'].busy.should == 0
-    end
+    subject.acquire
+    Sidekiq::Queue['queue1'].probed.should == 2
+    Sidekiq::Queue['queue2'].probed.should == 1
+  end
 
-    it 'should release when no queues was acquired' do
-      queues.each {|name| Sidekiq::Queue[name].pause }
-      subject.acquire
-      -> { subject.release_except nil }.should_not raise_exception
-    end
+  it 'should block except given queues' do
+    Sidekiq::Queue['queue1'].block_except 'queue2'
+    subject.acquire
+    Sidekiq::Queue['queue1'].probed.should == 1
+    Sidekiq::Queue['queue2'].probed.should == 1
 
-    context 'blocking' do
-      let(:blocking) { %w(queue1) }
+    Sidekiq::Queue['queue1'].block_except 'queue404'
+    subject.acquire
+    Sidekiq::Queue['queue1'].probed.should == 2
+    Sidekiq::Queue['queue2'].probed.should == 1
+  end
 
-      it 'should acquire blocking queues' do
-        3.times { subject.acquire }
-        Sidekiq::Queue['queue1'].busy.should == 3
-        Sidekiq::Queue['queue2'].busy.should == 1
-      end
-    end
+  it 'should release queues' do
+    subject.acquire
+    subject.release_except nil
+    Sidekiq::Queue['queue1'].probed.should == 0
+    Sidekiq::Queue['queue2'].probed.should == 0
   end
 
-  context 'without local flag' do
-    it_should_behave_like :selector
+  it 'should release queues except selected' do
+    subject.acquire
+    subject.release_except 'queue:queue1'
+    Sidekiq::Queue['queue1'].probed.should == 1
+    Sidekiq::Queue['queue2'].probed.should == 0
+  end
 
-    it 'without local flag should be global' do
-      subject.selector.should == Sidekiq::LimitFetch::Global::Selector
-    end
+  it 'should release when no queues was acquired' do
+    queues.each {|name| Sidekiq::Queue[name].pause }
+    subject.acquire
+    -> { subject.release_except nil }.should_not raise_exception
   end
 
-  context 'with local flag' do
-    let(:local) { true }
-    it_should_behave_like :selector
+  context 'blocking' do
+    let(:blocking) { %w(queue1) }
 
-    it 'should use local selector' do
-      subject.selector.should == Sidekiq::LimitFetch::Local::Selector
+    it 'should acquire blocking queues' do
+      3.times { subject.acquire }
+      Sidekiq::Queue['queue1'].probed.should == 3
+      Sidekiq::Queue['queue2'].probed.should == 1
     end
   end
 

data/spec/sidekiq/limit_fetch/semaphore_spec.rb

@@ -1,68 +1,49 @@
 require 'spec_helper'
 
 describe 'semaphore' do
-  shared_examples_for :semaphore do
-    it 'should have no limit by default' do
-      subject.limit.should_not be
-    end
-
-    it 'should set limit' do
-      subject.limit = 4
-      subject.limit.should == 4
-    end
-
-    it 'should acquire and count active tasks' do
-      3.times { subject.acquire }
-      subject.busy.should == 3
-    end
-
-    it 'should acquire tasks with regard to limit' do
-      subject.limit = 4
-      6.times { subject.acquire }
-      subject.busy.should == 4
-    end
+  let(:name) { 'default' }
+  subject { Sidekiq::LimitFetch::Global::Semaphore.new name }
 
-    it 'should release active tasks' do
-      6.times { subject.acquire }
-      3.times { subject.release }
-      subject.busy.should == 3
-    end
+  it 'should have no limit by default' do
+    subject.limit.should_not be
+  end
 
-    it 'should pause tasks' do
-      3.times { subject.acquire }
-      subject.pause
-      2.times { subject.acquire }
-      subject.busy.should == 3
-      2.times { subject.release }
-      subject.busy.should == 1
-    end
+  it 'should set limit' do
+    subject.limit = 4
+    subject.limit.should == 4
+  end
 
-    it 'should unpause tasks' do
-      subject.pause
-      3.times { subject.acquire }
-      subject.unpause
-      2.times { subject.acquire }
-      subject.busy.should == 2
-    end
+  it 'should acquire and count active tasks' do
+    3.times { subject.acquire }
+    subject.probed.should == 3
   end
 
-  let(:name) { 'default' }
+  it 'should acquire tasks with regard to limit' do
+    subject.limit = 4
+    6.times { subject.acquire }
+    subject.probed.should == 4
+  end
 
-  context 'local' do
-    subject { Sidekiq::LimitFetch::Local::Semaphore.new name }
-    it_behaves_like :semaphore
+  it 'should release active tasks' do
+    6.times { subject.acquire }
+    3.times { subject.release }
+    subject.probed.should == 3
   end
 
-  context 'global' do
-    subject { Sidekiq::LimitFetch::Global::Semaphore.new name }
-    it_behaves_like :semaphore
+  it 'should pause tasks' do
+    3.times { subject.acquire }
+    subject.pause
+    2.times { subject.acquire }
+    subject.probed.should == 3
+    2.times { subject.release }
+    subject.probed.should == 1
+  end
 
-    after :each do
-      Sidekiq.redis do |it|
-        it.del "limit_fetch:limit:#{name}"
-        it.del "limit_fetch:busy:#{name}"
-        it.del "limit_fetch:pause:#{name}"
-      end
-    end
+  it 'should unpause tasks' do
+    subject.pause
+    3.times { subject.acquire }
+    subject.unpause
+    2.times { subject.acquire }
+    subject.probed.should == 2
   end
 end

data/spec/sidekiq/limit_fetch_spec.rb

@@ -11,37 +11,37 @@ describe Sidekiq::LimitFetch do
   end
 
   subject { described_class.new options }
-  let(:options) {{ queues: queues, limits: limits, local: local }}
+  let(:options) {{ queues: queues, limits: limits }}
   let(:queues) { %w(queue1 queue1 queue2 queue2) }
   let(:limits) {{ 'queue1' => 1, 'queue2' => 2 }}
 
-  shared_examples_for :strategy do
-    it 'should acquire lock on queue for execution' do
-      work = subject.retrieve_work
-      work.queue_name.should == 'queue1'
-      work.message.should == 'task1'
+  it 'should acquire lock on queue for execution' do
+    work = subject.retrieve_work
+    work.queue_name.should == 'queue1'
+    work.message.should == 'task1'
 
-      subject.retrieve_work.should_not be
-      work.requeue
+    Sidekiq::Queue['queue1'].busy.should == 1
+    Sidekiq::Queue['queue2'].busy.should == 0
 
-      work = subject.retrieve_work
-      work.message.should == 'task2'
+    subject.retrieve_work.should_not be
+    work.requeue
 
-      subject.retrieve_work.should_not be
-      work.acknowledge
+    Sidekiq::Queue['queue1'].busy.should == 0
+    Sidekiq::Queue['queue2'].busy.should == 0
 
-      work = subject.retrieve_work
-      work.message.should == 'task1'
-    end
-  end
+    work = subject.retrieve_work
+    work.message.should == 'task2'
 
-  context 'global' do
-    let(:local) { false }
-    it_behaves_like :strategy
-  end
+    Sidekiq::Queue['queue1'].busy.should == 1
+    Sidekiq::Queue['queue2'].busy.should == 0
+
+    subject.retrieve_work.should_not be
+    work.acknowledge
+
+    Sidekiq::Queue['queue1'].busy.should == 0
+    Sidekiq::Queue['queue2'].busy.should == 0
 
-  context 'local' do
-    let(:local) { true }
-    it_behaves_like :strategy
+    work = subject.retrieve_work
+    work.message.should == 'task1'
   end
 end

data/spec/spec_helper.rb

@@ -4,15 +4,15 @@ require 'sidekiq/fetch'
 
 RSpec.configure do |config|
   config.before :each do
-    Sidekiq::Queue.instance_variable_set :@instances, {}
-    Sidekiq.options[:local] = defined?(local) ? local : nil
-
     Sidekiq.redis do |it|
       clean_redis = ->(queue) do
-        it.del "limit_fetch:limit:#{queue}"
-        it.del "limit_fetch:busy:#{queue}"
-        it.del "limit_fetch:pause:#{queue}"
-        it.del "limit_fetch:block:#{queue}"
+        it.pipelined do
+          it.del "limit_fetch:limit:#{queue}"
+          it.del "limit_fetch:busy:#{queue}"
+          it.del "limit_fetch:probed:#{queue}"
+          it.del "limit_fetch:pause:#{queue}"
+          it.del "limit_fetch:block:#{queue}"
+        end
       end
 
       clean_redis.call(name) if defined?(name)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-limit_fetch
 version: !ruby/object:Gem::Version
-  version: '1.6'
+  version: '1.7'
 platform: ruby
 authors:
 - brainopia
@@ -77,8 +77,6 @@ files:
 - lib/sidekiq/limit_fetch/global/monitor.rb
 - lib/sidekiq/limit_fetch/global/selector.rb
 - lib/sidekiq/limit_fetch/global/semaphore.rb
-- lib/sidekiq/limit_fetch/local/selector.rb
-- lib/sidekiq/limit_fetch/local/semaphore.rb
 - lib/sidekiq/limit_fetch/queues.rb
 - lib/sidekiq/limit_fetch/singleton.rb
 - lib/sidekiq/limit_fetch/unit_of_work.rb

data/lib/sidekiq/limit_fetch/local/selector.rb

@@ -1,31 +0,0 @@
-module Sidekiq::LimitFetch::Local
-  module Selector
-    extend self
-
-    def acquire(names)
-      blocked   = false
-      unblocked = []
-
-      queues(names).select {|queue|
-        next false if blocked and not unblocked.include?(queue.name)
-
-        if not queue.paused? and queue.blocking? and queue.busy > 0
-          blocked   = true
-          unblocked = queue.unblocked || []
-        end
-
-        queue.acquire
-      }.map(&:name)
-    end
-
-    def release(names)
-      queues(names).each(&:release)
-    end
-
-    private
-
-    def queues(names)
-      names.map {|name| Sidekiq::Queue[name] }
-    end
-  end
-end

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

@@ -1,61 +0,0 @@
-module Sidekiq::LimitFetch::Local
-  class Semaphore
-    attr_reader :limit, :busy, :unblocked
-
-    def initialize(name)
-      @name = name
-      @lock = Mutex.new
-      @busy = 0
-      @paused = false
-    end
-
-    def limit=(value)
-      @lock.synchronize do
-        @limit = value
-      end
-    end
-
-    def acquire
-      return if @paused
-      @lock.synchronize do
-        @busy += 1 if not @limit or @limit > @busy
-      end
-    end
-
-    def release
-      @lock.synchronize do
-        @busy -= 1
-      end
-    end
-
-    def pause
-      @paused = true
-    end
-
-    def unpause
-      @paused = false
-    end
-
-    def paused?
-      @paused
-    end
-
-    def block
-      @block = true
-    end
-
-    def block_except(*queues)
-      raise ArgumentError if queues.empty?
-      @unblocked = queues
-      @block = true
-    end
-
-    def unblock
-      @block = false
-    end
-
-    def blocking?
-      @block
-    end
-  end
-end