bunny 2.24.0 → 3.1.0

data/lib/bunny/concurrent/exception_accumulator.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "thread"
+
+module Bunny
+  module Concurrent
+    # A thread-safe exception accumulator that stores exceptions for later retrieval
+    # instead of immediately raising them in the calling thread.
+    #
+    # This is the default session error handler in Bunny. When errors occur in
+    # background threads (such as the reader loop or transport), they are stored
+    # in the accumulator rather than being raised asynchronously in the thread
+    # that created the session.
+    #
+    # This prevents dangerous control flow interruptions that can occur when
+    # exceptions are raised asynchronously via Thread#raise.
+    #
+    # @example Checking for accumulated exceptions
+    #   conn = Bunny.new
+    #   conn.start
+    #   # ... do work ...
+    #   if conn.exception_occurred?
+    #     exceptions = conn.exceptions
+    #     # handle exceptions appropriately
+    #   end
+    #
+    # @see https://github.com/ruby-amqp/bunny/issues/721
+    # @api public
+    class ExceptionAccumulator
+      def initialize
+        @exceptions = []
+        @mutex = Mutex.new
+      end
+
+      # Called by background threads to record an exception.
+      # This method is compatible with Thread#raise interface.
+      #
+      # @param exception [Exception] the exception to accumulate
+      def raise(exception)
+        @mutex.synchronize do
+          @exceptions << exception
+        end
+      end
+
+      # Returns true if any exceptions have been accumulated.
+      #
+      # @return [Boolean]
+      def any?
+        @mutex.synchronize { @exceptions.any? }
+      end
+
+      # Returns true if no exceptions have been accumulated.
+      #
+      # @return [Boolean]
+      def empty?
+        @mutex.synchronize { @exceptions.empty? }
+      end
+
+      # Returns the number of accumulated exceptions.
+      #
+      # @return [Integer]
+      def count
+        @mutex.synchronize { @exceptions.count }
+      end
+
+      # Returns all accumulated exceptions.
+      #
+      # @return [Array<Exception>]
+      def all
+        @mutex.synchronize { @exceptions.dup }
+      end
+
+      # Returns and removes the first accumulated exception (FIFO order).
+      # Returns nil if no exceptions have been accumulated.
+      #
+      # @return [Exception, nil]
+      def pop
+        @mutex.synchronize { @exceptions.shift }
+      end
+
+      # Clears all accumulated exceptions.
+      #
+      # @return [Array<Exception>] the exceptions that were cleared
+      def clear
+        @mutex.synchronize do
+          cleared = @exceptions.dup
+          @exceptions.clear
+          cleared
+        end
+      end
+
+      # Raises the first accumulated exception if any exist, removing it from the accumulator.
+      # Does nothing if no exceptions have been accumulated.
+      #
+      # @raise [Exception] the first accumulated exception
+      def raise_first!
+        exception = pop
+        Kernel.raise exception if exception
+      end
+
+      # Raises all accumulated exceptions wrapped in a single exception if any exist,
+      # clearing the accumulator.
+      #
+      # @raise [Bunny::AccumulatedExceptions] wrapper containing all accumulated exceptions
+      def raise_all!
+        exceptions = clear
+        return if exceptions.empty?
+        Kernel.raise AccumulatedExceptions.new(exceptions)
+      end
+    end
+  end
+
+  # Alias for backward compatibility and convenience
+  ExceptionAccumulator = Concurrent::ExceptionAccumulator
+end

data/lib/bunny/consumer.rb

@@ -99,13 +99,13 @@ module Bunny
     # @return [Boolean] true if this consumer uses automatic acknowledgement mode
     # @api public
     def automatic_acknowledgement?
-      @no_ack == true
+      @no_ack
     end
 
     # @return [Boolean] true if this consumer uses manual (explicit) acknowledgement mode
     # @api public
     def manual_acknowledgement?
-      @no_ack == false
+      !@no_ack
     end
 
     # @return [String] Name of the queue this consumer is on
@@ -117,14 +117,5 @@ module Bunny
         @queue
       end
     end
-
-    #
-    # Recovery
-    #
-
-    # @private
-    def recover_from_network_failure
-      @channel.basic_consume_with(self)
-    end
   end
 end

data/lib/bunny/cruby/socket.rb

@@ -29,7 +29,8 @@ module Bunny
 
     def self.open(host, port, options = {})
       socket = ::Socket.tcp(host, port, nil, nil,
-                            connect_timeout: options[:connect_timeout])
+                            connect_timeout: options[:connect_timeout],
+                            resolv_timeout: options[:connect_timeout])
       if ::Socket.constants.include?('TCP_NODELAY') || ::Socket.constants.include?(:TCP_NODELAY)
         socket.setsockopt(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, true)
       end
@@ -73,6 +74,37 @@ module Bunny
       value
     end # read_fully
 
+    # Reads given number of bytes into an existing buffer with an optional timeout
+    #
+    # @param [String] buffer Buffer to read into (will be appended to)
+    # @param [Integer] count How many bytes to read
+    # @param [Integer] timeout Timeout
+    #
+    # @return [String] The buffer with data appended
+    # @api public
+    def read_fully_into(buffer, count, timeout = nil)
+      return nil if @__bunny_socket_eof_flag__
+
+      bytes_read = 0
+      begin
+        loop do
+          chunk = read_nonblock(count - bytes_read)
+          buffer << chunk
+          bytes_read += chunk.bytesize
+          break if bytes_read >= count
+        end
+      rescue EOFError
+        @__bunny_socket_eof_flag__ = true
+      rescue *READ_RETRY_EXCEPTION_CLASSES
+        if IO.select([self], nil, nil, timeout)
+          retry
+        else
+          raise Timeout::Error, "IO timeout when reading #{count} bytes"
+        end
+      end
+      buffer
+    end # read_fully_into
+
     # Writes provided data using IO#write_nonblock, taking care of handling
     # of exceptions it raises when writing would fail (e.g. due to socket buffer
     # being full).

data/lib/bunny/cruby/ssl_socket.rb

@@ -69,6 +69,47 @@ module Bunny
         value
       end
 
+      # Reads given number of bytes into an existing buffer with an optional timeout
+      #
+      # @param [String] buffer Buffer to read into (will be appended to)
+      # @param [Integer] count How many bytes to read
+      # @param [Integer] timeout Timeout
+      #
+      # @return [String] The buffer with data appended
+      # @api public
+      def read_fully_into(buffer, count, timeout = nil)
+        return nil if @__bunny_socket_eof_flag__
+
+        bytes_read = 0
+        begin
+          loop do
+            chunk = read_nonblock(count - bytes_read)
+            buffer << chunk
+            bytes_read += chunk.bytesize
+            break if bytes_read >= count
+          end
+        rescue EOFError
+          @__bunny_socket_eof_flag__ = true
+        rescue OpenSSL::SSL::SSLError => e
+          if e.message == "read would block"
+            if IO.select([self], nil, nil, timeout)
+              retry
+            else
+              raise Timeout::Error, "IO timeout when reading #{count} bytes"
+            end
+          else
+            raise e
+          end
+        rescue *READ_RETRY_EXCEPTION_CLASSES
+          if IO.select([self], nil, nil, timeout)
+            retry
+          else
+            raise Timeout::Error, "IO timeout when reading #{count} bytes"
+          end
+        end
+        buffer
+      end
+
       # Writes provided data using IO#write_nonblock, taking care of handling
       # of exceptions it raises when writing would fail (e.g. due to socket buffer
       # being full).

data/lib/bunny/delivery_info.rb

@@ -1,11 +1,9 @@
 # frozen_string_literal: true
 
-require "bunny/versioned_delivery_tag"
-
 module Bunny
-  # Wraps {AMQ::Protocol::Basic::Deliver} to
+  # Wraps [AMQ::Protocol::Basic::Deliver] to
   # provide access to the delivery properties as immutable hash as
-  # well as methods.
+  # well as methods. Hash representation is created lazily.
   class DeliveryInfo
 
     #
@@ -26,15 +24,6 @@ module Bunny
     # @private
     def initialize(basic_deliver, consumer, channel)
       @basic_deliver = basic_deliver
-      @hash          = {
-        :consumer_tag => basic_deliver.consumer_tag,
-        :delivery_tag => VersionedDeliveryTag.new(basic_deliver.delivery_tag, channel.recoveries_counter),
-        :redelivered  => basic_deliver.redelivered,
-        :exchange     => basic_deliver.exchange,
-        :routing_key  => basic_deliver.routing_key,
-        :consumer     => consumer,
-        :channel      => channel
-      }
       @consumer      = consumer
       @channel       = channel
     end
@@ -42,18 +31,35 @@ module Bunny
     # Iterates over delivery properties
     # @see Enumerable#each
     def each(*args, &block)
-      @hash.each(*args, &block)
+      to_hash.each(*args, &block)
     end
 
     # Accesses delivery properties by key
     # @see Hash#[]
     def [](k)
-      @hash[k]
+      case k
+      when :consumer_tag then @basic_deliver.consumer_tag
+      when :delivery_tag then @basic_deliver.delivery_tag
+      when :redelivered  then @basic_deliver.redelivered
+      when :exchange     then @basic_deliver.exchange
+      when :routing_key  then @basic_deliver.routing_key
+      when :consumer     then @consumer
+      when :channel      then @channel
+      else nil
+      end
     end
 
     # @return [Hash] Hash representation of this delivery info
     def to_hash
-      @hash
+      @hash ||= {
+        :consumer_tag => @basic_deliver.consumer_tag,
+        :delivery_tag => @basic_deliver.delivery_tag,
+        :redelivered  => @basic_deliver.redelivered,
+        :exchange     => @basic_deliver.exchange,
+        :routing_key  => @basic_deliver.routing_key,
+        :consumer     => @consumer,
+        :channel      => @channel
+      }
     end
 
     # @private

data/lib/bunny/exceptions.rb

@@ -6,6 +6,9 @@ module Bunny
   class Exception < ::StandardError
   end
 
+  # Used when a list of endpoints (hostnames) to connect to
+  # has been fully traversed, that is, there are no more endpoints (hostnames)
+  # to try.
   class HostListDepleted < Exception
     def initialize
       super("No more hosts to try in the supplied list of hosts")
@@ -163,7 +166,7 @@ module Bunny
   class MessageError  < ConnectionLevelException; end
   # @private
   class ProtocolError < ConnectionLevelException; end
-  # Raised when RabbitMQ reports and internal error
+  # Raised when RabbitMQ reports an internal error
   class InternalError < ConnectionLevelException; end
 
   # Raised when read or write I/O operations time out (but only if
@@ -177,7 +180,7 @@ module Bunny
   class InconsistentDataError < Exception
   end
 
-  # Raised by adapters when frame does not end with {final octet AMQ::Protocol::Frame::FINAL_OCTET}.
+  # Raised by adapters when frame does not end with final octet [AMQ::Protocol::Frame::FINAL_OCTET].
   # This suggest that there is a bug in adapter or AMQ broker implementation.
   #
   # @see https://www.rabbitmq.com/resources/specs/amqp0-9-1.pdf AMQP 0.9.1 specification (Section 2.3)
@@ -209,6 +212,18 @@ module Bunny
     end
   end
 
+  # Raised when a published message is nacked by the broker
+  # and publisher confirm tracking is enabled.
+  # @api public
+  class MessageNacked < Exception
+    attr_reader :delivery_tag
+
+    def initialize(message, delivery_tag)
+      super(message)
+      @delivery_tag = delivery_tag
+    end
+  end
+
   # Raised when RabbitMQ responds with 406 PRECONDITION_FAILED
   class PreconditionFailed < ChannelLevelException
   end
@@ -268,4 +283,18 @@ module Bunny
   # @private
   class MissingTLSKeyFile < Exception
   end
+
+  # Exception wrapper that holds multiple accumulated exceptions.
+  # Raised by ExceptionAccumulator#raise_all! when multiple exceptions occurred.
+  #
+  # @api public
+  class AccumulatedExceptions < Exception
+    attr_reader :exceptions
+
+    def initialize(exceptions)
+      @exceptions = exceptions
+      messages = exceptions.map { |e| "#{e.class}: #{e.message}" }
+      super("#{exceptions.count} exception(s) accumulated:\n  #{messages.join("\n  ")}")
+    end
+  end
 end

data/lib/bunny/exchange.rb

@@ -9,6 +9,24 @@ module Bunny
   # @see http://rubybunny.info/articles/extensions.html RabbitMQ Extensions guide
   class Exchange
 
+    #
+    # Exchange type constants
+    #
+
+    # Standard AMQP 0-9-1 exchange types
+    TYPE_DIRECT  = :direct
+    TYPE_FANOUT  = :fanout
+    TYPE_TOPIC   = :topic
+    TYPE_HEADERS = :headers
+
+    # In RabbitMQ core since 4.3.0
+    TYPE_MODULUS_HASH = :"x-modulus-hash"
+    # In RabbitMQ core since 4.2.0
+    TYPE_LOCAL_RANDOM = :"x-local-random"
+    # Provided by commonly used plugins
+    TYPE_CONSISTENT_HASH = :"x-consistent-hash"
+    TYPE_RANDOM = :"x-random"
+
     #
     # API
     #
@@ -19,7 +37,7 @@ module Bunny
     # @return [String]
     attr_reader :name
 
-    # Type of this exchange (one of: :direct, :fanout, :topic, :headers).
+    # Type of this exchange (e.g. :direct, :fanout, :topic, :headers, :"x-consistent-hash", :"x-modulus-hash").
     # @return [Symbol]
     attr_reader :type
 
@@ -88,7 +106,10 @@ module Bunny
 
       declare! unless opts[:no_declare] || predeclared? || (@name == AMQ::Protocol::EMPTY_STRING)
 
+      # for basic.return dispatch and such
       @channel.register_exchange(self)
+      # for topology recovery
+      @channel.record_exchange(self)
     end
 
     # @return [Boolean] true if this exchange was declared as durable (will survive broker restart).
@@ -140,7 +161,8 @@ module Bunny
     # @see http://rubybunny.info/articles/exchanges.html Exchanges and Publishing guide
     # @api public
     def publish(payload, opts = {})
-      @channel.basic_publish(payload, self.name, (opts.delete(:routing_key) || opts.delete(:key)), opts)
+      rk = opts[:routing_key] || opts[:key]
+      @channel.basic_publish(payload, self.name, rk, opts)
 
       self
     end
@@ -155,7 +177,7 @@ module Bunny
     # @see http://rubybunny.info/articles/exchanges.html Exchanges and Publishing guide
     # @api public
     def delete(opts = {})
-      @channel.deregister_exchange(self)
+      @channel.delete_recorded_exchange(self)
       @channel.exchange_delete(@name, opts) unless predeclared?
     end
 
@@ -220,16 +242,6 @@ module Bunny
       @channel.wait_for_confirms
     end
 
-    # @private
-    def recover_from_network_failure
-      declare! unless @options[:no_declare] ||predefined?
-
-      @bindings.each do |b|
-        bind(b[:source], b[:opts])
-      end
-    end
-
-
     #
     # Implementation
     #

data/lib/bunny/get_response.rb

@@ -1,11 +1,9 @@
 # frozen_string_literal: true
 
-require "bunny/versioned_delivery_tag"
-
 module Bunny
   # Wraps {AMQ::Protocol::Basic::GetOk} to
   # provide access to the delivery properties as immutable hash as
-  # well as methods.
+  # well as methods. Hash representation is created lazily.
   class GetResponse
 
     #
@@ -23,32 +21,38 @@ module Bunny
 
     # @private
     def initialize(get_ok, channel)
-      @get_ok = get_ok
-      @hash          = {
-        :delivery_tag => @get_ok.delivery_tag,
-        :redelivered  => @get_ok.redelivered,
-        :exchange     => @get_ok.exchange,
-        :routing_key  => @get_ok.routing_key,
-        :channel      => channel
-      }
-      @channel       = channel
+      @get_ok  = get_ok
+      @channel = channel
     end
 
     # Iterates over the delivery properties
     # @see Enumerable#each
     def each(*args, &block)
-      @hash.each(*args, &block)
+      to_hash.each(*args, &block)
     end
 
     # Accesses delivery properties by key
     # @see Hash#[]
     def [](k)
-      @hash[k]
+      case k
+      when :delivery_tag then @get_ok.delivery_tag
+      when :redelivered  then @get_ok.redelivered
+      when :exchange     then @get_ok.exchange
+      when :routing_key  then @get_ok.routing_key
+      when :channel      then @channel
+      else nil
+      end
     end
 
     # @return [Hash] Hash representation of this delivery info
     def to_hash
-      @hash
+      @hash ||= {
+        :delivery_tag => @get_ok.delivery_tag,
+        :redelivered  => @get_ok.redelivered,
+        :exchange     => @get_ok.exchange,
+        :routing_key  => @get_ok.routing_key,
+        :channel      => @channel
+      }
     end
 
     # @private

data/lib/bunny/heartbeat_sender.rb

@@ -53,10 +53,10 @@ module Bunny
           sleep @interval
         end
       rescue IOError => ioe
-        @logger.error "I/O error in the hearbeat sender: #{ioe.message}"
+        @logger.error "I/O error in the heartbeat sender: #{ioe.message}"
         stop
       rescue ::Exception => e
-        @logger.error "Error in the hearbeat sender: #{e.message}"
+        @logger.error "Error in the heartbeat sender: #{e.message}"
         stop
       end
     end

data/lib/bunny/queue.rb

@@ -17,8 +17,10 @@ module Bunny
       QUORUM  = "quorum"
       CLASSIC = "classic"
       STREAM  = "stream"
+      DELAYED = "delayed"
+      JMS     = "jms"
 
-      KNOWN = [CLASSIC, QUORUM, STREAM]
+      KNOWN = [CLASSIC, QUORUM, STREAM, DELAYED, JMS]
 
       def self.known?(q_type)
         KNOWN.include?(q_type)
@@ -28,6 +30,13 @@ module Bunny
     module XArgs
       MAX_LENGTH = "x-max-length",
       QUEUE_TYPE = "x-queue-type"
+
+      DELAYED_RETRY_TYPE = "x-delayed-retry-type"
+      DELAYED_RETRY_MIN  = "x-delayed-retry-min"
+      DELAYED_RETRY_MAX  = "x-delayed-retry-max"
+
+      SELECTOR_FIELDS          = "x-selector-fields"
+      SELECTOR_FIELD_MAX_BYTES = "x-selector-field-max-bytes"
     end
 
     # @return [Bunny::Channel] Channel this queue uses
@@ -44,7 +53,7 @@ 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 [String] :type (nil)            Type of the declared queue (classic, quorum or stream)
+    # @option opts [String] :type (nil)            Type of the declared queue (classic, quorum, stream, delayed, or jms)
     # @option opts [Hash] :arguments (nil)         Additional optional arguments (typically used by RabbitMQ extensions and plugins)
     #
     # @see Bunny::Channel#queue
@@ -80,7 +89,10 @@ module Bunny
 
       declare! unless opts[:no_declare]
 
+      # for basic.deliver dispatch and such
       @channel.register_queue(self)
+      # for topology recovery
+      @channel.record_queue(self)
     end
 
     # @return [Boolean] true if this queue was declared as durable (will survive broker restart).
@@ -117,6 +129,13 @@ module Bunny
       @arguments
     end
 
+    # @param value [String]
+    # @private
+    def update_name_to(value)
+      @name = value
+      self
+    end
+
     def to_s
       oid = ("0x%x" % (self.object_id << 1))
       "<#{self.class.name}:#{oid} @name=\"#{name}\" channel=#{@channel.to_s} @durable=#{@durable} @auto_delete=#{@auto_delete} @exclusive=#{@exclusive} @arguments=#{@arguments}>"
@@ -320,6 +339,7 @@ module Bunny
     # @see http://rubybunny.info/articles/queues.html Queues and Consumers guide
     # @api public
     def delete(opts = {})
+      @channel.delete_recorded_queue_named(self.name)
       @channel.deregister_queue(self)
       @channel.queue_delete(@name, opts)
     end
@@ -362,42 +382,6 @@ module Bunny
         "unsupported queue type #{q_type.inspect}, supported ones: #{Types::KNOWN.join(', ')}") if (q_type and !Types.known?(q_type))
     end
 
-    #
-    # Recovery
-    #
-
-    # @private
-    def recover_from_network_failure
-      if self.server_named?
-        old_name = @name.dup
-        @name    = AMQ::Protocol::EMPTY_STRING
-
-        @channel.deregister_queue_named(old_name)
-      end
-
-      # TODO: inject and use logger
-      # puts "Recovering queue #{@name}"
-      begin
-        declare! unless @options[:no_declare]
-
-        @channel.register_queue(self)
-      rescue Exception => e
-        # TODO: inject and use logger
-        puts "Caught #{e.inspect} while redeclaring and registering #{@name}!"
-      end
-      recover_bindings
-    end
-
-    # @private
-    def recover_bindings
-      @bindings.each do |b|
-        # TODO: inject and use logger
-        # puts "Recovering binding #{b.inspect}"
-        self.bind(b[:exchange], b)
-      end
-    end
-
-
     #
     # Implementation
     #

data/lib/bunny/reader_loop.rb

@@ -43,9 +43,13 @@ module Bunny
                OpenSSL::OpenSSLError => e
           break if terminate? || @session.closing? || @session.closed?
 
-          @network_is_down = true
+          @mutex.synchronize do
+            @stopping = true
+            @network_is_down = true
+          end
+
           if @session.automatically_recover?
-            log_exception(e, level: :warn)
+            log_exception(e, level: :debug)
             @session.handle_network_failure(e)
           else
             log_exception(e)
@@ -62,10 +66,6 @@ module Bunny
             @network_is_down = true
             @session_error_handler.raise(Bunny::NetworkFailure.new("caught an unexpected exception in the network loop: #{e.message}", e))
           end
-        rescue Errno::EBADF => _ebadf
-          break if terminate?
-          # ignored, happens when we loop after the transport has already been closed
-          @mutex.synchronize { @stopping = true }
         end
       end