bunny 1.0.0.pre2 → 1.0.0.pre3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b675d7cc26c0951af3fda991f438c8bbc3cb03c5
-  data.tar.gz: 0cdf2879b75d769676c3dce890bd1d7213a96448
+  metadata.gz: 42830e201dcbd08b5367454288ce79c6924ea0d4
+  data.tar.gz: 04005efee192cb86d4e7af17776e53e13712525b
 SHA512:
-  metadata.gz: e881cb1d9695f16102ca8a08bdd9191a38cc044c16e4c1f89a32b2331d0abd6d58a00abc731e3c809d9cd538a1d243eca9029074da228ee28400c2307e7deb4f
-  data.tar.gz: 8390a12a2595bd1f7b65dd83c31686117081aa0672c258935e07c040ccf89222a1160e29cab0d519c24483f13adc24b3d8a5af41598b584d43c6913e1965d18e
+  metadata.gz: 6d1841d225856610228745312a60ae7e86cd175a40528902f2834aa1c51c548be68a74a481717127f8d4d15463670a4a7a80577983b7766ff841bcb51822a37c
+  data.tar.gz: 44dbd529f0b0d16ae0f3c115040a9b6879f85ef7e4da6668dbe869a10e5e2b752232828eec30b70292b1fd582e0876a8f9eeb420c81e6d05eb1ac22f9d1c8198

data/ChangeLog.md

@@ -1,5 +1,11 @@
 ## Changes between Bunny 1.0.0.pre1 and 1.0.0.pre2
 
+### Exclusivity Violation for Consumers Now Raises a Reasonable Exception
+
+When a second consumer is registered for the same queue on different channels,
+a reasonable exception (`Bunny::AccessRefused`) will be raised.
+
+
 ### Reentrant Mutex Implementation
 
 Bunny now allows mutex impl to be configurable, uses reentrant Monitor

data/benchmarks/synchronized_sorted_set.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require "rubygems"
+require "set"
+require "thread"
+require "benchmark"
+
+require "bunny/concurrent/synchronized_sorted_set"
+
+puts
+puts "-" * 80
+puts "Benchmarking on #{RUBY_DESCRIPTION}"
+
+n  = 2_000_000
+s  = SortedSet.new
+
+# warm up the JIT, etc
+puts "Doing a warmup run..."
+n.times do |i|
+  s << 1
+  s << i
+  s.delete i
+  s << i
+end
+
+t1  = Benchmark.realtime do
+  n.times do |i|
+    s << 1
+    s << i
+    s.delete i
+    s << i
+    s.length
+  end
+end
+r1  = (n.to_f/t1.to_f)
+
+s2 = SynchronizedSortedSet.new
+t2  = Benchmark.realtime do
+  n.times do |i|
+    s2 << 1
+    s2 << i
+    s2.delete i
+    s2 << i
+    s2.length
+  end
+end
+r2  = (n.to_f/t2.to_f)
+
+puts "Mixed sorted set ops, rate: #{(r1 / 1000).round(2)} KGHz"
+puts "Mixed synchronized sorted set ops, rate: #{(r2 / 1000).round(2)} KGHz"
+puts
+puts "-" * 80

data/lib/amq/protocol/extensions.rb

@@ -0,0 +1,16 @@
+# @private
+module AMQ
+  # @private
+  module Protocol
+    # @private
+    class Basic
+      # Extended to allow wrapping delivery tag into
+      # a versioned one.
+      #
+      # @private
+      class GetOk
+        attr_writer :delivery_tag
+      end
+    end
+  end
+end

data/lib/bunny.rb

@@ -4,6 +4,7 @@ require "timeout"
 
 require "bunny/version"
 require "amq/protocol/client"
+require "amq/protocol/extensions"
 
 require "bunny/framing"
 require "bunny/exceptions"

data/lib/bunny/channel.rb

@@ -3,6 +3,7 @@ require "thread"
 require "monitor"
 require "set"
 
+require "bunny/concurrent/atomic_fixnum"
 require "bunny/consumer_work_pool"
 
 require "bunny/exchange"
@@ -189,8 +190,12 @@ module Bunny
       @threads_waiting_on_basic_get_continuations = Set.new
 
       @next_publish_seq_no = 0
+
+      @recoveries_counter = Bunny::Concurrent::AtomicFixnum.new(0)
     end
 
+    attr_reader :recoveries_counter
+
     # @private
     def read_write_timeout
       @connection.read_write_timeout
@@ -438,7 +443,9 @@ module Bunny
     # @see http://rubybunny.info/articles/queues.html Queues and Consumers guide
     # @api public
     def reject(delivery_tag, requeue = false)
-      basic_reject(delivery_tag, requeue)
+      guarding_against_stale_delivery_tags(delivery_tag) do
+        basic_reject(delivery_tag.to_i, requeue)
+      end
     end
 
     # Acknowledges a message. Acknowledged messages are completely removed from the queue.
@@ -449,7 +456,9 @@ module Bunny
     # @see http://rubybunny.info/articles/queues.html Queues and Consumers guide
     # @api public
     def ack(delivery_tag, multiple = false)
-      basic_ack(delivery_tag, multiple)
+      guarding_against_stale_delivery_tags(delivery_tag) do
+        basic_ack(delivery_tag.to_i, multiple)
+      end
     end
     alias acknowledge ack
 
@@ -464,7 +473,9 @@ module Bunny
     # @see http://rubybunny.info/articles/queues.html Queues and Consumers guide
     # @api public
     def nack(delivery_tag, multiple = false, requeue = false)
-      basic_nack(delivery_tag, multiple, requeue)
+      guarding_against_stale_delivery_tags(delivery_tag) do
+        basic_nack(delivery_tag.to_i, multiple, requeue)
+      end
     end
 
     # @endgroup
@@ -522,13 +533,13 @@ module Bunny
       end
 
       m = AMQ::Protocol::Basic::Publish.encode(@id,
-                                               payload,
-                                               meta,
-                                               exchange_name,
-                                               routing_key,
-                                               meta[:mandatory],
-                                               false,
-                                               @connection.frame_max)
+        payload,
+        meta,
+        exchange_name,
+        routing_key,
+        meta[:mandatory],
+        false,
+        @connection.frame_max)
       @connection.send_frameset_without_timeout(m, self)
 
       self
@@ -701,6 +712,7 @@ module Bunny
     #   ch.basic_ack(delivery_info.delivery_tag, true)
     #
     # @see http://rubybunny.info/articles/queues.html Queues and Consumers guide
+    # @see #basic_ack_known_delivery_tag
     # @api public
     def basic_ack(delivery_tag, multiple)
       raise_if_no_longer_open!
@@ -765,9 +777,9 @@ module Bunny
     def basic_nack(delivery_tag, multiple = false, requeue = false)
       raise_if_no_longer_open!
       @connection.send_frame(AMQ::Protocol::Basic::Nack.encode(@id,
-                                                               delivery_tag,
-                                                               multiple,
-                                                               requeue))
+          delivery_tag,
+          multiple,
+          requeue))
 
       nil
     end
@@ -802,13 +814,13 @@ module Bunny
       end
 
       @connection.send_frame(AMQ::Protocol::Basic::Consume.encode(@id,
-                                                                  queue_name,
-                                                                  consumer_tag,
-                                                                  false,
-                                                                  no_ack,
-                                                                  exclusive,
-                                                                  false,
-                                                                  arguments))
+          queue_name,
+          consumer_tag,
+          false,
+          no_ack,
+          exclusive,
+          false,
+          arguments))
 
       begin
         Bunny::Timer.timeout(read_write_timeout, ClientTimeout) do
@@ -822,6 +834,10 @@ module Bunny
         raise e
       end
 
+      # in case there is another exclusive consumer and we get a channel.close
+      # response here. MK.
+      raise_if_channel_close!(@last_basic_consume_ok)
+
       # covers server-generated consumer tags
       add_consumer(queue_name, @last_basic_consume_ok.consumer_tag, no_ack, exclusive, arguments, &block)
 
@@ -847,13 +863,13 @@ module Bunny
       end
 
       @connection.send_frame(AMQ::Protocol::Basic::Consume.encode(@id,
-                                                                  consumer.queue_name,
-                                                                  consumer.consumer_tag,
-                                                                  false,
-                                                                  consumer.no_ack,
-                                                                  consumer.exclusive,
-                                                                  false,
-                                                                  consumer.arguments))
+          consumer.queue_name,
+          consumer.consumer_tag,
+          false,
+          consumer.no_ack,
+          consumer.exclusive,
+          false,
+          consumer.arguments))
 
       begin
         Bunny::Timer.timeout(read_write_timeout, ClientTimeout) do
@@ -867,6 +883,10 @@ module Bunny
         raise e
       end
 
+      # in case there is another exclusive consumer and we get a channel.close
+      # response here. MK.
+      raise_if_channel_close!(@last_basic_consume_ok)
+
       # covers server-generated consumer tags
       register_consumer(@last_basic_consume_ok.consumer_tag, consumer)
 
@@ -927,13 +947,13 @@ module Bunny
       raise_if_no_longer_open!
 
       @connection.send_frame(AMQ::Protocol::Queue::Declare.encode(@id,
-                                                                  name,
-                                                                  opts.fetch(:passive, false),
-                                                                  opts.fetch(:durable, false),
-                                                                  opts.fetch(:exclusive, false),
-                                                                  opts.fetch(:auto_delete, false),
-                                                                  false,
-                                                                  opts[:arguments]))
+          name,
+          opts.fetch(:passive, false),
+          opts.fetch(:durable, false),
+          opts.fetch(:exclusive, false),
+          opts.fetch(:auto_delete, false),
+          false,
+          opts[:arguments]))
       @last_queue_declare_ok = wait_on_continuations
 
       raise_if_continuation_resulted_in_a_channel_error!
@@ -956,10 +976,10 @@ module Bunny
       raise_if_no_longer_open!
 
       @connection.send_frame(AMQ::Protocol::Queue::Delete.encode(@id,
-                                                                 name,
-                                                                 opts[:if_unused],
-                                                                 opts[:if_empty],
-                                                                 false))
+          name,
+          opts[:if_unused],
+          opts[:if_empty],
+          false))
       Bunny::Timer.timeout(read_write_timeout, ClientTimeout) do
         @last_queue_delete_ok = wait_on_continuations
       end
@@ -1011,11 +1031,11 @@ module Bunny
                       end
 
       @connection.send_frame(AMQ::Protocol::Queue::Bind.encode(@id,
-                                                               name,
-                                                               exchange_name,
-                                                               opts[:routing_key],
-                                                               false,
-                                                               opts[:arguments]))
+          name,
+          exchange_name,
+          opts[:routing_key],
+          false,
+          opts[:arguments]))
       Bunny::Timer.timeout(read_write_timeout, ClientTimeout) do
         @last_queue_bind_ok = wait_on_continuations
       end
@@ -1047,10 +1067,10 @@ module Bunny
                       end
 
       @connection.send_frame(AMQ::Protocol::Queue::Unbind.encode(@id,
-                                                                 name,
-                                                                 exchange_name,
-                                                                 opts[:routing_key],
-                                                                 opts[:arguments]))
+          name,
+          exchange_name,
+          opts[:routing_key],
+          opts[:arguments]))
       Bunny::Timer.timeout(read_write_timeout, ClientTimeout) do
         @last_queue_unbind_ok = wait_on_continuations
       end
@@ -1082,14 +1102,14 @@ module Bunny
       raise_if_no_longer_open!
 
       @connection.send_frame(AMQ::Protocol::Exchange::Declare.encode(@id,
-                                                                     name,
-                                                                     type.to_s,
-                                                                     opts.fetch(:passive, false),
-                                                                     opts.fetch(:durable, false),
-                                                                     opts.fetch(:auto_delete, false),
-                                                                     false,
-                                                                     false,
-                                                                     opts[:arguments]))
+          name,
+          type.to_s,
+          opts.fetch(:passive, false),
+          opts.fetch(:durable, false),
+          opts.fetch(:auto_delete, false),
+          false,
+          false,
+          opts[:arguments]))
       Bunny::Timer.timeout(read_write_timeout, ClientTimeout) do
         @last_exchange_declare_ok = wait_on_continuations
       end
@@ -1112,9 +1132,9 @@ module Bunny
       raise_if_no_longer_open!
 
       @connection.send_frame(AMQ::Protocol::Exchange::Delete.encode(@id,
-                                                                    name,
-                                                                    opts[:if_unused],
-                                                                    false))
+          name,
+          opts[:if_unused],
+          false))
       Bunny::Timer.timeout(read_write_timeout, ClientTimeout) do
         @last_exchange_delete_ok = wait_on_continuations
       end
@@ -1154,11 +1174,11 @@ module Bunny
                          end
 
       @connection.send_frame(AMQ::Protocol::Exchange::Bind.encode(@id,
-                                                                  destination_name,
-                                                                  source_name,
-                                                                  opts[:routing_key],
-                                                                  false,
-                                                                  opts[:arguments]))
+          destination_name,
+          source_name,
+          opts[:routing_key],
+          false,
+          opts[:arguments]))
       Bunny::Timer.timeout(read_write_timeout, ClientTimeout) do
         @last_exchange_bind_ok = wait_on_continuations
       end
@@ -1198,11 +1218,11 @@ module Bunny
                          end
 
       @connection.send_frame(AMQ::Protocol::Exchange::Unbind.encode(@id,
-                                                                    destination_name,
-                                                                    source_name,
-                                                                    opts[:routing_key],
-                                                                    false,
-                                                                    opts[:arguments]))
+          destination_name,
+          source_name,
+          opts[:routing_key],
+          false,
+          opts[:arguments]))
       Bunny::Timer.timeout(read_write_timeout, ClientTimeout) do
         @last_exchange_unbind_ok = wait_on_continuations
       end
@@ -1399,6 +1419,7 @@ module Bunny
       # this includes recovering bindings
       recover_queues
       recover_consumers
+      increment_recoveries_counter
     end
 
     # Recovers basic.qos setting. Used by the Automatic Network Failure
@@ -1444,6 +1465,11 @@ module Bunny
       end
     end
 
+    # @private
+    def increment_recoveries_counter
+      @recoveries_counter.increment
+    end
+
     # @endgroup
 
 
@@ -1555,6 +1581,7 @@ module Bunny
 
     # @private
     def handle_basic_get_ok(basic_get_ok, properties, content)
+      basic_get_ok.delivery_tag = VersionedDeliveryTag.new(basic_get_ok.delivery_tag, @recoveries_counter.get)
       @basic_get_continuations.push([basic_get_ok, properties, content])
     end
 
@@ -1606,10 +1633,8 @@ module Bunny
 
       @unconfirmed_set_mutex.synchronize do
         @only_acks_received = (@only_acks_received && !nack)
-        @logger.debug "Channel #{@id}: @only_acks_received = #{@only_acks_received.inspect}, nack: #{nack.inspect}"
 
         @confirms_continuations.push(true) if @unconfirmed_set.empty?
-
         @confirms_callback.call(delivery_tag, multiple, nack) if @confirms_callback
       end
     end
@@ -1786,6 +1811,19 @@ module Bunny
       raise ChannelAlreadyClosed.new("cannot use a channel that was already closed! Channel id: #{@id}", self) if closed?
     end
 
+    # @private
+    def raise_if_channel_close!(method)
+      if method && method.is_a?(AMQ::Protocol::Channel::Close)
+        # basic.ack, basic.reject, basic.nack. MK.
+        if channel_level_exception_after_operation_that_has_no_response?(method)
+          @on_error.call(self, method) if @on_error
+        else
+          @last_channel_error = instantiate_channel_level_exception(method)
+          raise @last_channel_error
+        end
+      end
+    end
+
     # @private
     def reset_continuations
       @continuations           = new_continuation
@@ -1805,5 +1843,21 @@ module Bunny
         Concurrent::ContinuationQueue.new
       end
     end # if defined?
+
+    # @private
+    def guarding_against_stale_delivery_tags(tag, &block)
+      case tag
+      # if a fixnum was passed, execute unconditionally. MK.
+      when Fixnum then
+        block.call
+      # versioned delivery tags should be checked to avoid
+      # sending out stale (invalid) tags after channel was reopened
+      # during network failure recovery. MK.
+      when VersionedDeliveryTag then
+        if !tag.stale?(@recoveries_counter.get)
+          block.call
+        end
+      end
+    end
   end # Channel
 end # Bunny

data/lib/bunny/concurrent/atomic_fixnum.rb

@@ -0,0 +1,74 @@
+require "set"
+require "thread"
+require "monitor"
+
+module Bunny
+  module Concurrent
+    # Minimalistic implementation of a synchronized fixnum value,
+    # designed after (but not implementing the entire API of!)
+    #
+    # @note Designed to be intentionally minimalistic and only cover Bunny's needs.
+    #
+    # @api public
+    class AtomicFixnum
+      def initialize(n = 0)
+        @n     = n
+        @mutex = Monitor.new
+      end
+
+      def get
+        @mutex.synchronize do
+          @n
+        end
+      end
+
+      def set(n)
+        @mutex.synchronize do
+          @n = n
+        end
+      end
+
+      def increment
+        @mutex.synchronize do
+          @n = @n + 1
+        end
+      end
+      alias inc increment
+      alias increment_and_get increment
+
+      def get_and_add(i)
+        @mutex.synchronize do
+          v = @n
+          @n = @n + i
+
+          v
+        end
+      end
+
+      def get_and_increment
+        @mutex.synchronize do
+          v = @n
+          @n = @n + 1
+
+          v
+        end
+      end
+
+      def decrement
+        @mutex.synchronize do
+          @n = @n - 1
+        end
+      end
+      alias dec decrement
+      alias decrement_and_get decrement
+
+      def ==(m)
+        @mutex.synchronize { @n == m }
+      end
+
+      def ===(v)
+        @mutex.synchronize { @n === v }
+      end
+    end
+  end
+end

data/lib/bunny/concurrent/synchronized_sorted_set.rb

@@ -0,0 +1,56 @@
+require "set"
+require "thread"
+
+module Bunny
+  module Concurrent
+    # A SortedSet variation that synchronizes key mutation operations.
+    #
+    # @note This is NOT a complete SortedSet replacement. It only synchronizes operations needed by Bunny.
+    # @api public
+    class SynchronizedSortedSet < SortedSet
+      def initialize(enum = nil)
+        @mutex = Mutex.new
+
+        super
+      end
+
+      def add(o)
+        # avoid using Mutex#synchronize because of a Ruby 1.8.7-specific
+        # bug that prevents super from being called from within a block. MK.
+        @mutex.lock
+        begin
+          super
+        ensure
+          @mutex.unlock
+        end
+      end
+
+      def delete(o)
+        @mutex.lock
+        begin
+          super
+        ensure
+          @mutex.unlock
+        end
+      end
+
+      def delete_if(&block)
+        @mutex.lock
+        begin
+          super
+        ensure
+          @mutex.unlock
+        end
+      end
+
+      def include?(o)
+        @mutex.lock
+        begin
+          super
+        ensure
+          @mutex.unlock
+        end
+      end
+    end
+  end
+end

data/lib/bunny/consumer.rb

@@ -37,6 +37,7 @@ module Bunny
       @consumer_tag  = consumer_tag
       @exclusive     = exclusive
       @arguments     = arguments
+      # no_ack set to true = no manual ack = automatic ack. MK.
       @no_ack        = no_ack
     end
 
@@ -89,6 +90,18 @@ module Bunny
       "#<#{self.class.name}:#{object_id} @channel_id=#{@channel.number} @queue=#{self.queue_name}> @consumer_tag=#{@consumer_tag}>"
     end
 
+    # @return [Boolean] true if this consumer uses automatic acknowledgement mode
+    # @api public
+    def automatic_acknowledgement?
+      @no_ack == false
+    end
+
+    # @return [Boolean] true if this consumer uses manual (explicit) acknowledgement mode
+    # @api public
+    def manual_acknowledgement?
+      @no_ack == true
+    end
+
     #
     # Recovery
     #

data/lib/bunny/delivery_info.rb

@@ -1,3 +1,5 @@
+require "bunny/versioned_delivery_tag"
+
 module Bunny
   # Wraps {AMQ::Protocol::Basic::Deliver} to
   # provide access to the delivery properties as immutable hash as
@@ -24,7 +26,7 @@ module Bunny
       @basic_deliver = basic_deliver
       @hash          = {
         :consumer_tag => basic_deliver.consumer_tag,
-        :delivery_tag => basic_deliver.delivery_tag,
+        :delivery_tag => VersionedDeliveryTag.new(basic_deliver.delivery_tag, channel.recoveries_counter),
         :redelivered  => basic_deliver.redelivered,
         :exchange     => basic_deliver.exchange,
         :routing_key  => basic_deliver.routing_key,

data/lib/bunny/version.rb

@@ -2,5 +2,5 @@
 
 module Bunny
   # @return [String] Version of the library
-  VERSION = "1.0.0.pre2"
+  VERSION = "1.0.0.pre3"
 end

data/lib/bunny/versioned_delivery_tag.rb

@@ -0,0 +1,28 @@
+module Bunny
+  # Wraps a delivery tag (which is an integer) so that {Bunny::Channel} could
+  # detect stale tags after connection recovery.
+  #
+  # @private
+  class VersionedDeliveryTag
+    attr_reader :tag
+    attr_reader :version
+
+    def initialize(tag, version)
+      raise ArgumentError.new("tag cannot be nil") unless tag
+      raise ArgumentError.new("version cannot be nil") unless version
+
+      @tag     = tag
+      @version = version
+    end
+
+    def to_i
+      @tag
+    end
+
+    def stale?(version)
+      raise ArgumentError.new("version cannot be nil") unless version
+
+      @version < version
+    end
+  end
+end

data/spec/higher_level_api/integration/basic_ack_spec.rb

@@ -7,50 +7,65 @@ describe Bunny::Channel, "#ack" do
     c
   end
 
-  after :all do
+  after :each do
     connection.close if connection.open?
   end
 
-  subject do
-    connection.create_channel
-  end
-
   context "with a valid (known) delivery tag" do
     it "acknowleges a message" do
-      q = subject.queue("bunny.basic.ack.manual-acks", :exclusive => true)
-      x = subject.default_exchange
+      ch = connection.create_channel
+      q  = ch.queue("bunny.basic.ack.manual-acks", :exclusive => true)
+      x  = ch.default_exchange
 
       x.publish("bunneth", :routing_key => q.name)
-      sleep(0.25)
+      sleep 0.5
       q.message_count.should == 1
       delivery_details, properties, content = q.pop(:ack => true)
 
-      subject.ack(delivery_details.delivery_tag, true)
-      sleep(0.25)
+      ch.ack(delivery_details.delivery_tag, true)
       q.message_count.should == 0
 
-      subject.close
+      ch.close
+    end
+  end
+
+
+  context "with a valid (known) delivery tag and automatic ack mode" do
+    it "results in a channel exception" do
+      ch = connection.create_channel
+      q  = ch.queue("bunny.basic.ack.manual-acks", :exclusive => true)
+      x  = ch.default_exchange
+
+      q.subscribe(:manual_ack => false) do |delivery_info, properties, payload|
+        ch.ack(delivery_info.delivery_tag, false)
+      end
+
+      x.publish("bunneth", :routing_key => q.name)
+      sleep 0.5
+      lambda do
+        q.message_count
+      end.should raise_error(Bunny::ChannelAlreadyClosed)
     end
   end
 
   context "with an invalid (random) delivery tag" do
     it "causes a channel-level error" do
-      q = subject.queue("bunny.basic.ack.unknown-delivery-tag", :exclusive => true)
-      x = subject.default_exchange
+      ch = connection.create_channel
+      q  = ch.queue("bunny.basic.ack.unknown-delivery-tag", :exclusive => true)
+      x  = ch.default_exchange
 
       x.publish("bunneth", :routing_key => q.name)
-      sleep(0.25)
+      sleep 0.5
       q.message_count.should == 1
       _, _, content = q.pop(:ack => true)
 
-      subject.on_error do |ch, channel_close|
+      ch.on_error do |ch, channel_close|
         @channel_close = channel_close
       end
-      subject.ack(82, true)
-
-      sleep 0.5
+      ch.ack(82, true)
+      sleep 0.25
 
-      @channel_close.reply_text.should == "PRECONDITION_FAILED - unknown delivery tag 82"
+      @channel_close.reply_code.should == AMQ::Protocol::PreconditionFailed::VALUE
     end
   end
 end

data/spec/higher_level_api/integration/basic_consume_spec.rb

@@ -1,4 +1,5 @@
 require "spec_helper"
+require "set"
 
 describe Bunny::Queue, "#subscribe" do
   let(:connection) do
@@ -41,6 +42,66 @@ describe Bunny::Queue, "#subscribe" do
 
       ch.close
     end
+
+    context "with a single consumer" do
+      let(:queue_name) { "bunny.basic_consume#{rand}" }
+
+      it "provides delivery tag access" do
+        delivery_tags = SortedSet.new
+
+        cch = connection.create_channel
+        q = cch.queue(queue_name, :auto_delete => true, :durable => false)
+        q.subscribe(:exclusive => false, :manual_ack => false) do |delivery_info, properties, payload|
+          delivery_tags << delivery_info.delivery_tag
+        end
+        sleep 0.5
+
+        ch = connection.create_channel
+        x  = ch.default_exchange
+        100.times do
+          x.publish("hello", :routing_key => queue_name)
+        end
+
+        sleep 1.0
+        delivery_tags.should == SortedSet.new(Range.new(1, 100).to_a)
+
+        ch.queue(queue_name, :auto_delete => true, :durable => false).message_count.should == 0
+
+        ch.close
+      end
+    end
+
+
+    context "with multiple consumers on the same channel" do
+      let(:queue_name) { "bunny.basic_consume#{rand}" }
+
+      it "provides delivery tag access" do
+        delivery_tags = SortedSet.new
+
+        cch = connection.create_channel
+        q   = cch.queue(queue_name, :auto_delete => true, :durable => false)
+
+        7.times do
+          q.subscribe(:exclusive => false, :manual_ack => false) do |delivery_info, properties, payload|
+            delivery_tags << delivery_info.delivery_tag
+          end
+        end
+        sleep 1.0
+
+        ch = connection.create_channel
+        x  = ch.default_exchange
+        100.times do
+          x.publish("hello", :routing_key => queue_name)
+        end
+
+        sleep 1.5
+        delivery_tags.should == SortedSet.new(Range.new(1, 100).to_a)
+
+        ch.queue(queue_name, :auto_delete => true, :durable => false).message_count.should == 0
+
+        ch.close
+      end
+    end
   end
 
   context "with manual acknowledgement mode" do
@@ -77,7 +138,7 @@ describe Bunny::Queue, "#subscribe" do
     end
   end
 
-  20.times do |i|
+  ENV.fetch("RUNS", 20).to_i.times do |i|
     context "with a queue that already has messages (take #{i})" do
       let(:queue_name) { "bunny.basic_consume#{rand}" }
 

data/spec/higher_level_api/integration/basic_get_spec.rb

@@ -8,7 +8,7 @@ describe Bunny::Queue, "#pop" do
     c
   end
 
-  after :all do
+  after :each do
     connection.close if connection.open?
   end
 

data/spec/issues/issue141_spec.rb

@@ -0,0 +1,44 @@
+require "spec_helper"
+
+describe "Registering 2nd exclusive consumer on queue" do
+  let(:connection) do
+    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
+    c.start
+    c
+  end
+
+  after :each do
+    connection.close if connection.open?
+  end
+
+
+  it "raises a meaningful exception" do
+    xs  = []
+
+    ch1 = connection.create_channel
+    ch2 = connection.create_channel
+    q1  = ch1.queue("", :auto_delete => true)
+    q2  = ch2.queue(q1.name, :auto_delete => true, :passive => true)
+
+    c1  = q1.subscribe(:exclusive => true) do |_, _, payload|
+      xs << payload
+    end
+    sleep 0.1
+
+    lambda do
+      q2.subscribe(:exclusive => true) do |_, _, _|
+      end
+    end.should raise_error(Bunny::AccessRefused)
+
+    ch1.should be_open
+    ch2.should be_closed
+
+    q1.publish("abc")
+    sleep 0.1
+
+    # verify that the first consumer is fine
+    xs.should == ["abc"]
+
+    q1.delete
+  end
+end

data/spec/unit/concurrent/atomic_fixnum_spec.rb

@@ -0,0 +1,35 @@
+require "spec_helper"
+require "bunny/concurrent/atomic_fixnum"
+
+describe Bunny::Concurrent::AtomicFixnum do
+  it "allows retrieving the current value" do
+    af = described_class.new(0)
+
+    af.get.should == 0
+    af.should == 0
+  end
+
+  it "can be updated" do
+    af = described_class.new(0)
+
+    af.get.should == 0
+    Thread.new do
+      af.set(10)
+    end
+    sleep 0.6
+    af.get.should == 10
+  end
+
+  it "can be incremented" do
+    af = described_class.new(0)
+
+    af.get.should == 0
+    10.times do
+      Thread.new do
+        af.increment
+      end
+    end
+    sleep 0.6
+    af.get.should == 10
+  end
+end

data/spec/unit/concurrent/synchronized_sorted_set_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+require "bunny/concurrent/synchronized_sorted_set"
+
+describe Bunny::Concurrent::SynchronizedSortedSet do
+  it "synchronizes common operations needed by Bunny" do
+    s = described_class.new
+    s.length.should == 0
+
+    10.times do
+      Thread.new do
+        s << 1
+        s << 1
+        s << 2
+        s << 3
+        s << 4
+        s << 4
+        s << 4
+        s << 4
+        s << 5
+        s << 5
+        s << 5
+        s << 5
+        s << 6
+        s << 7
+        s << 8
+        s.delete 8
+        s.delete_if { |i| i == 1 }
+      end
+    end
+    sleep 2.0
+
+    s.length.should == 6
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bunny
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre2
+  version: 1.0.0.pre3
 platform: ruby
 authors:
 - Chris Duncan
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-26 00:00:00.000000000 Z
+date: 2013-08-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: amq-protocol
@@ -57,6 +57,7 @@ files:
 - benchmarks/queue_declare.rb
 - benchmarks/queue_declare_and_bind.rb
 - benchmarks/queue_declare_bind_and_delete.rb
+- benchmarks/synchronized_sorted_set.rb
 - benchmarks/write_vs_write_nonblock.rb
 - bin/ci/before_build.sh
 - bunny.gemspec
@@ -90,6 +91,7 @@ files:
 - examples/guides/getting_started/weathr.rb
 - examples/guides/queues/one_off_consumer.rb
 - examples/guides/queues/redeliveries.rb
+- lib/amq/protocol/extensions.rb
 - lib/bunny.rb
 - lib/bunny/authentication/credentials_encoder.rb
 - lib/bunny/authentication/external_mechanism_encoder.rb
@@ -97,9 +99,11 @@ files:
 - lib/bunny/channel.rb
 - lib/bunny/channel_id_allocator.rb
 - lib/bunny/compatibility.rb
+- lib/bunny/concurrent/atomic_fixnum.rb
 - lib/bunny/concurrent/condition.rb
 - lib/bunny/concurrent/continuation_queue.rb
 - lib/bunny/concurrent/linked_continuation_queue.rb
+- lib/bunny/concurrent/synchronized_sorted_set.rb
 - lib/bunny/consumer.rb
 - lib/bunny/consumer_tag_generator.rb
 - lib/bunny/consumer_work_pool.rb
@@ -119,6 +123,7 @@ files:
 - lib/bunny/test_kit.rb
 - lib/bunny/transport.rb
 - lib/bunny/version.rb
+- lib/bunny/versioned_delivery_tag.rb
 - profiling/basic_publish/with_4K_messages.rb
 - spec/compatibility/queue_declare_spec.rb
 - spec/compatibility/queue_declare_with_default_channel_spec.rb
@@ -162,6 +167,7 @@ files:
 - spec/higher_level_api/integration/tx_commit_spec.rb
 - spec/higher_level_api/integration/tx_rollback_spec.rb
 - spec/issues/issue100_spec.rb
+- spec/issues/issue141_spec.rb
 - spec/issues/issue78_spec.rb
 - spec/issues/issue83_spec.rb
 - spec/issues/issue97_attachment.json
@@ -181,8 +187,10 @@ files:
 - spec/tls/server_cert.pem
 - spec/tls/server_key.pem
 - spec/unit/bunny_spec.rb
+- spec/unit/concurrent/atomic_fixnum_spec.rb
 - spec/unit/concurrent/condition_spec.rb
 - spec/unit/concurrent/linked_continuation_queue_spec.rb
+- spec/unit/concurrent/synchronized_sorted_set_spec.rb
 homepage: http://rubybunny.info
 licenses:
 - MIT
@@ -250,6 +258,7 @@ test_files:
 - spec/higher_level_api/integration/tx_commit_spec.rb
 - spec/higher_level_api/integration/tx_rollback_spec.rb
 - spec/issues/issue100_spec.rb
+- spec/issues/issue141_spec.rb
 - spec/issues/issue78_spec.rb
 - spec/issues/issue83_spec.rb
 - spec/issues/issue97_attachment.json
@@ -269,6 +278,8 @@ test_files:
 - spec/tls/server_cert.pem
 - spec/tls/server_key.pem
 - spec/unit/bunny_spec.rb
+- spec/unit/concurrent/atomic_fixnum_spec.rb
 - spec/unit/concurrent/condition_spec.rb
 - spec/unit/concurrent/linked_continuation_queue_spec.rb
+- spec/unit/concurrent/synchronized_sorted_set_spec.rb
 has_rdoc: true