bunny 3.1.0 → 3.3.0

data/lib/bunny/queue.rb

@@ -91,8 +91,9 @@ module Bunny
 
       # for basic.deliver dispatch and such
       @channel.register_queue(self)
-      # for topology recovery
-      @channel.record_queue(self)
+      # for topology recovery. A passive declaration does not own the queue,
+      # so it must not overwrite what was recorded for it earlier
+      @channel.record_queue(self) unless @options[:passive]
     end
 
     # @return [Boolean] true if this queue was declared as durable (will survive broker restart).
@@ -159,7 +160,7 @@ module Bunny
     def bind(exchange, opts = {})
       @channel.queue_bind(@name, exchange, opts)
 
-      exchange_name = if exchange.respond_to?(:name)
+      exchange_name = if exchange.is_a?(Bunny::Exchange)
                         exchange.name
                       else
                         exchange
@@ -168,7 +169,7 @@ module Bunny
 
       # store bindings for automatic recovery. We need to be very careful to
       # not cause an infinite rebinding loop here when we recover. MK.
-      binding = { :exchange => exchange_name, :routing_key => (opts[:routing_key] || opts[:key]), :arguments => opts[:arguments] }
+      binding = { exchange: exchange_name, routing_key: (opts[:routing_key] || opts[:key]), arguments: opts[:arguments] }
       @bindings.push(binding) unless @bindings.include?(binding)
 
       self
@@ -188,7 +189,7 @@ module Bunny
     def unbind(exchange, opts = {})
       @channel.queue_unbind(@name, exchange, opts)
 
-      exchange_name = if exchange.respond_to?(:name)
+      exchange_name = if exchange.is_a?(Bunny::Exchange)
                         exchange.name
                       else
                         exchange
@@ -214,11 +215,11 @@ module Bunny
     # @see http://rubybunny.info/articles/queues.html Queues and Consumers guide
     # @api public
     def subscribe(opts = {
-                    :consumer_tag    => @channel.generate_consumer_tag,
-                    :manual_ack      => false,
-                    :exclusive       => false,
-                    :block           => false,
-                    :on_cancellation => nil
+                    consumer_tag:    @channel.generate_consumer_tag,
+                    manual_ack:      false,
+                    exclusive:       false,
+                    block:           false,
+                    on_cancellation: nil
                   }, &block)
 
       unless opts[:ack].nil?
@@ -256,7 +257,7 @@ module Bunny
     #
     # @see http://rubybunny.info/articles/queues.html Queues and Consumers guide
     # @api public
-    def subscribe_with(consumer, opts = {:block => false})
+    def subscribe_with(consumer, opts = { block: false })
       @channel.basic_consume_with(consumer)
 
       @channel.work_pool.join if opts[:block]
@@ -281,13 +282,13 @@ module Bunny
     #   ch   = conn.create_channel
     #   q = ch.queue("test1")
     #   x = ch.default_exchange
-    #   x.publish("Hello, everybody!", :routing_key => 'test1')
+    #   x.publish("Hello, everybody!", routing_key: 'test1')
     #
     #   delivery_info, properties, payload = q.pop
     #
     #   puts "This is the message: " + payload + "\n\n"
     #   conn.close
-    def pop(opts = {:manual_ack => false}, &block)
+    def pop(opts = { manual_ack: false }, &block)
       unless opts[:ack].nil?
         warn "[DEPRECATION] `:ack` is deprecated.  Please use `:manual_ack` instead."
         opts[:manual_ack] = opts[:ack]
@@ -323,7 +324,7 @@ module Bunny
     # @see Bunny::Channel#default_exchange
     # @see http://rubybunny.info/articles/exchanges.html Exchanges and Publishing guide
     def publish(payload, opts = {})
-      @channel.default_exchange.publish(payload, opts.merge(:routing_key => @name))
+      @channel.default_exchange.publish(payload, opts.merge(routing_key: @name))
 
       self
     end
@@ -357,9 +358,9 @@ module Bunny
     # @see #message_count
     # @see #consumer_count
     def status
-      queue_declare_ok = @channel.queue_declare(@name, @options.merge(:passive => true))
-      {:message_count => queue_declare_ok.message_count,
-        :consumer_count => queue_declare_ok.consumer_count}
+      queue_declare_ok = @channel.queue_declare(@name, @options.merge(passive: true))
+      { message_count: queue_declare_ok.message_count,
+        consumer_count: queue_declare_ok.consumer_count }
     end
 
     # @return [Integer] How many messages the queue has ready (e.g. not delivered but not unacknowledged)
@@ -378,8 +379,8 @@ module Bunny
       # be extra defensive
       args = args0 || {}
       q_type = args["x-queue-type"] || args[:"x-queue-type"]
-      throw ArgumentError.new(
-        "unsupported queue type #{q_type.inspect}, supported ones: #{Types::KNOWN.join(', ')}") if (q_type and !Types.known?(q_type))
+      raise ArgumentError,
+        "unsupported queue type #{q_type.inspect}, supported ones: #{Types::KNOWN.join(', ')}" if (q_type and !Types.known?(q_type))
     end
 
     #
@@ -397,15 +398,15 @@ module Bunny
     # @private
     def self.add_default_options(name, opts)
       # :nowait is always false for Bunny
-      h = { :queue => name, :nowait => false }.merge(opts)
+      h = { queue: name, nowait: false }.merge(opts)
 
       if name.empty?
         {
-          :passive     => false,
-          :durable     => false,
-          :exclusive   => false,
-          :auto_delete => false,
-          :arguments   => nil
+          passive:     false,
+          durable:     false,
+          exclusive:   false,
+          auto_delete: false,
+          arguments:   nil
         }.merge(h)
       else
         h

data/lib/bunny/reader_loop.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "thread"
-
 module Bunny
   # Network activity loop that reads and passes incoming AMQP 0.9.1 methods for
   # processing. They are dispatched further down the line in Bunny::Session and Bunny::Channel.

data/lib/bunny/return_info.rb

@@ -41,10 +41,10 @@ module Bunny
     # @return [Hash] Hash representation of this returned delivery info
     def to_hash
       @hash ||= {
-        :reply_code   => @basic_return.reply_code,
-        :reply_text   => @basic_return.reply_text,
-        :exchange     => @basic_return.exchange,
-        :routing_key  => @basic_return.routing_key
+        reply_code:   @basic_return.reply_code,
+        reply_text:   @basic_return.reply_text,
+        exchange:     @basic_return.exchange,
+        routing_key:  @basic_return.routing_key
       }
     end
 

data/lib/bunny/session.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 require "socket"
-require "thread"
-require "monitor"
 
 require "bunny/transport"
 require "bunny/channel_id_allocator"
@@ -51,19 +49,19 @@ module Bunny
 
     # RabbitMQ client metadata
     DEFAULT_CLIENT_PROPERTIES = {
-      :capabilities => {
-        :publisher_confirms           => true,
-        :consumer_cancel_notify       => true,
-        :exchange_exchange_bindings   => true,
+      capabilities: {
+        publisher_confirms:           true,
+        consumer_cancel_notify:       true,
+        exchange_exchange_bindings:   true,
         :"basic.nack"                 => true,
         :"connection.blocked"         => true,
         # See http://www.rabbitmq.com/auth-notification.html
-        :authentication_failure_close => true
+        authentication_failure_close: true
       },
-      :product      => "Bunny",
-      :platform     => ::RUBY_DESCRIPTION,
-      :version      => Bunny::VERSION,
-      :information  => "https://github.com/ruby-amqp/bunny",
+      product:     "Bunny",
+      platform:    ::RUBY_DESCRIPTION,
+      version:     Bunny::VERSION,
+      information: "https://github.com/ruby-amqp/bunny",
     }
 
     # @private
@@ -225,6 +223,7 @@ module Bunny
       @transport_mutex     = @mutex_impl.new
       @status_mutex        = @mutex_impl.new
       @address_index_mutex = @mutex_impl.new
+      @recovery_mutex      = @mutex_impl.new
 
       @channels            = Hash.new
 
@@ -341,6 +340,10 @@ module Bunny
             @transport.connect
           end
 
+          if @transport.read_timeout.nil?
+            @transport.read_timeout = @transport.connect_timeout || Transport::DEFAULT_READ_TIMEOUT
+          end
+
           self.init_connection
           self.open_connection
 
@@ -577,7 +580,7 @@ module Bunny
     def queue_exists?(name)
       ch = create_channel
       begin
-        ch.queue(name, :passive => true)
+        ch.queue(name, passive: true)
         true
       rescue Bunny::ResourceLocked => _
         true
@@ -599,7 +602,7 @@ module Bunny
     def exchange_exists?(name)
       ch = create_channel
       begin
-        ch.exchange(name, :passive => true)
+        ch.exchange(name, passive: true)
         true
       rescue Bunny::NotFound => _
         false
@@ -786,16 +789,18 @@ module Bunny
     # @private
     def handle_frameset(ch_number, frames)
       method = frames.first
+      ch = find_channel(ch_number)
+
+      unless ch
+        @logger.warn "Channel #{ch_number} is not open on this connection!"
+        return
+      end
 
       case method
-      when AMQ::Protocol::Basic::GetOk then
-        @channels[ch_number].handle_basic_get_ok(*frames)
-      when AMQ::Protocol::Basic::GetEmpty then
-        @channels[ch_number].handle_basic_get_empty(*frames)
-      when AMQ::Protocol::Basic::Return then
-        @channels[ch_number].handle_basic_return(*frames)
-      else
-        @channels[ch_number].handle_frameset(*frames)
+      when AMQ::Protocol::Basic::GetOk    then ch.handle_basic_get_ok(*frames)
+      when AMQ::Protocol::Basic::GetEmpty then ch.handle_basic_get_empty(*frames)
+      when AMQ::Protocol::Basic::Return   then ch.handle_basic_return(*frames)
+      else                                     ch.handle_frameset(*frames)
       end
     end
 
@@ -810,30 +815,51 @@ module Bunny
 
       @status_mutex.synchronize { @status = :disconnected }
 
-      if !recovering_from_network_failure?
-        begin
+      acquired = @recovery_mutex.synchronize do
+        if @recovering_from_network_failure
+          false
+        else
           @recovering_from_network_failure = true
-          if recoverable_network_failure?(exception)
-            announce_network_failure_recovery
-            @channel_mutex.synchronize do
-              @channels.each do |n, ch|
-                ch.connection_closed!
-                ch.maybe_kill_consumer_work_pool!
-              end
+        end
+      end
+      return unless acquired
+
+      begin
+        if recoverable_network_failure?(exception)
+          announce_network_failure_recovery
+          @channel_mutex.synchronize do
+            @channels.each do |n, ch|
+              ch.connection_closed!
+              ch.maybe_kill_consumer_work_pool!
             end
-            @reader_loop.stop if @reader_loop
-            maybe_shutdown_heartbeat_sender
+          end
+          @reader_loop.stop if @reader_loop
+          maybe_shutdown_heartbeat_sender
+
+          loop do
+            break unless recover_connection_and_channels
 
-            recover_connection_and_channels
             recover_topology
-            mark_channels_after_recovery!
-            notify_of_recovery_completion
-          else
-            @logger.error "Exception #{exception.message} is considered unrecoverable..."
+
+            if open?
+              mark_channels_after_recovery!
+              notify_of_recovery_completion
+              break
+            end
+
+            if should_retry_recovery?
+              decrement_recovery_attemp_counter!
+              announce_network_failure_recovery
+            else
+              give_up_on_recovery
+              break
+            end
           end
-        ensure
-          @recovering_from_network_failure = false
+        else
+          @logger.error "Exception #{exception.message} is considered unrecoverable..."
         end
+      ensure
+        @recovery_mutex.synchronize { @recovering_from_network_failure = false }
       end
     end
 
@@ -846,7 +872,7 @@ module Bunny
     # @return [Boolean]
     # @private
     def recovering_from_network_failure?
-      @recovering_from_network_failure
+      @recovery_mutex.synchronize { @recovering_from_network_failure }
     end
 
     # @param [Bunny::Queue] queue
@@ -987,7 +1013,6 @@ module Bunny
       self.start
 
       if open?
-        @recovering_from_network_failure = false
         @logger.debug "Connection is now open"
         if @reset_recovery_attempt_counter_after_reconnection
           @logger.debug "Resetting recovery attempt counter after successful reconnection"
@@ -997,6 +1022,9 @@ module Bunny
         end
 
         recover_channels
+        true
+      else
+        raise TCPConnectionFailed.new("connection is not open after a connection recovery attempt", @transport.host, @transport.port)
       end
     rescue HostListDepleted
       reset_address_index
@@ -1010,17 +1038,23 @@ module Bunny
           announce_network_failure_recovery
           retry
         else
-          @logger.error "Ran out of recovery attempts (limit set to #{@max_recovery_attempts}), giving up"
-          @transport.close
-          self.close(false)
-          @manually_closed = false
-          notify_of_recovery_attempts_exhausted
+          give_up_on_recovery
+          false
         end
       else
         raise e
       end
     end
 
+    # @private
+    def give_up_on_recovery
+      @logger.error "Ran out of recovery attempts (limit set to #{@max_recovery_attempts}), giving up"
+      @transport.close
+      self.close(false)
+      @manually_closed = false
+      notify_of_recovery_attempts_exhausted
+    end
+
     # @private
     def recovery_attempts_limited?
       !!@max_recovery_attempts
@@ -1091,7 +1125,7 @@ module Bunny
       exchanges.each do |x|
         begin
           recover_exchange(x)
-        rescue Exception => e
+        rescue ::StandardError => e
           @logger.error "Caught an exception while recovering exchange #{x.name}: #{e.inspect}"
         end
       end
@@ -1100,7 +1134,7 @@ module Bunny
       queues.each do |q|
         begin
           recover_queue(q)
-        rescue Exception => e
+        rescue ::StandardError => e
           @logger.error "Caught an exception while recovering queue #{q.name}: #{e.inspect}"
         end
       end
@@ -1109,7 +1143,7 @@ module Bunny
       queue_bindings.each do |b|
         begin
           recover_queue_binding(b)
-        rescue Exception => e
+        rescue ::StandardError => e
           @logger.error "Caught an exception while recovering a binding of queue #{b.destination}: #{e.inspect}"
         end
       end
@@ -1117,14 +1151,18 @@ module Bunny
       exchange_bindings.each do |b|
         begin
           recover_exchange_binding(b)
-        rescue Exception => e
+        rescue ::StandardError => e
           @logger.error "Caught an exception while recovering a binding of exchange #{b.source}: #{e.inspect}"
         end
       end
 
       @logger.debug { "Will recover #{consumers.size} consumer(s)" }
       consumers.each do |c|
-        recover_consumer(c)
+        begin
+          recover_consumer(c)
+        rescue ::StandardError => e
+          @logger.error "Caught an exception while recovering consumer #{c.consumer_tag} on queue #{c.queue_name}: #{e.inspect}"
+        end
       end
     end
 
@@ -1195,8 +1233,12 @@ module Bunny
     # @private
     def recover_consumer(c)
       c.channel.maybe_reinitialize_consumer_pool!
-      c.channel.basic_consume(c.queue_name, c.consumer_tag, !c.manual_ack, c.exclusive, c.arguments) do |*args|
-        c.callable.call(*args)
+      if c.callable.is_a?(Bunny::Consumer)
+        c.channel.basic_consume_with(c.callable)
+      else
+        c.channel.basic_consume(c.queue_name, c.consumer_tag, !c.manual_ack, c.exclusive, c.arguments) do |*args|
+          c.callable.call(*args)
+        end
       end
     end
 
@@ -1613,9 +1655,11 @@ module Bunny
       # We set the read_write_timeout to twice the heartbeat value,
       # and then some padding for edge cases.
       # This allows us to miss a single heartbeat before we time out the socket.
-      # If heartbeats are disabled, assume that TCP keepalives or a similar mechanism will be used
-      # and disable socket read timeouts. See ruby-amqp/bunny#551.
-      @transport.read_timeout = @heartbeat * 2.2
+      # If heartbeats are disabled, socket read timeouts will be disabled as well,
+      # but only after negotiation completes: a peer that accepts TCP connections
+      # without servicing them must not be able to block the handshake
+      # indefinitely. See ruby-amqp/bunny#551.
+      @transport.read_timeout = @heartbeat * 2.2 if @heartbeat > 0
       @logger.debug { "Will use socket read timeout of #{@transport.read_timeout.to_i} seconds" }
 
       # if there are existing channels we've just recovered from
@@ -1646,27 +1690,28 @@ module Bunny
       end
       connection_open_ok = frame2.decode_payload
 
-      @status_mutex.synchronize { @status = :open }
-      if @heartbeat && @heartbeat > 0
-        initialize_heartbeat_sender
-      end
-
       unless connection_open_ok.is_a?(AMQ::Protocol::Connection::OpenOk)
         if connection_open_ok.is_a?(AMQ::Protocol::Connection::Close)
           e = instantiate_connection_level_exception(connection_open_ok)
+          if automatically_recover?
+            close_transport
+            raise e
+          end
+
           begin
             shut_down_all_consumer_work_pools!
             maybe_shutdown_reader_loop
           rescue ShutdownSignal => _sse
             # no-op
-          rescue Exception => e
-            @logger.warn "Caught an exception when cleaning up after receiving connection.close: #{e.message}"
+          rescue Exception => cleanup_exception
+            @logger.warn "Caught an exception when cleaning up after receiving connection.close: #{cleanup_exception.message}"
           ensure
             close_transport
           end
 
           if threaded?
             @session_error_handler.raise(e)
+            return
           else
             raise e
           end
@@ -1674,6 +1719,13 @@ module Bunny
           raise "could not open connection: server did not respond with connection.open-ok but #{connection_open_ok.inspect} instead"
         end
       end
+
+      @status_mutex.synchronize { @status = :open }
+      if @heartbeat && @heartbeat > 0
+        initialize_heartbeat_sender
+      else
+        @transport.read_timeout = 0
+      end
     end
 
     def heartbeat_disabled?(val)
@@ -1714,7 +1766,7 @@ module Bunny
           @transport = Transport.new(self,
                                      host_from_address(address),
                                      port_from_address(address),
-                                     @opts.merge(:session_error_handler => @session_error_handler)
+                                     @opts.merge(session_error_handler: @session_error_handler)
           )
 
           # Reset the cached progname for the logger only when no logger was provided

data/lib/bunny/transport.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 require "socket"
-require "thread"
-require "monitor"
 
 begin
   require "openssl"
@@ -305,7 +303,7 @@ module Bunny
     def self.reachable?(host, port, timeout)
       begin
         s = Bunny::SocketImpl.open(host, port,
-          :connect_timeout => timeout)
+          connect_timeout: timeout)
 
         true
       rescue SocketError, Timeout::Error => _e
@@ -327,8 +325,8 @@ module Bunny
       @logger.debug("Using connection timeout of #{@connect_timeout} when connecting to #{@host}:#{@port}")
       begin
         @socket = Bunny::SocketImpl.open(@host, @port,
-          :keepalive      => @opts[:keepalive],
-          :connect_timeout => @connect_timeout)
+          keepalive:       @opts[:keepalive],
+          connect_timeout: @connect_timeout)
       rescue StandardError, ClientTimeout => e
         @status = :not_connected
         raise Bunny::TCPConnectionFailed.new(e, self.hostname, self.port)

data/lib/bunny/version.rb

@@ -1,7 +1,6 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module Bunny
   # @return [String] Version of the library
-  VERSION = "3.1.0"
+  VERSION = "3.3.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bunny
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 3.3.0
 platform: ruby
 authors:
 - Chris Duncan
@@ -19,14 +19,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.7'
+        version: '2.9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.7'
+        version: '2.9'
 - !ruby/object:Gem::Dependency
   name: logger
   requirement: !ruby/object:Gem::Requirement
@@ -76,6 +76,8 @@ extensions: []
 extra_rdoc_files:
 - README.md
 files:
+- ChangeLog.md
+- LICENSE
 - README.md
 - lib/amq/protocol/extensions.rb
 - lib/bunny.rb
@@ -134,7 +136,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.16
 specification_version: 4
 summary: Popular easy to use Ruby client for RabbitMQ
 test_files: []