bunny 2.4.0 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 790cbbf1db8e302bc827c5bea5f7402246666232
-  data.tar.gz: 5db72065394300e1836777389d4cefc96f2213b2
+  metadata.gz: 6f628f0ace95911e5d5ce48817389f79a3a68415
+  data.tar.gz: a4f867d1fbe68457f311a0b3691a644c882cc1e4
 SHA512:
-  metadata.gz: a209a0ee2b9d6bb19616d647f7070dbf6834aff8faa3136e1ae452fa0aae5980c9bc4bffedb6a8f4062f92b3469580936c3c94deca3d386120543ae11f737538
-  data.tar.gz: ca0250521c37790299f627edf42db7598ddfe21d1cfd749f84745f5003c160d3c12fa52dbbb3c899aa709125f715bfe55c53697ef2bf05b0db89ec98b5ad6934
+  metadata.gz: 792e2d8e367bca866fa48af83d640b75feb401da8a10711852df09d436ca614cdf0a7c52a72fe2a890cb627991639b771cd0ed6fa3b912bc235206c00da219ec
+  data.tar.gz: 8a3fa96ab3e6103513f1df439c37f8d4ce6688c9dba2c40e7fadbec265bf1cf5e2abd438b16f7e954ff6c1479130ecc0253023c8e6d50248a199ce2a13ab8098

data/CONTRIBUTING.md

@@ -55,7 +55,7 @@ it by pressing CTRL+C.
 ### Running Test Suites
 
 Prior to running the tests, configure the RabbitMQ permissions
-by running `./bin/ci/before_script`. The script uses `rabbitmqctl` and `rabbitmq-plugins`
+by running `./bin/ci/before_build`. The script uses `rabbitmqctl` and `rabbitmq-plugins`
 to set up RabbitMQ in a way that Bunny test suites expect. Two environment variables,
 `RABBITMQCTL` and `RABBITMQ_PLUGINS`, are available to control what `rabbitmqctl` and
 `rabbitmq-plugins` commands will be used. By default they are taken from `PATH`

data/ChangeLog.md

@@ -1,4 +1,9 @@
-## Changes between Bunny 2.3.0 and 2.4.0 (unreleased)
+## Changes between Bunny 2.4.0 and 2.5.0 (unreleased)
+
+No changes yet.
+
+
+## Changes between Bunny 2.3.0 and 2.4.0 (June 11th, 2016)
 
 ### Unconfirmed Delivery Tag Set Reset on Network Recovery
 

data/lib/bunny/channel.rb

@@ -1783,6 +1783,8 @@ 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

data/lib/bunny/exchange.rb

@@ -1,3 +1,5 @@
+require 'amq/protocol'
+
 module Bunny
   # Represents AMQP 0.9.1 exchanges.
   #
@@ -80,6 +82,8 @@ module Bunny
       @internal         = @options[:internal]
       @arguments        = @options[:arguments]
 
+      @bindings         = Set.new
+
       declare! unless opts[:no_declare] || predeclared? || (@name == AMQ::Protocol::EMPTY_STRING)
 
       @channel.register_exchange(self)
@@ -169,6 +173,7 @@ module Bunny
     # @api public
     def bind(source, opts = {})
       @channel.exchange_bind(source, self, opts)
+      @bindings.add(source: source, opts: opts)
 
       self
     end
@@ -189,6 +194,7 @@ module Bunny
     # @api public
     def unbind(source, opts = {})
       @channel.exchange_unbind(source, self, opts)
+      @bindings.delete(source: source, opts: opts)
 
       self
     end
@@ -214,8 +220,11 @@ module Bunny
 
     # @private
     def recover_from_network_failure
-      # puts "Recovering exchange #{@name} from network failure"
-      declare! unless predefined?
+      declare! unless @options[:no_declare] ||predefined?
+
+      @bindings.each do |b|
+        bind(b[:source], b[:opts])
+      end
     end
 
 

data/lib/bunny/queue.rb

@@ -341,7 +341,7 @@ module Bunny
       # TODO: inject and use logger
       # puts "Recovering queue #{@name}"
       begin
-        declare!
+        declare! unless @options[:no_declare]
 
         @channel.register_queue(self)
       rescue Exception => e

data/lib/bunny/session.rb

@@ -108,6 +108,7 @@ module Bunny
     # @option connection_string_or_opts [String] :tls_key (nil) Path to client TLS/SSL private key file (.pem)
     # @option connection_string_or_opts [Array<String>] :tls_ca_certificates Array of paths to TLS/SSL CA files (.pem), by default detected from OpenSSL configuration
     # @option connection_string_or_opts [String] :verify_peer (true) Whether TLS peer verification should be performed
+    # @option connection_string_or_opts [Keyword] :tls_version (negotiated) What TLS version should be used (:TLSv1, :TLSv1_1, or :TLSv1_2)
     # @option connection_string_or_opts [Integer] :continuation_timeout (15000) Timeout for client operations that expect a response (e.g. {Bunny::Queue#get}), in milliseconds.
     # @option connection_string_or_opts [Integer] :connection_timeout (5) Timeout in seconds for connecting to the server.
     # @option connection_string_or_opts [Proc] :hosts_shuffle_strategy A Proc that reorders a list of host strings, defaults to Array#shuffle
@@ -668,30 +669,28 @@ module Bunny
 
     # @private
     def recover_from_network_failure
-      begin
-        sleep @network_recovery_interval
-        @logger.debug "About to start connection recovery..."
+      sleep @network_recovery_interval
+      @logger.debug "About to start connection recovery..."
 
-        self.initialize_transport
+      self.initialize_transport
 
-        @logger.warn "Retrying connection on next host in line: #{@transport.host}:#{@transport.port}"
-        self.start
+      @logger.warn "Retrying connection on next host in line: #{@transport.host}:#{@transport.port}"
+      self.start
 
-        if open?
-          @recovering_from_network_failure = false
+      if open?
+        @recovering_from_network_failure = false
 
-          recover_channels
-        end
-      rescue HostListDepleted
-        reset_address_index
-        retry
-      rescue TCPConnectionFailedForAllHosts, TCPConnectionFailed, AMQ::Protocol::EmptyResponseError => e
-        @logger.warn "TCP connection failed, reconnecting in #{@network_recovery_interval} seconds"
-        sleep @network_recovery_interval
-        if should_retry_recovery?
-          @recovery_attempts -= 1 if @recovery_attempts
-          retry if recoverable_network_failure?(e)
-        end
+        recover_channels
+      end
+    rescue HostListDepleted
+      reset_address_index
+      retry
+    rescue TCPConnectionFailedForAllHosts, TCPConnectionFailed, AMQ::Protocol::EmptyResponseError => e
+      @logger.warn "TCP connection failed, reconnecting in #{@network_recovery_interval} seconds"
+      sleep @network_recovery_interval
+      if should_retry_recovery?
+        @recovery_attempts -= 1 if @recovery_attempts
+        retry if recoverable_network_failure?(e)
       end
     end
 

data/lib/bunny/version.rb

@@ -2,5 +2,5 @@
 
 module Bunny
   # @return [String] Version of the library
-  VERSION = "2.4.0"
+  VERSION = "2.5.0"
 end

data/spec/higher_level_api/integration/connection_recovery_spec.rb

@@ -1,403 +1,421 @@
 require "spec_helper"
 require "rabbitmq/http/client"
 
-unless ENV["CI"]
-  describe "Connection recovery" do
-    let(:connection)  {  }
-    let(:http_client) { RabbitMQ::HTTP::Client.new("http://127.0.0.1:15672") }
-
-    def close_all_connections!
-      http_client.list_connections.each do |conn_info|
-        begin
-          http_client.close_connection(conn_info.name)
-        rescue Bunny::ConnectionForced
-          # This is not a problem, but the specs intermittently believe it is.
-        end
-      end
+describe "Connection recovery" do
+  let(:http_client) { RabbitMQ::HTTP::Client.new("http://127.0.0.1:15672") }
+  let(:logger) { Logger.new($stderr).tap {|logger| logger.level = Logger::FATAL} }
+  let(:recovery_interval) { 0.2 }
+
+  it "reconnects after grace period" do
+    with_open do |c|
+      close_all_connections!
+      wait_on_loss_and_recovery_of { connections.any? }
     end
+  end
 
-    def wait_for_recovery
-      sleep 1.5
+  it "reconnects after grace period (with multiple hosts)" do
+    with_open_multi_host do |c|
+      close_all_connections!
+      wait_on_loss_and_recovery_of { connections.any? }
     end
+  end
 
-    def with_open(c = Bunny.new(:network_recovery_interval => 0.2, :recover_from_connection_close => true), &block)
-      begin
-        c.start
-        block.call(c)
-      ensure
-        c.close
-      end
+  it "reconnects after grace period (with multiple hosts, including a broken one)" do
+    with_open_multi_broken_host do |c|
+      close_all_connections!
+      wait_on_loss_and_recovery_of { connections.any? }
     end
+  end
 
-    def with_open_multi_host( c = Bunny.new( :hosts => ["127.0.0.1", "localhost"],
-                                             :network_recovery_interval => 0.2,
-                                             :recover_from_connection_close => true), &block)
-      begin
-        c.start
-        block.call(c)
-      ensure
-        c.close
-      end
+  it "recovers channels" do
+    with_open do |c|
+      ch1 = c.create_channel
+      ch2 = c.create_channel
+      close_all_connections!
+      poll_until { channels.count.zero? }
+      poll_until { channels.count == 2 }
+      expect(ch1).to be_open
+      expect(ch2).to be_open
     end
+  end
 
-    def with_open_multi_broken_host( c = Bunny.new( :hosts => ["broken", "127.0.0.1", "localhost"],
-                                             :hosts_shuffle_strategy => Proc.new { |hosts| hosts }, # We do not shuffle for these tests so we always hit the broken host
-                                             :network_recovery_interval => 0.2,
-                                             :recover_from_connection_close => true), &block)
-      begin
-        c.start
-        block.call(c)
-      ensure
-        c.close
-      end
+  it "recovers channels (with multiple hosts)" do
+    with_open_multi_host do |c|
+      ch1 = c.create_channel
+      ch2 = c.create_channel
+      close_all_connections!
+      poll_until { channels.count.zero? }
+      poll_until { channels.count == 2 }
+      expect(ch1).to be_open
+      expect(ch2).to be_open
     end
+  end
 
-    def with_recovery_attempts_limited_to(attempts = 3, &block)
-      c = Bunny.new(:recover_from_connection_close => true, :network_recovery_interval => 0.2, :recovery_attempts => attempts)
-      begin
-        c.start
-        block.call(c)
-      ensure
-        c.close
-      end
+  it "recovers channels (with multiple hosts, including a broken one)" do
+    with_open_multi_broken_host do |c|
+      ch1 = c.create_channel
+      ch2 = c.create_channel
+      close_all_connections!
+      poll_until { channels.count.zero? }
+      poll_until { channels.count == 2 }
+      expect(ch1).to be_open
+      expect(ch2).to be_open
     end
+  end
 
-    def ensure_queue_recovery(ch, q)
-      ch.confirm_select
-      q.purge
-      x = ch.default_exchange
-      x.publish("msg", :routing_key => q.name)
-      ch.wait_for_confirms
-      sleep 0.5
-      expect(q.message_count).to eq 1
-      q.purge
+  it "recovers basic.qos prefetch setting" do
+    with_open do |c|
+      ch = c.create_channel
+      ch.prefetch(11)
+      expect(ch.prefetch_count).to eq 11
+      expect(ch.prefetch_global).to be false
+      close_all_connections!
+      wait_on_loss_and_recovery_of { connections.any? }
+      expect(ch).to be_open
+      expect(ch.prefetch_count).to eq 11
+      expect(ch.prefetch_global).to be false
     end
+  end
 
-    def ensure_queue_binding_recovery(ch, x, q, routing_key = "")
-      ch.confirm_select
-      q.purge
-      x.publish("msg", :routing_key => routing_key)
-      ch.wait_for_confirms
-      sleep 0.5
-      expect(q.message_count).to eq 1
-      q.purge
+  it "recovers basic.qos prefetch global setting" do
+    with_open do |c|
+      ch = c.create_channel
+      ch.prefetch(42, true)
+      expect(ch.prefetch_count).to eq 42
+      expect(ch.prefetch_global).to be true
+      close_all_connections!
+      wait_on_loss_and_recovery_of { connections.any? }
+      expect(ch).to be_open
+      expect(ch.prefetch_count).to eq 42
+      expect(ch.prefetch_global).to be true
     end
+  end
 
-    def ensure_exchange_binding_recovery(ch, source, destination, routing_key = "")
+  it "recovers publisher confirms setting" do
+    with_open do |c|
+      ch = c.create_channel
       ch.confirm_select
-      q  = ch.queue("", :exclusive => true)
-      q.bind(destination, :routing_key => routing_key)
+      expect(ch).to be_using_publisher_confirms
+      close_all_connections!
+      wait_on_loss_and_recovery_of { connections.any? }
+      expect(ch).to be_open
+      expect(ch).to be_using_publisher_confirms
+    end
+  end
 
-      source.publish("msg", :routing_key => routing_key)
-      ch.wait_for_confirms
-      sleep 0.5
-      expect(q.message_count).to eq 1
-      q.delete
+  it "recovers transactionality setting" do
+    with_open do |c|
+      ch = c.create_channel
+      ch.tx_select
+      expect(ch).to be_using_tx
+      close_all_connections!
+      wait_on_loss_and_recovery_of { connections.any? }
+      expect(ch).to be_open
+      expect(ch).to be_using_tx
     end
+  end
 
-    #
-    # Examples
-    #
+  it "recovers client-named queues" do
+    with_open do |c|
+      ch = c.create_channel
+      q  = ch.queue("bunny.tests.recovery.client-named#{rand}")
+      close_all_connections!
+      wait_on_loss_and_recovery_of { connections.any? }
+      expect(ch).to be_open
+      ensure_queue_recovery(ch, q)
+      q.delete
+    end
+  end
 
-    it "reconnects after grace period" do
-      with_open do |c|
-        close_all_connections!
-        sleep 0.1
-        expect(c).not_to be_open
+  # a very simplistic test for queues inspired by #412
+  it "recovers client-named queues declared with passive = true" do
+    with_open do |c|
+      ch  = c.create_channel
+      ch2 = c.create_channel
 
-        wait_for_recovery
-        expect(c).to be_open
-      end
-    end
+      n   = rand
+      s   = "bunny.tests.recovery.client-named#{n}"
 
-    it "reconnects after grace period (with multiple hosts)" do
-      with_open_multi_host do |c|
-        close_all_connections!
-        sleep 0.1
-        expect(c).not_to be_open
+      q   = ch.queue(s)
+      q2  = ch2.queue(s, no_declare: true)
 
-        wait_for_recovery
-        expect(c).to be_open
-      end
+      close_all_connections!
+      wait_on_loss_and_recovery_of { connections.any? }
+      expect(ch).to be_open
+      ensure_queue_recovery(ch, q)
+      q.delete
     end
+  end
 
-    it "reconnects after grace period (with multiple hosts, including a broken one)" do
-      with_open_multi_broken_host do |c|
-        close_all_connections!
-        sleep 0.1
-        expect(c).not_to be_open
 
-        wait_for_recovery
-        expect(c).to be_open
-      end
+  it "recovers server-named queues" do
+    with_open do |c|
+      ch = c.create_channel
+      q  = ch.queue("", :exclusive => true)
+      close_all_connections!
+      wait_on_loss_and_recovery_of { connections.any? }
+      expect(ch).to be_open
+      ensure_queue_recovery(ch, q)
     end
+  end
 
-    it "recovers channels" do
-      with_open do |c|
-        ch1 = c.create_channel
-        ch2 = c.create_channel
-        close_all_connections!
-        sleep 0.1
-        expect(c).not_to be_open
-
-        wait_for_recovery
-        expect(ch1).to be_open
-        expect(ch2).to be_open
-      end
+  it "recovers queue bindings" do
+    with_open do |c|
+      ch = c.create_channel
+      x  = ch.fanout("amq.fanout")
+      q  = ch.queue("", :exclusive => true)
+      q.bind(x)
+      close_all_connections!
+      wait_on_loss_and_recovery_of { connections.any? }
+      expect(ch).to be_open
+      ensure_queue_binding_recovery(ch, x, q)
     end
+  end
 
-    it "recovers channels (with multiple hosts)" do
-      with_open_multi_host do |c|
-        ch1 = c.create_channel
-        ch2 = c.create_channel
-        close_all_connections!
-        sleep 0.1
-        expect(c).not_to be_open
-
-        wait_for_recovery
-        expect(ch1).to be_open
-        expect(ch2).to be_open
-      end
-    end
+  it "recovers exchanges and their bindings" do
+    with_open do |c|
+      ch          = c.create_channel
+      source      = ch.fanout("source.exchange.recovery.example", auto_delete: true)
+      destination = ch.fanout("destination.exchange.recovery.example", auto_delete: true)
 
-    it "recovers channels (with multiple hosts, including a broken one)" do
-      with_open_multi_broken_host do |c|
-        ch1 = c.create_channel
-        ch2 = c.create_channel
-        close_all_connections!
-        sleep 0.1
-        expect(c).not_to be_open
-
-        wait_for_recovery
-        expect(ch1).to be_open
-        expect(ch2).to be_open
-      end
-    end
+      destination.bind(source)
 
-    it "recovers basic.qos prefetch setting" do
-      with_open do |c|
-        ch = c.create_channel
-        ch.prefetch(11)
-        expect(ch.prefetch_count).to eq 11
-        expect(ch.prefetch_global).to be false
-        close_all_connections!
-        sleep 0.1
-        expect(c).not_to be_open
-
-        wait_for_recovery
-        expect(ch).to be_open
-        expect(ch.prefetch_count).to eq 11
-        expect(ch.prefetch_global).to be false
-      end
-    end
+      # Exchanges won't get auto-deleted on connection loss unless they have
+      # had an exclusive queue bound to them.
+      dst_queue   = ch.queue("", exclusive: true)
+      dst_queue.bind(destination, routing_key: "")
 
-    it "recovers basic.qos prefetch global setting" do
-      with_open do |c|
-        ch = c.create_channel
-        ch.prefetch(42, true)
-        expect(ch.prefetch_count).to eq 42
-        expect(ch.prefetch_global).to be true
-        close_all_connections!
-        sleep 0.1
-        expect(c).not_to be_open
-
-        wait_for_recovery
-        expect(ch).to be_open
-        expect(ch.prefetch_count).to eq 42
-        expect(ch.prefetch_global).to be true
-      end
+      src_queue   = ch.queue("", exclusive: true)
+      src_queue.bind(source, routing_key: "")
+
+      close_all_connections!
+
+      wait_on_loss_and_recovery_of { exchange_names_in_vhost("/").include?(source.name) }
+
+      ch.confirm_select
+
+      source.publish("msg", routing_key: "")
+      ch.wait_for_confirms
+      expect(dst_queue.message_count).to eq 1
     end
+  end
 
-    it "recovers publisher confirms setting" do
-      with_open do |c|
-        ch = c.create_channel
-        ch.confirm_select
-        expect(ch).to be_using_publisher_confirms
-        close_all_connections!
-        sleep 0.1
-        expect(c).not_to be_open
-
-        wait_for_recovery
-        expect(ch).to be_open
-        expect(ch).to be_using_publisher_confirms
-      end
+  # this is a simplistic test that primarily execises the code path from #412
+  it "recovers exchanges that were declared with passive = true" do
+    with_open do |c|
+      ch          = c.create_channel
+      ch2         = c.create_channel
+      source      = ch.fanout("source.exchange.recovery.example", auto_delete: true)
+      destination = ch.fanout("destination.exchange.recovery.example", auto_delete: true)
+
+      source2      = ch2.fanout("source.exchange.recovery.example", no_declare: true)
+      destination2 = ch2.fanout("destination.exchange.recovery.example", no_declare: true)
+
+      destination.bind(source)
+
+      # Exchanges won't get auto-deleted on connection loss unless they have
+      # had an exclusive queue bound to them.
+      dst_queue   = ch.queue("", exclusive: true)
+      dst_queue.bind(destination, routing_key: "")
+
+      src_queue   = ch.queue("", exclusive: true)
+      src_queue.bind(source, routing_key: "")
+
+      close_all_connections!
+
+      wait_on_loss_and_recovery_of { exchange_names_in_vhost("/").include?(source.name) }
+
+      ch2.confirm_select
+
+      source2.publish("msg", routing_key: "")
+      ch2.wait_for_confirms
+      expect(dst_queue.message_count).to eq 1
     end
+  end
 
-    it "recovers transactionality setting" do
-      with_open do |c|
-        ch = c.create_channel
-        ch.tx_select
-        expect(ch).to be_using_tx
-        close_all_connections!
-        sleep 0.1
-        expect(c).not_to be_open
-
-        wait_for_recovery
-        expect(ch).to be_open
-        expect(ch).to be_using_tx
-      end
+  it "recovers allocated channel ids" do
+    with_open do |c|
+      q = "queue#{Time.now.to_i}"
+      10.times { c.create_channel }
+      expect(c.queue_exists?(q)).to eq false
+      close_all_connections!
+      wait_on_loss_and_recovery_of { channels.any? }
+      # make sure the connection isn't closed shortly after
+      # due to "second 'channel.open' seen". MK.
+      expect(c).to be_open
+      sleep 0.1
+      expect(c).to be_open
+      sleep 0.1
+      expect(c).to be_open
     end
+  end
+
+  it "recovers consumers" do
+    with_open do |c|
+      delivered = false
 
-    it "recovers client-named queues" do
-      with_open do |c|
-        ch = c.create_channel
-        q  = ch.queue("bunny.tests.recovery.client-named#{rand}")
-        close_all_connections!
-        sleep 0.1
-        expect(c).not_to be_open
-
-        wait_for_recovery
-        expect(ch).to be_open
-        ensure_queue_recovery(ch, q)
-        q.delete
+      ch = c.create_channel
+      q  = ch.queue("", :exclusive => true)
+      q.subscribe do |_, _, _|
+        delivered = true
       end
+      close_all_connections!
+      wait_on_loss_and_recovery_of { connections.any? }
+      expect(ch).to be_open
+
+      q.publish("")
+
+      poll_until { delivered }
     end
+  end
 
+  it "recovers all consumers" do
+    n = 1024
 
-    it "recovers server-named queues" do
-      with_open do |c|
-        ch = c.create_channel
-        q  = ch.queue("", :exclusive => true)
-        close_all_connections!
-        sleep 0.1
-        expect(c).not_to be_open
+    with_open do |c|
+      ch = c.create_channel
+      q  = ch.queue("", :exclusive => true)
+      n.times { q.subscribe { |_, _, _| } }
+      close_all_connections!
+      wait_on_loss_and_recovery_of { connections.any? }
+      expect(ch).to be_open
+      sleep 0.5
 
-        wait_for_recovery
-        expect(ch).to be_open
-        ensure_queue_recovery(ch, q)
-      end
+      expect(q.consumer_count).to eq n
     end
+  end
 
-    it "recovers queue bindings" do
-      with_open do |c|
-        ch = c.create_channel
-        x  = ch.fanout("amq.fanout")
-        q  = ch.queue("", :exclusive => true)
-        q.bind(x)
-        close_all_connections!
-        sleep 0.1
-        expect(c).not_to be_open
-
-        wait_for_recovery
-        expect(ch).to be_open
-        ensure_queue_binding_recovery(ch, x, q)
-      end
-    end
+  it "recovers all queues" do
+    n = 256
 
-    it "recovers exchange bindings" do
-      with_open do |c|
-        ch = c.create_channel
-        x  = ch.fanout("amq.fanout")
-        x2 = ch.fanout("bunny.tests.recovery.fanout")
-        x2.bind(x)
-        close_all_connections!
-        sleep 0.1
-        expect(c).not_to be_open
-
-        wait_for_recovery
-        expect(ch).to be_open
-        ensure_exchange_binding_recovery(ch, x, x2)
+    qs = []
+
+    with_open do |c|
+      ch = c.create_channel
+
+      n.times do
+        qs << ch.queue("", :exclusive => true)
       end
-    end
+      close_all_connections!
+      wait_on_loss_and_recovery_of { queue_names.include?(qs.first.name) }
+      sleep 0.5
+      expect(ch).to be_open
 
-    it "recovers allocated channel ids" do
-      with_open do |c|
-        q = "queue#{Time.now.to_i}"
-        10.times { c.create_channel }
-        expect(c.queue_exists?(q)).to eq false
-        close_all_connections!
-        sleep 0.1
-        expect(c).not_to be_open
-
-        wait_for_recovery
-        expect(c.queue_exists?(q)).to eq false
-        # make sure the connection isn't closed shortly after
-        # due to "second 'channel.open' seen". MK.
-        expect(c).to be_open
-        sleep 0.1
-        expect(c).to be_open
-        sleep 0.1
-        expect(c).to be_open
+      qs.each do |q|
+        ch.queue_declare(q.name, :passive => true)
       end
     end
+  end
 
-    it "recovers consumers" do
-      with_open do |c|
-        delivered = false
-
-        ch = c.create_channel
-        q  = ch.queue("", :exclusive => true)
-        q.subscribe do |_, _, _|
-          delivered = true
-        end
-        close_all_connections!
-        sleep 0.1
-        expect(c).not_to be_open
-
-        wait_for_recovery
-        expect(ch).to be_open
-
-        q.publish("")
-        sleep 0.5
-        expect(delivered).to eq true
-      end
+  it "tries to recover for a given number of attempts" do
+    pending "Need a fix for https://github.com/ruby-amqp/bunny/issues/408"
+    with_recovery_attempts_limited_to(2) do |c|
+      close_all_connections!
+      wait_on_loss_and_recovery_of { connections.any? }
+
+      close_all_connections!
+      wait_on_loss_and_recovery_of { connections.any? }
+
+      close_all_connections!
+      sleep(recovery_interval + 0.5)
+      expect(connections).to be_empty
     end
+  end
 
-    it "recovers all consumers" do
-      n = 1024
-
-      with_open do |c|
-        ch = c.create_channel
-        q  = ch.queue("", :exclusive => true)
-        n.times do
-          q.subscribe do |_, _, _|
-            delivered = true
-          end
-        end
-        close_all_connections!
-        sleep 0.1
-        expect(c).not_to be_open
-
-        wait_for_recovery
-        sleep 1
-        expect(ch).to be_open
-
-        expect(q.consumer_count).to eq n
-      end
+  def exchange_names_in_vhost(vhost)
+    http_client.list_exchanges(vhost).map {|e| e["name"]}
+  end
+
+  def connections
+    http_client.list_connections
+  end
+
+  def channels
+    http_client.list_channels
+  end
+
+  def queue_names
+    http_client.list_queues.map {|q| q["name"]}
+  end
+
+  def close_all_connections!
+    connections.each do |conn_info|
+      close_ignoring_permitted_exceptions(conn_info.name)
     end
+  end
 
-    it "recovers all queues" do
-      n = 256
+  def close_ignoring_permitted_exceptions(connection_name)
+    http_client.close_connection(connection_name)
+  rescue Bunny::ConnectionForced
+  end
 
-      qs = []
+  def wait_on_loss_and_recovery_of(&probe)
+    poll_while &probe
+    poll_until &probe
+  end
 
-      with_open do |c|
-        ch = c.create_channel
+  def poll_while(&probe)
+    Timeout::timeout(10) {
+      sleep 0.1 while probe[]
+    }
+  end
 
-        n.times do
-          qs << ch.queue("", :exclusive => true)
-        end
-        close_all_connections!
-        sleep 0.1
-        expect(c).not_to be_open
+  def poll_until(&probe)
+    Timeout::timeout(10) {
+      sleep 0.1 until probe[]
+    }
+  end
 
-        wait_for_recovery
-        sleep 1
-        expect(ch).to be_open
+  def with_open(c = Bunny.new(network_recovery_interval: recovery_interval,
+                              recover_from_connection_close: true,
+                              logger: logger), &block)
+    c.start
+    block.call(c)
+  ensure
+    c.close
+  end
 
-        qs.each do |q|
-          ch.queue_declare(q.name, :passive => true)
-        end
-      end
-    end
+  def with_open_multi_host(&block)
+    c = Bunny.new(hosts: ["127.0.0.1", "localhost"],
+                  network_recovery_interval: recovery_interval,
+                  recover_from_connection_close: true,
+                  logger: logger)
+    with_open(c, &block)
+  end
 
-    it "tries to recover for a given number of attempts" do
-      with_recovery_attempts_limited_to(2) do |c|
-        close_all_connections!
-        expect(c).to receive(:start).exactly(2).times.and_raise(Bunny::TCPConnectionFailed.new("test"))
+  def with_open_multi_broken_host(&block)
+    c = Bunny.new(hosts: ["broken", "127.0.0.1", "localhost"],
+                  hosts_shuffle_strategy: Proc.new { |hosts| hosts }, # We do not shuffle for these tests so we always hit the broken host
+                  network_recovery_interval: recovery_interval,
+                  recover_from_connection_close: true,
+                  logger: logger)
+    with_open(c, &block)
+  end
 
-        wait_for_recovery
-      end
-    end
+  def with_recovery_attempts_limited_to(attempts = 3, &block)
+    c = Bunny.new(recover_from_connection_close: true,
+                  network_recovery_interval: recovery_interval,
+                  recovery_attempts: attempts,
+                  logger: logger)
+    with_open(c, &block)
+  end
+
+  def ensure_queue_recovery(ch, q)
+    ch.confirm_select
+    q.purge
+    x = ch.default_exchange
+    x.publish("msg", routing_key: q.name)
+    ch.wait_for_confirms
+    expect(q.message_count).to eq 1
+    q.purge
+  end
+
+  def ensure_queue_binding_recovery(ch, x, q, routing_key = "")
+    ch.confirm_select
+    q.purge
+    x.publish("msg", routing_key: routing_key)
+    ch.wait_for_confirms
+    expect(q.message_count).to eq 1
+    q.purge
   end
 end

data/spec/higher_level_api/integration/publisher_confirms_spec.rb

@@ -60,6 +60,18 @@ describe Bunny::Channel do
           }.not_to raise_error
 
         end
+
+        it "raises an error when called on a closed channel" do
+          ch = connection.create_channel
+
+          ch.confirm_select
+
+          ch.close
+
+          expect {
+            ch.wait_for_confirms
+          }.to raise_error(Bunny::ChannelAlreadyClosed)
+        end
       end
 
       context "when some of the messages get nacked" do

data/spec/unit/exchange_recovery_spec.rb

@@ -0,0 +1,39 @@
+require_relative '../../lib/bunny/channel'
+require_relative '../../lib/bunny/exchange'
+
+module Bunny
+  describe Exchange do
+    context "recovery" do
+      it "recovers exchange bindings, unless already unbound" do
+        ch = instance_double(Bunny::Channel,
+                             exchange_declare: nil,
+                             register_exchange: nil)
+        src1 = Exchange.new(ch, "direct", "src1")
+        src2 = Exchange.new(ch, "direct", "src2")
+        src3 = Exchange.new(ch, "direct", "src3")
+        dst = Exchange.new(ch, "direct", "dst")
+
+        original_binds_count = 5
+        expected_rebinds_count = 3
+        expected_total_binds = original_binds_count + expected_rebinds_count
+        allow(ch).to receive(:exchange_bind).exactly(expected_total_binds).times
+
+        dst.bind(src1, routing_key: "abc")
+        dst.bind(src2, routing_key: "def")
+        dst.bind(src2, routing_key: "ghi")
+        dst.bind(src3, routing_key: "jkl")
+        dst.bind(src3, routing_key: "jkl", arguments: {"key" => "value"})
+
+        allow(ch).to receive(:exchange_unbind).twice
+        dst.unbind(src2, routing_key: "def")
+        dst.unbind(src3, routing_key: "jkl", arguments: {"key" => "value"})
+
+        expect(ch).to receive(:exchange_bind).with(src1, dst, routing_key: "abc")
+        expect(ch).to receive(:exchange_bind).with(src2, dst, routing_key: "ghi")
+        expect(ch).to receive(:exchange_bind).with(src3, dst, routing_key: "jkl")
+
+        dst.recover_from_network_failure
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bunny
 version: !ruby/object:Gem::Version
-  version: 2.4.0
+  version: 2.5.0
 platform: ruby
 authors:
 - Chris Duncan
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-11 00:00:00.000000000 Z
+date: 2016-07-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: amq-protocol
@@ -150,7 +150,6 @@ files:
 - spec/higher_level_api/integration/basic_return_spec.rb
 - spec/higher_level_api/integration/channel_close_spec.rb
 - spec/higher_level_api/integration/channel_open_spec.rb
-- spec/higher_level_api/integration/confirm_select_spec.rb
 - spec/higher_level_api/integration/connection_recovery_spec.rb
 - spec/higher_level_api/integration/connection_spec.rb
 - spec/higher_level_api/integration/connection_stop_spec.rb
@@ -209,6 +208,7 @@ files:
 - spec/unit/concurrent/condition_spec.rb
 - spec/unit/concurrent/linked_continuation_queue_spec.rb
 - spec/unit/concurrent/synchronized_sorted_set_spec.rb
+- spec/unit/exchange_recovery_spec.rb
 - spec/unit/version_delivery_tag_spec.rb
 homepage: http://rubybunny.info
 licenses:
@@ -230,7 +230,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Popular easy to use Ruby client for RabbitMQ
@@ -250,7 +250,6 @@ test_files:
 - spec/higher_level_api/integration/basic_return_spec.rb
 - spec/higher_level_api/integration/channel_close_spec.rb
 - spec/higher_level_api/integration/channel_open_spec.rb
-- spec/higher_level_api/integration/confirm_select_spec.rb
 - spec/higher_level_api/integration/connection_recovery_spec.rb
 - spec/higher_level_api/integration/connection_spec.rb
 - spec/higher_level_api/integration/connection_stop_spec.rb
@@ -309,5 +308,6 @@ test_files:
 - spec/unit/concurrent/condition_spec.rb
 - spec/unit/concurrent/linked_continuation_queue_spec.rb
 - spec/unit/concurrent/synchronized_sorted_set_spec.rb
+- spec/unit/exchange_recovery_spec.rb
 - spec/unit/version_delivery_tag_spec.rb
 has_rdoc: true

data/spec/higher_level_api/integration/confirm_select_spec.rb

@@ -1,19 +0,0 @@
-require "spec_helper"
-
-describe Bunny::Channel, "#confirm_select" 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 "is supported" do
-    connection.with_channel do |ch|
-      ch.confirm_select
-    end
-  end
-end