bunny 1.0.7 → 2.24.0

data/lib/bunny/channel.rb

@@ -1,4 +1,6 @@
 # -*- coding: utf-8 -*-
+# frozen_string_literal: true
+
 require "thread"
 require "monitor"
 require "set"
@@ -13,11 +15,7 @@ require "bunny/delivery_info"
 require "bunny/return_info"
 require "bunny/message_properties"
 
-if defined?(JRUBY_VERSION)
-  require "bunny/concurrent/linked_continuation_queue"
-else
-  require "bunny/concurrent/continuation_queue"
-end
+require "bunny/concurrent/continuation_queue"
 
 module Bunny
   # ## Channels in RabbitMQ
@@ -37,11 +35,10 @@ module Bunny
   # Channels can be opened either via `Bunny::Session#create_channel` (sufficient in the majority
   # of cases) or by instantiating `Bunny::Channel` directly:
   #
-  # @example Using {Bunny::Session#create_channel}:
-  #   conn = Bunny.new
-  #   conn.start
+  #     conn = Bunny.new
+  #     conn.start
   #
-  #   ch   = conn.create_channel
+  #     ch   = conn.create_channel
   #
   # This will automatically allocate a channel id.
   #
@@ -51,10 +48,8 @@ module Bunny
   # closed, too. Closed channels can no longer be used. Attempts to use them will raise
   # {Bunny::ChannelAlreadyClosed}.
   #
-  # @example
-  #
-  #   ch  = conn.create_channel
-  #   ch.close
+  #     ch = conn.create_channel
+  #     ch.close
   #
   # ## Higher-level API
   #
@@ -146,6 +141,10 @@ module Bunny
     attr_reader :work_pool
     # @return [Integer] Next publisher confirmations sequence index
     attr_reader :next_publish_seq_no
+    # @return [Integer] Offset for the confirmations sequence index.
+    # This will be set to the current sequence index during automatic network failure recovery
+    # to keep the sequence monotonic for the user and abstract the reset from the protocol
+    attr_reader :delivery_tag_offset
     # @return [Hash<String, Bunny::Queue>] Queue instances declared on this channel
     attr_reader :queues
     # @return [Hash<String, Bunny::Exchange>] Exchange instances declared on this channel
@@ -157,7 +156,15 @@ module Bunny
     # @return [Hash<String, Bunny::Consumer>] Consumer instances declared on this channel
     attr_reader :consumers
 
+    # @return [Integer] active basic.qos prefetch value
+    attr_reader :prefetch_count
+    # @return [Integer] active basic.qos prefetch global mode
+    attr_reader :prefetch_global
+
+    attr_reader :cancel_consumers_before_closing
+
     DEFAULT_CONTENT_TYPE = "application/octet-stream".freeze
+    SHORTSTR_LIMIT = 255
 
     # @param [Bunny::Session] connection AMQP 0.9.1 connection
     # @param [Integer] id Channel id, pass nil to make Bunny automatically allocate it
@@ -166,6 +173,17 @@ module Bunny
       @connection = connection
       @logger     = connection.logger
       @id         = id || @connection.next_channel_id
+
+      # channel allocator is exhausted
+      if @id < 0
+        msg = "Cannot open a channel: max number of channels on connection reached. Connection channel_max value: #{@connection.channel_max}"
+        @logger.error(msg)
+
+        raise msg
+      else
+        @logger.debug { "Allocated channel id: #{@id}" }
+      end
+
       @status     = :opening
 
       @connection.register_channel(self)
@@ -179,6 +197,9 @@ module Bunny
       @publishing_mutex = @connection.mutex_impl.new
       @consumer_mutex   = @connection.mutex_impl.new
 
+      @queue_mutex    = @connection.mutex_impl.new
+      @exchange_mutex = @connection.mutex_impl.new
+
       @unconfirmed_set_mutex = @connection.mutex_impl.new
 
       self.reset_continuations
@@ -191,15 +212,21 @@ module Bunny
       @threads_waiting_on_basic_get_continuations = Set.new
 
       @next_publish_seq_no = 0
+      @delivery_tag_offset = 0
 
       @recoveries_counter = Bunny::Concurrent::AtomicFixnum.new(0)
+      @uncaught_exception_handler = Proc.new do |e, consumer|
+        @logger.error "Uncaught exception from consumer #{consumer.to_s}: #{e.inspect} @ #{e.backtrace[0]}"
+      end
+
+      @cancel_consumers_before_closing = false
     end
 
     attr_reader :recoveries_counter
 
     # @private
-    def read_write_timeout
-      @connection.read_write_timeout
+    def wait_on_continuations_timeout
+      @connection.transport_write_timeout
     end
 
     # Opens the channel and resets its internal state
@@ -223,8 +250,29 @@ module Bunny
     # {Bunny::Queue}, {Bunny::Exchange} and {Bunny::Consumer} instances.
     # @api public
     def close
+      # see bunny#528
+      raise_if_no_longer_open!
+
+      # This is a best-effort attempt to cancel all consumers before closing the channel.
+      # Retries are extremely unlikely to succeed, and the channel itself is about to be closed,
+      # so we don't bother retrying.
+      if self.cancel_consumers_before_closing?
+       # cancelling a consumer involves using the same mutex, so avoid holding the lock
+        keys = @consumer_mutex.synchronize { @consumers.keys }
+        keys.each do |ctag|
+          begin
+            self.basic_cancel(ctag)
+          rescue Bunny::Exception
+            # ignore
+          rescue Bunny::ClientTimeout
+            # ignore
+          end
+        end
+      end
+
       @connection.close_channel(self)
-      closed!
+      @status = :closed
+      @work_pool.shutdown
       maybe_kill_consumer_work_pool!
     end
 
@@ -240,7 +288,6 @@ module Bunny
       @status == :closed
     end
 
-
     #
     # @group Backwards compatibility with 0.8.0
     #
@@ -267,6 +314,23 @@ module Bunny
 
     # @endgroup
 
+    # @group Other settings
+
+    def configure(&block)
+      block.call(self) if block_given?
+
+      self
+    end
+
+    def cancel_consumers_before_closing!
+      @cancel_consumers_before_closing = true
+    end
+
+    def cancel_consumers_before_closing?
+      !!@cancel_consumers_before_closing
+    end
+
+    # @endgroup
 
     #
     # Higher-level API, similar to amqp gem
@@ -289,7 +353,7 @@ module Bunny
     # @see http://rubybunny.info/articles/extensions.html RabbitMQ Extensions to AMQP 0.9.1 guide
     # @api public
     def fanout(name, opts = {})
-      Exchange.new(self, :fanout, name, opts)
+      find_exchange(name) || Exchange.new(self, :fanout, name, opts)
     end
 
     # Declares a direct exchange or looks it up in the cache of previously
@@ -307,7 +371,7 @@ module Bunny
     # @see http://rubybunny.info/articles/extensions.html RabbitMQ Extensions to AMQP 0.9.1 guide
     # @api public
     def direct(name, opts = {})
-      Exchange.new(self, :direct, name, opts)
+      find_exchange(name) || Exchange.new(self, :direct, name, opts)
     end
 
     # Declares a topic exchange or looks it up in the cache of previously
@@ -325,7 +389,7 @@ module Bunny
     # @see http://rubybunny.info/articles/extensions.html RabbitMQ Extensions to AMQP 0.9.1 guide
     # @api public
     def topic(name, opts = {})
-      Exchange.new(self, :topic, name, opts)
+      find_exchange(name) || Exchange.new(self, :topic, name, opts)
     end
 
     # Declares a headers exchange or looks it up in the cache of previously
@@ -343,14 +407,14 @@ module Bunny
     # @see http://rubybunny.info/articles/extensions.html RabbitMQ Extensions to AMQP 0.9.1 guide
     # @api public
     def headers(name, opts = {})
-      Exchange.new(self, :headers, name, opts)
+      find_exchange(name) || Exchange.new(self, :headers, name, opts)
     end
 
     # Provides access to the default exchange
     # @see http://rubybunny.info/articles/exchanges.html Exchanges and Publishing guide
     # @api public
     def default_exchange
-      self.direct(AMQ::Protocol::EMPTY_STRING, :no_declare => true)
+      @default_exchange ||= Exchange.default(self)
     end
 
     # Declares a headers exchange or looks it up in the cache of previously
@@ -368,7 +432,7 @@ module Bunny
     # @see http://rubybunny.info/articles/exchanges.html Exchanges and Publishing guide
     # @see http://rubybunny.info/articles/extensions.html RabbitMQ Extensions to AMQP 0.9.1 guide
     def exchange(name, opts = {})
-      Exchange.new(self, opts.fetch(:type, :direct), name, opts)
+      find_exchange(name) || Exchange.new(self, opts.fetch(:type, :direct), name, opts)
     end
 
     # @endgroup
@@ -384,34 +448,105 @@ module Bunny
     # @option opts [Boolean] :durable (false) Should this queue be durable?
     # @option opts [Boolean] :auto-delete (false) Should this queue be automatically deleted when the last consumer disconnects?
     # @option opts [Boolean] :exclusive (false) Should this queue be exclusive (only can be used by this connection, removed when the connection is closed)?
-    # @option opts [Boolean] :arguments ({}) Additional optional arguments (typically used by RabbitMQ extensions and plugins)
+    # @option opts [Hash] :arguments ({}) Optional arguments (x-arguments)
     #
     # @return [Bunny::Queue] Queue that was declared or looked up in the cache
     # @see http://rubybunny.info/articles/queues.html Queues and Consumers guide
     # @see http://rubybunny.info/articles/extensions.html RabbitMQ Extensions guide
     # @api public
     def queue(name = AMQ::Protocol::EMPTY_STRING, opts = {})
+      throw ArgumentError.new("queue name must not be nil") if name.nil?
+
       q = find_queue(name) || Bunny::Queue.new(self, name, opts)
 
       register_queue(q)
     end
 
-    # @endgroup
+    # Declares a new client-named quorum queue.
+    #
+    # @param [String] name Queue name. Empty (server-generated) names are not supported by this method.
+    # @param  [Hash]  opts  Queue properties and other options. Durability, exclusivity, auto-deletion options will be ignored.
+    #
+    # @option opts [Hash] :arguments ({}) Optional arguments (x-arguments)
+    #
+    # @return [Bunny::Queue] Queue that was declared
+    # @see #durable_queue
+    # @see #queue
+    # @api public
+    def quorum_queue(name, opts = {})
+      throw ArgumentError.new("quorum queue name must not be nil") if name.nil?
+      throw ArgumentError.new("quorum queue name must not be empty (server-named QQs do not make sense)") if name.empty?
 
+      durable_queue(name, Bunny::Queue::Types::QUORUM, opts)
+    end
 
-    # @group QoS and Flow Control
+    # Declares a new client-named stream (that Bunny can use as if it was a queue).
+    # Note that Bunny would still use AMQP 0-9-1 to perform operations on this "queue".
+    # To use stream-specific operations and to gain from stream protocol efficiency and partitioning,
+    # use a Ruby client for the RabbitMQ stream protocol.
+    #
+    # @param [String] name Stream name. Empty (server-generated) names are not supported by this method.
+    # @param  [Hash]  opts  Queue properties and other options. Durability, exclusivity, auto-deletion options will be ignored.
+    #
+    # @option opts [Hash] :arguments ({}) Optional arguments (x-arguments)
+    #
+    #
+    # @return [Bunny::Queue] Queue that was declared
+    # @see #durable_queue
+    # @see #queue
+    # @api public
+    def stream(name, opts = {})
+      throw ArgumentError.new("stream name must not be nil") if name.nil?
+      throw ArgumentError.new("stream name must not be empty (server-named QQs do not make sense)") if name.empty?
+
+      durable_queue(name, Bunny::Queue::Types::STREAM, opts)
+    end
 
-    # Sets how many messages will be given to consumers on this channel before they
-    # have to acknowledge or reject one of the previously consumed messages
+    # Declares a new server-named queue that is automatically deleted when the
+    # connection is closed.
     #
-    # @param [Integer] prefetch_count Prefetch (QoS setting) for this channel
-    # @see http://rubybunny.info/articles/exchanges.html Exchanges and Publishing guide
-    # @see http://rubybunny.info/articles/queues.html Queues and Consumers guide
+    # @param [String] name Queue name. Empty (server-generated) names are not supported by this method.
+    # @param  [Hash]  opts  Queue properties and other options. Durability, exclusivity, auto-deletion options will be ignored.
+    #
+    # @option opts [Hash] :arguments ({}) Optional arguments (x-arguments)
+    #
+    # @return [Bunny::Queue] Queue that was declared
+    # @see #queue
     # @api public
-    def prefetch(prefetch_count)
-      self.basic_qos(prefetch_count, false)
+    def durable_queue(name, type = "classic", opts = {})
+      throw ArgumentError.new("queue name must not be nil") if name.nil?
+      throw ArgumentError.new("queue name must not be empty (server-named durable queues do not make sense)") if name.empty?
+
+      final_opts = opts.merge({
+        :type        => type,
+        :durable     => true,
+        # exclusive or auto-delete QQs do not make much sense
+        :exclusive   => false,
+        :auto_delete => false
+      })
+      q = find_queue(name) || Bunny::Queue.new(self, name, final_opts)
+
+      register_queue(q)
     end
 
+    # Declares a new server-named queue that is automatically deleted when the
+    # connection is closed.
+    #
+    # @return [Bunny::Queue] Queue that was declared
+    # @see #queue
+    # @api public
+    def temporary_queue(opts = {})
+      temporary_queue_opts = {
+        :exclusive => true
+      }
+      queue("", opts.merge(temporary_queue_opts))
+    end
+
+    # @endgroup
+
+
+    # @group QoS and Flow Control
+
     # Flow control. When set to false, RabbitMQ will stop delivering messages on this
     # channel.
     #
@@ -444,9 +579,7 @@ module Bunny
     # @see http://rubybunny.info/articles/queues.html Queues and Consumers guide
     # @api public
     def reject(delivery_tag, requeue = false)
-      guarding_against_stale_delivery_tags(delivery_tag) do
-        basic_reject(delivery_tag.to_i, requeue)
-      end
+      basic_reject(delivery_tag.to_i, requeue)
     end
 
     # Acknowledges a message. Acknowledged messages are completely removed from the queue.
@@ -457,9 +590,7 @@ module Bunny
     # @see http://rubybunny.info/articles/queues.html Queues and Consumers guide
     # @api public
     def ack(delivery_tag, multiple = false)
-      guarding_against_stale_delivery_tags(delivery_tag) do
-        basic_ack(delivery_tag.to_i, multiple)
-      end
+      basic_ack(delivery_tag.to_i, multiple)
     end
     alias acknowledge ack
 
@@ -474,9 +605,7 @@ module Bunny
     # @see http://rubybunny.info/articles/queues.html Queues and Consumers guide
     # @api public
     def nack(delivery_tag, multiple = false, requeue = false)
-      guarding_against_stale_delivery_tags(delivery_tag) do
-        basic_nack(delivery_tag.to_i, multiple, requeue)
-      end
+      basic_nack(delivery_tag.to_i, multiple, requeue)
     end
 
     # @endgroup
@@ -513,6 +642,7 @@ module Bunny
     # @api public
     def basic_publish(payload, exchange, routing_key, opts = {})
       raise_if_no_longer_open!
+      raise ArgumentError, "routing key cannot be longer than #{SHORTSTR_LIMIT} characters" if routing_key && routing_key.size > SHORTSTR_LIMIT
 
       exchange_name = if exchange.respond_to?(:name)
                         exchange.name
@@ -531,8 +661,10 @@ module Bunny
       opts[:priority]      ||= 0
 
       if @next_publish_seq_no > 0
-        @unconfirmed_set.add(@next_publish_seq_no)
-        @next_publish_seq_no += 1
+        @unconfirmed_set_mutex.synchronize do
+          @unconfirmed_set.add(@next_publish_seq_no)
+          @next_publish_seq_no += 1
+        end
       end
 
       frames = AMQ::Protocol::Basic::Publish.encode(@id,
@@ -543,7 +675,7 @@ module Bunny
         opts[:mandatory],
         false,
         @connection.frame_max)
-      @connection.send_frameset_without_timeout(frames, self)
+      @connection.send_frameset(frames, self)
 
       self
     end
@@ -555,7 +687,8 @@ module Bunny
     # @param [String] queue Queue name
     # @param [Hash] opts Options
     #
-    # @option opts [Boolean] :ack (true) Will this message be acknowledged manually?
+    # @option opts [Boolean] :ack (true) [DEPRECATED] Use :manual_ack instead
+    # @option opts [Boolean] :manual_ack (true) Will this message be acknowledged manually?
     #
     # @return [Array] A triple of delivery info, message properties and message content
     #
@@ -564,15 +697,20 @@ module Bunny
     #   conn.start
     #   ch   = conn.create_channel
     #   # here we assume the queue already exists and has messages
-    #   delivery_info, properties, payload = ch.basic_get("bunny.examples.queue1", :ack => true)
+    #   delivery_info, properties, payload = ch.basic_get("bunny.examples.queue1", :manual_ack => true)
     #   ch.acknowledge(delivery_info.delivery_tag)
     # @see Bunny::Queue#pop
     # @see http://rubybunny.info/articles/queues.html Queues and Consumers guide
     # @api public
-    def basic_get(queue, opts = {:ack => true})
+    def basic_get(queue, opts = {:manual_ack => true})
       raise_if_no_longer_open!
 
-      @connection.send_frame(AMQ::Protocol::Basic::Get.encode(@id, queue, !(opts[:ack])))
+      unless opts[:ack].nil?
+        warn "[DEPRECATION] `:ack` is deprecated.  Please use `:manual_ack` instead."
+        opts[:manual_ack] = opts[:ack]
+      end
+
+      @connection.send_frame(AMQ::Protocol::Basic::Get.encode(@id, queue, !(opts[:manual_ack])))
       # this is a workaround for the edge case when basic_get is called in a tight loop
       # and network goes down we need to perform recovery. The problem is, basic_get will
       # keep blocking the thread that calls it without clear way to constantly unblock it
@@ -580,40 +718,59 @@ module Bunny
       # implementation (and even more correct and convenient ones, such as wait/notify, should
       # we implement them). So we return a triple of nils immediately which apps should be
       # able to handle anyway as "got no message, no need to act". MK.
-      @last_basic_get_response = if @connection.open?
-                                   wait_on_basic_get_continuations
-                                 else
-                                   [nil, nil, nil]
-                                 end
+      last_basic_get_response = if @connection.open?
+                                  begin
+                                    wait_on_basic_get_continuations
+                                  rescue Timeout::Error => e
+                                    raise_if_continuation_resulted_in_a_channel_error!
+                                    raise e
+                                  end
+                                else
+                                  [nil, nil, nil]
+                                end
 
       raise_if_continuation_resulted_in_a_channel_error!
-      @last_basic_get_response
+      last_basic_get_response
     end
 
+    # prefetch_count is of type short in the protocol. MK.
+    MAX_PREFETCH_COUNT = (2 ** 16) - 1
+
     # Controls message delivery rate using basic.qos AMQP 0.9.1 method.
     #
     # @param [Integer] prefetch_count How many messages can consumers on this channel be given at a time
     #                                 (before they have to acknowledge or reject one of the earlier received messages)
-    # @param [Boolean] global (false) Ignored, as it is not supported by RabbitMQ
+    # @param [Boolean] global
+    #   Whether to use global mode for prefetch:
+    #   - +false+: per-consumer
+    #   - +true+:  per-channel
+    #   Note that the default value (+false+) hasn't actually changed, but
+    #   previous documentation described that as meaning per-channel and
+    #   unsupported in RabbitMQ, whereas it now actually appears to mean
+    #   per-consumer and supported
+    #   (https://www.rabbitmq.com/consumer-prefetch.html).
     # @return [AMQ::Protocol::Basic::QosOk] RabbitMQ response
     # @see Bunny::Channel#prefetch
     # @see http://rubybunny.info/articles/queues.html Queues and Consumers guide
     # @api public
-    def basic_qos(prefetch_count, global = false)
-      raise ArgumentError.new("prefetch count must be a positive integer, given: #{prefetch_count}") if prefetch_count < 0
+    def basic_qos(count, global = false)
+      raise ArgumentError.new("prefetch count must be a positive integer, given: #{count}") if count < 0
+      raise ArgumentError.new("prefetch count must be no greater than #{MAX_PREFETCH_COUNT}, given: #{count}") if count > MAX_PREFETCH_COUNT
       raise_if_no_longer_open!
 
-      @connection.send_frame(AMQ::Protocol::Basic::Qos.encode(@id, 0, prefetch_count, global))
+      @connection.send_frame(AMQ::Protocol::Basic::Qos.encode(@id, 0, count, global))
 
-      Bunny::Timeout.timeout(read_write_timeout, ClientTimeout) do
+      with_continuation_timeout do
         @last_basic_qos_ok = wait_on_continuations
       end
       raise_if_continuation_resulted_in_a_channel_error!
 
-      @prefetch_count = prefetch_count
+      @prefetch_count  = count
+      @prefetch_global = global
 
       @last_basic_qos_ok
     end
+    alias prefetch basic_qos
 
     # Redeliver unacknowledged messages
     #
@@ -624,7 +781,7 @@ module Bunny
       raise_if_no_longer_open!
 
       @connection.send_frame(AMQ::Protocol::Basic::Recover.encode(@id, requeue))
-      Bunny::Timeout.timeout(read_write_timeout, ClientTimeout) do
+      with_continuation_timeout do
         @last_basic_recover_ok = wait_on_continuations
       end
       raise_if_continuation_resulted_in_a_channel_error!
@@ -654,7 +811,7 @@ module Bunny
     #
     #   ch    = conn.create_channel
     #   q.subscribe do |delivery_info, properties, payload|
-    #     # requeue the message
+    #     # reject the message
     #     ch.basic_reject(delivery_info.delivery_tag, false)
     #   end
     #
@@ -664,17 +821,19 @@ module Bunny
     #
     #   ch    = conn.create_channel
     #   # we assume the queue exists and has messages
-    #   delivery_info, properties, payload = ch.basic_get("bunny.examples.queue3", :ack => true)
+    #   delivery_info, properties, payload = ch.basic_get("bunny.examples.queue3", :manual_ack => true)
     #   ch.basic_reject(delivery_info.delivery_tag, true)
     #
     # @see Bunny::Channel#basic_nack
     # @see http://rubybunny.info/articles/queues.html Queues and Consumers guide
     # @api public
-    def basic_reject(delivery_tag, requeue)
-      raise_if_no_longer_open!
-      @connection.send_frame(AMQ::Protocol::Basic::Reject.encode(@id, delivery_tag, requeue))
+    def basic_reject(delivery_tag, requeue = false)
+      guarding_against_stale_delivery_tags(delivery_tag) do
+        raise_if_no_longer_open!
+        @connection.send_frame(AMQ::Protocol::Basic::Reject.encode(@id, delivery_tag, requeue))
 
-      nil
+        nil
+      end
     end
 
     # Acknowledges a delivery (message).
@@ -690,7 +849,7 @@ module Bunny
     #   ch    = conn.create_channel
     #   q.subscribe do |delivery_info, properties, payload|
     #     # requeue the message
-    #     ch.basic_ack(delivery_info.delivery_tag)
+    #     ch.basic_ack(delivery_info.delivery_tag.to_i)
     #   end
     #
     # @example Ack a message fetched via basic.get
@@ -699,8 +858,8 @@ module Bunny
     #
     #   ch    = conn.create_channel
     #   # we assume the queue exists and has messages
-    #   delivery_info, properties, payload = ch.basic_get("bunny.examples.queue3", :ack => true)
-    #   ch.basic_ack(delivery_info.delivery_tag)
+    #   delivery_info, properties, payload = ch.basic_get("bunny.examples.queue3", :manual_ack => true)
+    #   ch.basic_ack(delivery_info.delivery_tag.to_i)
     #
     # @example Ack multiple messages fetched via basic.get
     #   conn  = Bunny.new
@@ -708,20 +867,21 @@ module Bunny
     #
     #   ch    = conn.create_channel
     #   # we assume the queue exists and has messages
-    #   _, _, payload1 = ch.basic_get("bunny.examples.queue3", :ack => true)
-    #   _, _, payload2 = ch.basic_get("bunny.examples.queue3", :ack => true)
-    #   delivery_info, properties, payload3 = ch.basic_get("bunny.examples.queue3", :ack => true)
+    #   _, _, payload1 = ch.basic_get("bunny.examples.queue3", :manual_ack => true)
+    #   _, _, payload2 = ch.basic_get("bunny.examples.queue3", :manual_ack => true)
+    #   delivery_info, properties, payload3 = ch.basic_get("bunny.examples.queue3", :manual_ack => true)
     #   # ack all fetched messages up to payload3
-    #   ch.basic_ack(delivery_info.delivery_tag, true)
+    #   ch.basic_ack(delivery_info.delivery_tag.to_i, 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!
-      @connection.send_frame(AMQ::Protocol::Basic::Ack.encode(@id, delivery_tag, multiple))
+    def basic_ack(delivery_tag, multiple = false)
+      guarding_against_stale_delivery_tags(delivery_tag) do
+        raise_if_no_longer_open!
+        @connection.send_frame(AMQ::Protocol::Basic::Ack.encode(@id, delivery_tag, multiple))
 
-      nil
+        nil
+      end
     end
 
     # Rejects or requeues messages just like {Bunny::Channel#basic_reject} but can do so
@@ -758,7 +918,7 @@ module Bunny
     #
     #   ch    = conn.create_channel
     #   # we assume the queue exists and has messages
-    #   delivery_info, properties, payload = ch.basic_get("bunny.examples.queue3", :ack => true)
+    #   delivery_info, properties, payload = ch.basic_get("bunny.examples.queue3", :manual_ack => true)
     #   ch.basic_nack(delivery_info.delivery_tag, false, true)
     #
     #
@@ -768,9 +928,9 @@ module Bunny
     #
     #   ch    = conn.create_channel
     #   # we assume the queue exists and has messages
-    #   _, _, payload1 = ch.basic_get("bunny.examples.queue3", :ack => true)
-    #   _, _, payload2 = ch.basic_get("bunny.examples.queue3", :ack => true)
-    #   delivery_info, properties, payload3 = ch.basic_get("bunny.examples.queue3", :ack => true)
+    #   _, _, payload1 = ch.basic_get("bunny.examples.queue3", :manual_ack => true)
+    #   _, _, payload2 = ch.basic_get("bunny.examples.queue3", :manual_ack => true)
+    #   delivery_info, properties, payload3 = ch.basic_get("bunny.examples.queue3", :manual_ack => true)
     #   # requeue all fetched messages up to payload3
     #   ch.basic_nack(delivery_info.delivery_tag, true, true)
     #
@@ -778,13 +938,15 @@ module Bunny
     # @see http://rubybunny.info/articles/extensions.html RabbitMQ Extensions guide
     # @api public
     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))
+      guarding_against_stale_delivery_tags(delivery_tag) do
+        raise_if_no_longer_open!
+        @connection.send_frame(AMQ::Protocol::Basic::Nack.encode(@id,
+                                                                 delivery_tag,
+                                                                 multiple,
+                                                                 requeue))
 
-      nil
+        nil
+      end
     end
 
     # Registers a consumer for queue. Delivered messages will be handled with the block
@@ -826,7 +988,7 @@ module Bunny
           arguments))
 
       begin
-        Bunny::Timeout.timeout(read_write_timeout, ClientTimeout) do
+        with_continuation_timeout do
           @last_basic_consume_ok = wait_on_continuations
         end
       rescue Exception => e
@@ -876,7 +1038,7 @@ module Bunny
           consumer.arguments))
 
       begin
-        Bunny::Timeout.timeout(read_write_timeout, ClientTimeout) do
+        with_continuation_timeout do
           @last_basic_consume_ok = wait_on_continuations
         end
       rescue Exception => e
@@ -904,18 +1066,29 @@ module Bunny
     # it was on is auto-deleted and this consumer was the last one, the queue will be deleted.
     #
     # @param [String] consumer_tag Consumer tag (unique identifier) to cancel
+    # @param [Hash] arguments ({}) Optional arguments
     #
-    # @return [AMQ::Protocol::Basic::CancelOk] RabbitMQ response
+    # @option opts [Boolean] :no_wait (false) if set to true, this method won't receive a response and will
+    #                                         immediately return nil
+    #
+    # @return [AMQ::Protocol::Basic::CancelOk] RabbitMQ response or nil, if the no_wait option is used
     # @see http://rubybunny.info/articles/queues.html Queues and Consumers guide
     # @api public
-    def basic_cancel(consumer_tag)
-      @connection.send_frame(AMQ::Protocol::Basic::Cancel.encode(@id, consumer_tag, false))
+    def basic_cancel(consumer_tag, opts = {})
+      no_wait = opts.fetch(:no_wait, false)
+      @connection.send_frame(AMQ::Protocol::Basic::Cancel.encode(@id, consumer_tag, no_wait))
 
-      Bunny::Timeout.timeout(read_write_timeout, ClientTimeout) do
-        @last_basic_cancel_ok = wait_on_continuations
+      if no_wait
+        @last_basic_cancel_ok = nil
+      else
+        with_continuation_timeout do
+          @last_basic_cancel_ok = wait_on_continuations
+        end
       end
 
-      maybe_kill_consumer_work_pool! unless any_consumers?
+      # reduces thread usage for channels that don't have any
+      # consumers
+      @work_pool.shutdown(true) unless self.any_consumers?
 
       @last_basic_cancel_ok
     end
@@ -933,7 +1106,8 @@ module Bunny
 
     # Declares a queue using queue.declare AMQP 0.9.1 method.
     #
-    # @param [String] name Queue name
+    # @param [String] name The name of the queue or an empty string to let RabbitMQ generate a name.
+    #                      Note that LF and CR characters will be stripped from the value.
     # @param [Hash] opts Queue properties
     #
     # @option opts [Boolean] durable (false)     Should information about this queue be persisted to disk so that it
@@ -944,23 +1118,37 @@ module Bunny
     #                                          connection is closed
     # @option opts [Boolean] passive (false)   If true, queue will be checked for existence. If it does not
     #                                          exist, {Bunny::NotFound} will be raised.
-    #
+    # @option opts [Hash] :arguments ({}) Optional queue arguments (x-arguments)
     # @return [AMQ::Protocol::Queue::DeclareOk] RabbitMQ response
     # @see http://rubybunny.info/articles/queues.html Queues and Consumers guide
     # @api public
     def queue_declare(name, opts = {})
       raise_if_no_longer_open!
 
-      @connection.send_frame(AMQ::Protocol::Queue::Declare.encode(@id,
-          name,
+      Bunny::Queue.verify_type!(opts[:arguments]) if opts[:arguments]
+
+      # strip trailing new line and carriage returns
+      # just like RabbitMQ does
+      safe_name = name.gsub(/[\r\n]/, "")
+      @pending_queue_declare_name = safe_name
+      @connection.send_frame(
+        AMQ::Protocol::Queue::Declare.encode(@id,
+          @pending_queue_declare_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
 
+      begin
+        with_continuation_timeout do
+          @last_queue_declare_ok = wait_on_continuations
+        end
+      ensure
+        # clear pending continuation context if it belongs to us
+        @pending_queue_declare_name = nil if @pending_queue_declare_name == safe_name
+      end
       raise_if_continuation_resulted_in_a_channel_error!
 
       @last_queue_declare_ok
@@ -985,7 +1173,7 @@ module Bunny
           opts[:if_unused],
           opts[:if_empty],
           false))
-      Bunny::Timeout.timeout(read_write_timeout, ClientTimeout) do
+      with_continuation_timeout do
         @last_queue_delete_ok = wait_on_continuations
       end
       raise_if_continuation_resulted_in_a_channel_error!
@@ -1005,7 +1193,7 @@ module Bunny
 
       @connection.send_frame(AMQ::Protocol::Queue::Purge.encode(@id, name, false))
 
-      Bunny::Timeout.timeout(read_write_timeout, ClientTimeout) do
+      with_continuation_timeout do
         @last_queue_purge_ok = wait_on_continuations
       end
       raise_if_continuation_resulted_in_a_channel_error!
@@ -1038,10 +1226,10 @@ module Bunny
       @connection.send_frame(AMQ::Protocol::Queue::Bind.encode(@id,
           name,
           exchange_name,
-          opts[:routing_key],
+          (opts[:routing_key] || opts[:key]),
           false,
           opts[:arguments]))
-      Bunny::Timeout.timeout(read_write_timeout, ClientTimeout) do
+      with_continuation_timeout do
         @last_queue_bind_ok = wait_on_continuations
       end
 
@@ -1076,7 +1264,7 @@ module Bunny
           exchange_name,
           opts[:routing_key],
           opts[:arguments]))
-      Bunny::Timeout.timeout(read_write_timeout, ClientTimeout) do
+      with_continuation_timeout do
         @last_queue_unbind_ok = wait_on_continuations
       end
 
@@ -1089,33 +1277,38 @@ module Bunny
 
     # @group Exchange operations (exchange.*)
 
-    # Declares a echange using echange.declare AMQP 0.9.1 method.
+    # Declares a exchange using exchange.declare AMQP 0.9.1 method.
     #
-    # @param [String] name Exchange name
+    # @param [String] name The name of the exchange. Note that LF and CR characters
+    #                       will be stripped from the value.
+    # @param [String,Symbol] type Exchange type, e.g. :fanout or :topic
     # @param [Hash] opts Exchange properties
     #
-    # @option opts [Boolean] durable (false)     Should information about this echange be persisted to disk so that it
+    # @option opts [Boolean] durable (false)     Should information about this exchange be persisted to disk so that it
     #                                            can survive broker restarts? Typically set to true for long-lived exchanges.
-    # @option opts [Boolean] auto_delete (false) Should this echange be deleted when it is no longer used?
+    # @option opts [Boolean] auto_delete (false) Should this exchange be deleted when it is no longer used?
     # @option opts [Boolean] passive (false)   If true, exchange will be checked for existence. If it does not
     #                                          exist, {Bunny::NotFound} will be raised.
     #
     # @return [AMQ::Protocol::Exchange::DeclareOk] RabbitMQ response
-    # @see http://rubybunny.info/articles/echanges.html Exchanges and Publishing guide
+    # @see http://rubybunny.info/articles/exchanges.html Exchanges and Publishing guide
     # @api public
     def exchange_declare(name, type, opts = {})
       raise_if_no_longer_open!
 
+      # strip trailing new line and carriage returns
+      # just like RabbitMQ does
+      safe_name = name.gsub(/[\r\n]/, "")
       @connection.send_frame(AMQ::Protocol::Exchange::Declare.encode(@id,
-          name,
+          safe_name,
           type.to_s,
           opts.fetch(:passive, false),
           opts.fetch(:durable, false),
           opts.fetch(:auto_delete, false),
-          false,
-          false,
+          opts.fetch(:internal, false),
+          opts.fetch(:no_wait, false),
           opts[:arguments]))
-      Bunny::Timeout.timeout(read_write_timeout, ClientTimeout) do
+      with_continuation_timeout do
         @last_exchange_declare_ok = wait_on_continuations
       end
 
@@ -1140,7 +1333,7 @@ module Bunny
           name,
           opts[:if_unused],
           false))
-      Bunny::Timeout.timeout(read_write_timeout, ClientTimeout) do
+      with_continuation_timeout do
         @last_exchange_delete_ok = wait_on_continuations
       end
 
@@ -1184,7 +1377,7 @@ module Bunny
           opts[:routing_key],
           false,
           opts[:arguments]))
-      Bunny::Timeout.timeout(read_write_timeout, ClientTimeout) do
+      with_continuation_timeout do
         @last_exchange_bind_ok = wait_on_continuations
       end
 
@@ -1228,7 +1421,7 @@ module Bunny
           opts[:routing_key],
           false,
           opts[:arguments]))
-      Bunny::Timeout.timeout(read_write_timeout, ClientTimeout) do
+      with_continuation_timeout do
         @last_exchange_unbind_ok = wait_on_continuations
       end
 
@@ -1256,7 +1449,7 @@ module Bunny
       raise_if_no_longer_open!
 
       @connection.send_frame(AMQ::Protocol::Channel::Flow.encode(@id, active))
-      Bunny::Timeout.timeout(read_write_timeout, ClientTimeout) do
+      with_continuation_timeout do
         @last_channel_flow_ok = wait_on_continuations
       end
       raise_if_continuation_resulted_in_a_channel_error!
@@ -1277,10 +1470,11 @@ module Bunny
       raise_if_no_longer_open!
 
       @connection.send_frame(AMQ::Protocol::Tx::Select.encode(@id))
-      Bunny::Timeout.timeout(read_write_timeout, ClientTimeout) do
+      with_continuation_timeout do
         @last_tx_select_ok = wait_on_continuations
       end
       raise_if_continuation_resulted_in_a_channel_error!
+      @tx_mode = true
 
       @last_tx_select_ok
     end
@@ -1292,7 +1486,7 @@ module Bunny
       raise_if_no_longer_open!
 
       @connection.send_frame(AMQ::Protocol::Tx::Commit.encode(@id))
-      Bunny::Timeout.timeout(read_write_timeout, ClientTimeout) do
+      with_continuation_timeout do
         @last_tx_commit_ok = wait_on_continuations
       end
       raise_if_continuation_resulted_in_a_channel_error!
@@ -1307,7 +1501,7 @@ module Bunny
       raise_if_no_longer_open!
 
       @connection.send_frame(AMQ::Protocol::Tx::Rollback.encode(@id))
-      Bunny::Timeout.timeout(read_write_timeout, ClientTimeout) do
+      with_continuation_timeout do
         @last_tx_rollback_ok = wait_on_continuations
       end
       raise_if_continuation_resulted_in_a_channel_error!
@@ -1315,6 +1509,11 @@ module Bunny
       @last_tx_rollback_ok
     end
 
+    # @return [Boolean] true if this channel has transactions enabled
+    def using_tx?
+      !!@tx_mode
+    end
+
     # @endgroup
 
 
@@ -1326,6 +1525,7 @@ module Bunny
     def using_publisher_confirmations?
       @next_publish_seq_no > 0
     end
+    alias using_publisher_confirms? using_publisher_confirmations?
 
     # Enables publisher confirms for the channel.
     # @return [AMQ::Protocol::Confirm::SelectOk] RabbitMQ response
@@ -1334,7 +1534,7 @@ module Bunny
     # @see #nacked_set
     # @see http://rubybunny.info/articles/extensions.html RabbitMQ Extensions guide
     # @api public
-    def confirm_select(callback=nil)
+    def confirm_select(callback = nil)
       raise_if_no_longer_open!
 
       if @next_publish_seq_no == 0
@@ -1342,12 +1542,13 @@ module Bunny
         @unconfirmed_set        = Set.new
         @nacked_set             = Set.new
         @next_publish_seq_no    = 1
+        @only_acks_received = true
       end
 
       @confirms_callback = callback
 
       @connection.send_frame(AMQ::Protocol::Confirm::Select.encode(@id, false))
-      Bunny::Timeout.timeout(read_write_timeout, ClientTimeout) do
+      with_continuation_timeout do
         @last_confirm_select_ok = wait_on_continuations
       end
       raise_if_continuation_resulted_in_a_channel_error!
@@ -1355,19 +1556,18 @@ module Bunny
     end
 
     # Blocks calling thread until confirms are received for all
-    # currently unacknowledged published messages.
+    # currently unacknowledged published messages. Returns immediately
+    # if there are no outstanding confirms.
     #
-    # @return [Boolean] true if all messages were acknowledged positively, false otherwise
+    # @return [Boolean] true if all messages were acknowledged positively since the last time this method was called, false otherwise
     # @see #confirm_select
     # @see #unconfirmed_set
     # @see #nacked_set
     # @see http://rubybunny.info/articles/extensions.html RabbitMQ Extensions guide
     # @api public
     def wait_for_confirms
-      @only_acks_received = true
       wait_on_confirms_continuations
-
-      @only_acks_received
+      read_and_reset_only_acks_received
     end
 
     # @endgroup
@@ -1386,7 +1586,8 @@ module Bunny
     # @return [String]  Unique string.
     # @api plugin
     def generate_consumer_tag(name = "bunny")
-      "#{name}-#{Time.now.to_i * 1000}-#{Kernel.rand(999_999_999_999)}"
+      t = Bunny::Timestamp.now
+      "#{name}-#{t.to_i * 1000}-#{Kernel.rand(999_999_999_999)}"
     end
 
     # @endgroup
@@ -1404,6 +1605,13 @@ module Bunny
       @on_error = block
     end
 
+    # Defines a handler for uncaught exceptions in consumers
+    # (e.g. delivered message handlers).
+    #
+    # @api public
+    def on_uncaught_exception(&block)
+      @uncaught_exception_handler = block
+    end
 
     #
     # Recovery
@@ -1416,10 +1624,12 @@ module Bunny
     #
     # @api plugin
     def recover_from_network_failure
-      @logger.debug "Recovering channel #{@id} after network failure"
+      @logger.debug { "Recovering channel #{@id} after network failure" }
       release_all_continuations
 
       recover_prefetch_setting
+      recover_confirm_mode
+      recover_tx_mode
       recover_exchanges
       # this includes recovering bindings
       recover_queues
@@ -1432,7 +1642,30 @@ module Bunny
     #
     # @api plugin
     def recover_prefetch_setting
-      basic_qos(@prefetch_count) if @prefetch_count
+      basic_qos(@prefetch_count, @prefetch_global) if @prefetch_count
+    end
+
+    # Recovers publisher confirms mode. Used by the Automatic Network Failure
+    # Recovery feature.
+    # Set the offset to the previous publish sequence index as the protocol will reset the index to after recovery.
+    #
+    # @api plugin
+    def recover_confirm_mode
+      if using_publisher_confirmations?
+        @unconfirmed_set_mutex.synchronize do
+          @unconfirmed_set.clear
+          @delivery_tag_offset = @next_publish_seq_no - 1
+        end
+        confirm_select(@confirms_callback)
+      end
+    end
+
+    # Recovers transaction mode. Used by the Automatic Network Failure
+    # Recovery feature.
+    #
+    # @api plugin
+    def recover_tx_mode
+      tx_select if @tx_mode
     end
 
     # Recovers exchanges. Used by the Automatic Network Failure
@@ -1440,7 +1673,7 @@ module Bunny
     #
     # @api plugin
     def recover_exchanges
-      @exchanges.values.dup.each do |x|
+      @exchange_mutex.synchronize { @exchanges.values }.each do |x|
         x.recover_from_network_failure
       end
     end
@@ -1450,8 +1683,8 @@ module Bunny
     #
     # @api plugin
     def recover_queues
-      @queues.values.dup.each do |q|
-        @logger.debug "Recovering queue #{q.name}"
+      @queue_mutex.synchronize { @queues.values }.each do |q|
+        @logger.debug { "Recovering queue #{q.name}" }
         q.recover_from_network_failure
       end
     end
@@ -1462,10 +1695,11 @@ module Bunny
     # @api plugin
     def recover_consumers
       unless @consumers.empty?
-        @work_pool = ConsumerWorkPool.new(@work_pool.size)
+        @work_pool = ConsumerWorkPool.new(@work_pool.size, @work_pool.abort_on_exception)
         @work_pool.start
       end
-      @consumers.values.dup.each do |c|
+
+      @consumer_mutex.synchronize { @consumers.values }.each do |c|
         c.recover_from_network_failure
       end
     end
@@ -1475,12 +1709,26 @@ module Bunny
       @recoveries_counter.increment
     end
 
+    # @api public
+    def recover_cancelled_consumers!
+      @recover_cancelled_consumers = true
+    end
+
+    # @api public
+    def recovers_cancelled_consumers?
+      !!@recover_cancelled_consumers
+    end
+
     # @endgroup
 
 
     # @return [String] Brief human-readable representation of the channel
     def to_s
-      "#<#{self.class.name}:#{object_id} @id=#{self.number} @connection=#{@connection.to_s}>"
+      "#<#{self.class.name}:#{object_id} @id=#{self.number} @connection=#{@connection.to_s} @open=#{open?}>"
+    end
+
+    def inspect
+      to_s
     end
 
 
@@ -1488,6 +1736,11 @@ module Bunny
     # Implementation
     #
 
+    # @private
+    def with_continuation_timeout(&block)
+      Bunny::Timeout.timeout(wait_on_continuations_timeout, ClientTimeout, &block)
+    end
+
     # @private
     def register_consumer(consumer_tag, consumer)
       @consumer_mutex.synchronize do
@@ -1511,12 +1764,33 @@ module Bunny
       end
     end
 
+    # @private
+    def pending_server_named_queue_declaration?
+      @pending_queue_declare_name && @pending_queue_declare_name.empty?
+    end
+
+    # @private
+    def can_accept_queue_declare_ok?(method)
+      @pending_queue_declare_name == method.queue ||
+        pending_server_named_queue_declaration?
+    end
+
     # @private
     def handle_method(method)
-      @logger.debug "Channel#handle_frame on channel #{@id}: #{method.inspect}"
+      @logger.debug { "Channel#handle_frame on channel #{@id}: #{method.inspect}" }
       case method
       when AMQ::Protocol::Queue::DeclareOk then
-        @continuations.push(method)
+        # safeguard against late arrivals of responses and
+        # so on, see ruby-amqp/bunny#558
+        if can_accept_queue_declare_ok?(method)
+          @continuations.push(method)
+        else
+          if !pending_server_named_queue_declaration?
+            # this response is for an outdated/overwritten
+            # queue.declare, drop it
+            @logger.warn "Received a queue.declare-ok response for a mismatching queue (#{method.queue} instead of #{@pending_queue_declare_name}) on channel #{@id}, possibly due to concurrent channel use or a timeout, ignoring it"
+          end
+        end
       when AMQ::Protocol::Queue::DeleteOk then
         @continuations.push(method)
       when AMQ::Protocol::Queue::PurgeOk then
@@ -1545,10 +1819,18 @@ module Bunny
         if consumer = @consumers[method.consumer_tag]
           @work_pool.submit do
             begin
-              @consumers.delete(method.consumer_tag)
-              consumer.handle_cancellation(method)
+              if recovers_cancelled_consumers?
+                consumer.handle_cancellation(method)
+                @logger.info "Automatically recovering cancelled consumer #{consumer.consumer_tag} on queue #{consumer.queue_name}"
+
+                consume_with(consumer)
+              else
+                @consumers.delete(method.consumer_tag)
+                consumer.handle_cancellation(method)
+              end
             rescue Exception => e
               @logger.error "Got exception when notifying consumer #{method.consumer_tag} about cancellation!"
+              @uncaught_exception_handler.call(e, consumer) if @uncaught_exception_handler
             end
           end
         else
@@ -1588,7 +1870,7 @@ module Bunny
 
     # @private
     def channel_level_exception_after_operation_that_has_no_response?(method)
-      method.reply_code == 406 && method.reply_text =~ /unknown delivery tag/
+      method.reply_code == 406 && (method.reply_text =~ /unknown delivery tag/ || method.reply_text =~ /delivery acknowledgement on channel \d+ timed out/)
     end
 
     # @private
@@ -1607,7 +1889,11 @@ module Bunny
       consumer = @consumers[basic_deliver.consumer_tag]
       if consumer
         @work_pool.submit do
-          consumer.call(DeliveryInfo.new(basic_deliver, consumer, self), MessageProperties.new(properties), content)
+          begin
+            consumer.call(DeliveryInfo.new(basic_deliver, consumer, self), MessageProperties.new(properties), content)
+          rescue StandardError => e
+            @uncaught_exception_handler.call(e, consumer) if @uncaught_exception_handler
+          end
         end
       else
         @logger.warn "No consumer for tag #{basic_deliver.consumer_tag} on channel #{@id}!"
@@ -1625,29 +1911,29 @@ module Bunny
       end
     end
 
+    # Handle delivery tag offset calculations to keep the the delivery tag monotonic after a reset
+    # due to automatic network failure recovery. @unconfirmed_set contains indices already offsetted.
     # @private
-    def handle_ack_or_nack(delivery_tag, multiple, nack)
-      if nack
-        cloned_set = @unconfirmed_set.clone
-        if multiple
-          cloned_set.keep_if { |i| i <= delivery_tag }
-          @nacked_set.merge(cloned_set)
-        else
-          @nacked_set.add(delivery_tag)
+    def handle_ack_or_nack(delivery_tag_before_offset, multiple, nack)
+      @unconfirmed_set_mutex.synchronize do
+        delivery_tag          = delivery_tag_before_offset + @delivery_tag_offset
+        confirmed_range_start = multiple ? @unconfirmed_set.min : delivery_tag
+        confirmed_range_end   = delivery_tag
+        confirmed_range       = (confirmed_range_start..confirmed_range_end)
+
+        if nack
+          @nacked_set.merge(@unconfirmed_set & confirmed_range)
         end
-      end
 
-      if multiple
-        @unconfirmed_set.delete_if { |i| i <= delivery_tag }
-      else
-        @unconfirmed_set.delete(delivery_tag)
-      end
+        @unconfirmed_set.subtract(confirmed_range)
 
-      @unconfirmed_set_mutex.synchronize do
         @only_acks_received = (@only_acks_received && !nack)
 
         @confirms_continuations.push(true) if @unconfirmed_set.empty?
-        @confirms_callback.call(delivery_tag, multiple, nack) if @confirms_callback
+
+        if @confirms_callback
+          confirmed_range.each { |tag| @confirms_callback.call(tag, false, nack) }
+        end
       end
     end
 
@@ -1689,22 +1975,37 @@ module Bunny
 
     # @private
     def wait_on_confirms_continuations
+      raise_if_no_longer_open!
+
       if @connection.threaded
         t = Thread.current
         @threads_waiting_on_confirms_continuations << t
 
         begin
-          @confirms_continuations.poll(@connection.continuation_timeout)
+          while @unconfirmed_set_mutex.synchronize { !@unconfirmed_set.empty? }
+            @confirms_continuations.poll(@connection.continuation_timeout)
+          end
         ensure
           @threads_waiting_on_confirms_continuations.delete(t)
         end
       else
-        connection.reader_loop.run_once until @confirms_continuations.length > 0
+        unless @unconfirmed_set.empty?
+          connection.reader_loop.run_once until @confirms_continuations.length > 0
+          @confirms_continuations.pop
+        end
+      end
+    end
 
-        @confirms_continuations.pop
+    # @private
+    def read_and_reset_only_acks_received
+      @unconfirmed_set_mutex.synchronize do
+        result = @only_acks_received
+        @only_acks_received = true
+        result
       end
     end
 
+
     # Releases all continuations. Used by automatic network recovery.
     # @private
     def release_all_continuations
@@ -1750,37 +2051,37 @@ module Bunny
 
     # @private
     def deregister_queue(queue)
-      @queues.delete(queue.name)
+      @queue_mutex.synchronize { @queues.delete(queue.name) }
     end
 
     # @private
     def deregister_queue_named(name)
-      @queues.delete(name)
+      @queue_mutex.synchronize { @queues.delete(name) }
     end
 
     # @private
     def register_queue(queue)
-      @queues[queue.name] = queue
+      @queue_mutex.synchronize { @queues[queue.name] = queue }
     end
 
     # @private
     def find_queue(name)
-      @queues[name]
+      @queue_mutex.synchronize { @queues[name] }
     end
 
     # @private
     def deregister_exchange(exchange)
-      @exchanges.delete(exchange.name)
+      @exchange_mutex.synchronize { @exchanges.delete(exchange.name) }
     end
 
     # @private
     def register_exchange(exchange)
-      @exchanges[exchange.name] = exchange
+      @exchange_mutex.synchronize { @exchanges[exchange.name] = exchange }
     end
 
     # @private
     def find_exchange(name)
-      @exchanges[name]
+      @exchange_mutex.synchronize { @exchanges[name] }
     end
 
     protected
@@ -1820,7 +2121,13 @@ module Bunny
 
     # @private
     def raise_if_no_longer_open!
-      raise ChannelAlreadyClosed.new("cannot use a channel that was already closed! Channel id: #{@id}", self) if closed?
+      if closed?
+        if @last_channel_error
+          raise ChannelAlreadyClosed.new("cannot use a closed channel! Channel id: #{@id}, closed due to a server-reported channel error: #{@last_channel_error.message}", self)
+        else
+          raise ChannelAlreadyClosed.new("cannot use a closed channel! Channel id: #{@id}", self)
+        end
+      end
     end
 
     # @private
@@ -1843,24 +2150,16 @@ module Bunny
       @basic_get_continuations = new_continuation
     end
 
-
-    if defined?(JRUBY_VERSION)
-      # @private
-      def new_continuation
-        Concurrent::LinkedContinuationQueue.new
-      end
-    else
-      # @private
-      def new_continuation
-        Concurrent::ContinuationQueue.new
-      end
-    end # if defined?
+    # @private
+    def new_continuation
+      Concurrent::ContinuationQueue.new
+    end
 
     # @private
     def guarding_against_stale_delivery_tags(tag, &block)
       case tag
         # if a fixnum was passed, execute unconditionally. MK.
-      when Fixnum then
+      when Integer then
         block.call
         # versioned delivery tags should be checked to avoid
         # sending out stale (invalid) tags after channel was reopened