bunny 2.23.0 → 3.0.0

data/lib/bunny/transport.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "socket"
 require "thread"
 require "monitor"
@@ -70,7 +72,7 @@ module Bunny
       @read_timeout = opts[:read_timeout] || DEFAULT_READ_TIMEOUT
       @read_timeout = nil if @read_timeout == 0
 
-      @write_timeout = opts[:socket_timeout] # Backwards compatability
+      @write_timeout = opts[:socket_timeout] # Backwards compatibility
 
       @write_timeout ||= opts[:write_timeout] || DEFAULT_WRITE_TIMEOUT
       @write_timeout = nil if @write_timeout == 0
@@ -151,51 +153,26 @@ module Bunny
       block.call(@tls_context) if @tls_context
     end
 
-    if defined?(JRUBY_VERSION)
-      # Writes data to the socket.
-      def write(data)
-        return write_without_timeout(data) unless @write_timeout
+    # Writes data to the socket. If read/write timeout was specified the operation will return after that
+    # amount of time has elapsed waiting for the socket.
+    def write(data)
+      return write_without_timeout(data) unless @write_timeout
 
-        begin
-          if open?
-            @writes_mutex.synchronize do
-              @socket.write(data)
-            end
-          end
-        rescue SystemCallError, Timeout::Error, Bunny::ConnectionError, IOError => e
-          @logger.error "Got an exception when sending data: #{e.message} (#{e.class.name})"
-          close
-          @status = :not_connected
-
-          if @session.automatically_recover?
-            @session.handle_network_failure(e)
-          else
-            @session_error_handler.raise(Bunny::NetworkFailure.new("detected a network failure: #{e.message}", e))
+      begin
+        if open?
+          @writes_mutex.synchronize do
+            @socket.write_nonblock_fully(data, @write_timeout)
           end
         end
-      end
-    else
-      # Writes data to the socket. If read/write timeout was specified the operation will return after that
-      # amount of time has elapsed waiting for the socket.
-      def write(data)
-        return write_without_timeout(data) unless @write_timeout
+      rescue SystemCallError, Timeout::Error, Bunny::ConnectionError, IOError => e
+        @logger.error "Got an exception when sending data: #{e.message} (#{e.class.name})"
+        close
+        @status = :not_connected
 
-        begin
-          if open?
-            @writes_mutex.synchronize do
-              @socket.write_nonblock_fully(data, @write_timeout)
-            end
-          end
-        rescue SystemCallError, Timeout::Error, Bunny::ConnectionError, IOError => e
-          @logger.error "Got an exception when sending data: #{e.message} (#{e.class.name})"
-          close
-          @status = :not_connected
-
-          if @session.automatically_recover?
-            @session.handle_network_failure(e)
-          else
-            @session_error_handler.raise(Bunny::NetworkFailure.new("detected a network failure: #{e.message}", e))
-          end
+        if @session.automatically_recover?
+          @session.handle_network_failure(e)
+        else
+          @session_error_handler.raise(Bunny::NetworkFailure.new("detected a network failure: #{e.message}", e))
         end
       end
     end
@@ -203,8 +180,10 @@ module Bunny
     # Writes data to the socket without timeout checks
     def write_without_timeout(data, raise_exceptions = false)
       begin
-        @writes_mutex.synchronize { @socket.write(data) }
-        @socket.flush
+        @writes_mutex.synchronize do
+          @socket.write(data)
+          @socket.flush
+        end
       rescue SystemCallError, Bunny::ConnectionError, IOError => e
         close
         raise e if raise_exceptions
@@ -223,7 +202,7 @@ module Bunny
     # @private
     def send_frame(frame)
       if closed?
-        @session.handle_network_failure(ConnectionClosedError.new(frame))
+        @session.handle_network_failure(ConnectionClosedError.new(frame)) if @session.automatically_recover?
       else
         write(frame.encode)
       end
@@ -235,7 +214,7 @@ module Bunny
     # @private
     def send_frame_without_timeout(frame)
       if closed?
-        @session.handle_network_failure(ConnectionClosedError.new(frame))
+        @session.handle_network_failure(ConnectionClosedError.new(frame)) if @session.automatically_recover?
       else
         write_without_timeout(frame.encode)
       end
@@ -282,7 +261,10 @@ module Bunny
     # Exposed primarily for Bunny::Channel
     # @private
     def read_next_frame(opts = {})
-      header              = read_fully(7)
+      @frame_header_buffer ||= String.new(capacity: 7)
+      @frame_header_buffer.clear
+      header = read_fully_into(@frame_header_buffer, 7)
+
       type, channel, size = AMQ::Protocol::Frame.decode_header(header)
       payload             = if size > 0
                               read_fully(size)
@@ -301,8 +283,26 @@ module Bunny
       AMQ::Protocol::Frame.new(type, payload, channel)
     end
 
+    # @private
+    def read_fully_into(buffer, count)
+      begin
+        @socket.read_fully_into(buffer, count, @read_timeout)
+      rescue SystemCallError, Timeout::Error, Bunny::ConnectionError, IOError => e
+        @logger.error "Got an exception when receiving data: #{e.message} (#{e.class.name})"
+        close
+        @status = :not_connected
 
-    def self.reacheable?(host, port, timeout)
+        if @session.automatically_recover?
+          raise
+        else
+          @session_error_handler.raise(Bunny::NetworkFailure.new("detected a network failure: #{e.message}", e))
+        end
+      end
+      buffer
+    end
+
+
+    def self.reachable?(host, port, timeout)
       begin
         s = Bunny::SocketImpl.open(host, port,
           :connect_timeout => timeout)
@@ -315,11 +315,16 @@ module Bunny
       end
     end
 
+    class << self
+      alias_method :reacheable?, :reachable?
+    end
+
     def self.ping!(host, port, timeout)
-      raise ConnectionTimeout.new("#{host}:#{port} is unreachable") if !reacheable?(host, port, timeout)
+      raise ConnectionTimeout.new("#{host}:#{port} is unreachable") if !reachable?(host, port, timeout)
     end
 
     def initialize_socket
+      @logger.debug("Using connection timeout of #{@connect_timeout} when connecting to #{@host}:#{@port}")
       begin
         @socket = Bunny::SocketImpl.open(@host, @port,
           :keepalive      => @opts[:keepalive],

data/lib/bunny/version.rb

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

data/lib/bunny.rb

@@ -1,4 +1,5 @@
 # -*- encoding: utf-8; mode: ruby -*-
+# frozen_string_literal: true
 
 require "timeout"
 
@@ -88,7 +89,7 @@ module Bunny
   # @option connection_string_or_opts [Proc] :recovery_attempt_started (nil) Will be called before every connection recovery attempt
   # @option connection_string_or_opts [Proc] :recovery_completed (nil) Will be called after successful connection recovery
   # @option connection_string_or_opts [Boolean] :recover_from_connection_close (true) Should this connection recover after receiving a server-sent connection.close (e.g. connection was force closed)?
-  # @option connection_string_or_opts [Object] :session_error_handler (Thread.current) Object which responds to #raise that will act as a session error handler. Defaults to Thread.current, which will raise asynchronous exceptions in the thread that created the session.
+  # @option connection_string_or_opts [Object] :session_error_handler (ExceptionAccumulator.new) Object which responds to #raise that will act as a session error handler. Defaults to a Bunny::ExceptionAccumulator instance which stores exceptions for safe retrieval later. Can be set to Thread.current for legacy behavior (raises asynchronous exceptions in the creating thread).
   #
   # @option optz [String] :auth_mechanism ("PLAIN") Authentication mechanism, PLAIN or EXTERNAL
   # @option optz [String] :locale ("PLAIN") Locale RabbitMQ should use

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bunny
 version: !ruby/object:Gem::Version
-  version: 2.23.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Chris Duncan
@@ -9,10 +9,9 @@ authors:
 - Jakub Stastny aka botanicus
 - Michael S. Klishin
 - Stefan Kaes
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-07-01 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: amq-protocol
@@ -20,20 +19,34 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.3'
+        version: '2.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.3.1
+        version: '1.7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.3'
+        version: '1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.3.1
+        version: '1.7'
 - !ruby/object:Gem::Dependency
   name: sorted_set
   requirement: !ruby/object:Gem::Requirement
@@ -74,7 +87,7 @@ files:
 - lib/bunny/concurrent/atomic_fixnum.rb
 - lib/bunny/concurrent/condition.rb
 - lib/bunny/concurrent/continuation_queue.rb
-- lib/bunny/concurrent/linked_continuation_queue.rb
+- lib/bunny/concurrent/exception_accumulator.rb
 - lib/bunny/concurrent/synchronized_sorted_set.rb
 - lib/bunny/consumer.rb
 - lib/bunny/consumer_tag_generator.rb
@@ -87,8 +100,6 @@ files:
 - lib/bunny/framing.rb
 - lib/bunny/get_response.rb
 - lib/bunny/heartbeat_sender.rb
-- lib/bunny/jruby/socket.rb
-- lib/bunny/jruby/ssl_socket.rb
 - lib/bunny/message_properties.rb
 - lib/bunny/queue.rb
 - lib/bunny/reader_loop.rb
@@ -99,15 +110,16 @@ files:
 - lib/bunny/test_kit.rb
 - lib/bunny/timeout.rb
 - lib/bunny/timestamp.rb
+- lib/bunny/topology_recovery_filter.rb
+- lib/bunny/topology_registry.rb
 - lib/bunny/transport.rb
 - lib/bunny/version.rb
-- lib/bunny/versioned_delivery_tag.rb
 homepage: http://rubybunny.info
 licenses:
 - MIT
 metadata:
   changelog_uri: https://github.com/ruby-amqp/bunny/blob/main/ChangeLog.md
-post_install_message:
+  source_code_uri: https://github.com/ruby-amqp/bunny/
 rdoc_options: []
 require_paths:
 - lib
@@ -122,8 +134,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.9
-signing_key:
+rubygems_version: 4.0.6
 specification_version: 4
 summary: Popular easy to use Ruby client for RabbitMQ
 test_files: []

data/lib/bunny/concurrent/linked_continuation_queue.rb

@@ -1,61 +0,0 @@
-if !defined?(JRUBY_VERSION)
-  raise "Bunny::Concurrent::LinkedContinuationQueue can only be used on JRuby!"
-end
-
-require "java"
-
-java_import java.util.concurrent.LinkedBlockingQueue
-java_import java.util.concurrent.TimeUnit
-
-module Bunny
-  module Concurrent
-    # Continuation queue implementation for JRuby.
-    #
-    # On JRuby, we'd rather use reliable and heavily battle tested j.u.c.
-    # primitives with well described semantics than informally specified, clumsy
-    # and limited Ruby standard library parts.
-    #
-    # This is an implementation of the continuation queue on top of the linked blocking
-    # queue in j.u.c.
-    #
-    # Compared to the Ruby standard library Queue, there is one limitation: you cannot
-    # push a nil on the queue, it will fail with a null pointer exception.
-    # @private
-    class LinkedContinuationQueue
-      def initialize(*args, &block)
-        @q = LinkedBlockingQueue.new
-      end
-
-      def push(el, timeout_in_ms = nil)
-        if timeout_in_ms
-          @q.offer(el, timeout_in_ms, TimeUnit::MILLISECONDS)
-        else
-          @q.offer(el)
-        end
-      end
-      alias << push
-
-      def pop
-        @q.take
-      end
-
-      def poll(timeout_in_ms = nil)
-        if timeout_in_ms
-          v = @q.poll(timeout_in_ms, TimeUnit::MILLISECONDS)
-          raise ::Timeout::Error.new("operation did not finish in #{timeout_in_ms} ms") if v.nil?
-          v
-        else
-          @q.poll
-        end
-      end
-
-      def clear
-        @q.clear
-      end
-
-      def method_missing(selector, *args, &block)
-        @q.__send__(selector, *args, &block)
-      end
-    end
-  end
-end

data/lib/bunny/jruby/socket.rb

@@ -1,57 +0,0 @@
-require "bunny/cruby/socket"
-
-module Bunny
-  module JRuby
-    # TCP socket extension that uses Socket#readpartial to avoid excessive CPU
-    # burn after some time. See issue #165.
-    # @private
-    module Socket
-      include Bunny::Socket
-
-      def self.open(host, port, options = {})
-        socket = ::Socket.tcp(host, port, nil, nil,
-                              connect_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
-        socket.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_KEEPALIVE, true) if options.fetch(:keepalive, true)
-        socket.extend self
-        socket.options = { :host => host, :port => port }.merge(options)
-        socket
-      rescue Errno::ETIMEDOUT
-        raise ClientTimeout
-      end
-
-      # Reads given number of bytes with an optional timeout
-      #
-      # @param [Integer] count How many bytes to read
-      # @param [Integer] timeout Timeout
-      #
-      # @return [String] Data read from the socket
-      # @api public
-      def read_fully(count, timeout = nil)
-        value = ''
-
-        begin
-          loop do
-            value << read_nonblock(count - value.bytesize)
-            break if value.bytesize >= count
-          end
-        rescue EOFError
-          # JRuby specific fix via https://github.com/jruby/jruby/issues/1694#issuecomment-54873532
-          IO.select([self], nil, nil, timeout)
-          retry
-        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
-
-        value
-      end # read_fully
-
-    end
-  end
-end

data/lib/bunny/jruby/ssl_socket.rb

@@ -1,58 +0,0 @@
-module Bunny
-  module JRuby
-    begin
-      require "bunny/cruby/ssl_socket"
-      require "openssl"
-
-      # TLS-enabled TCP socket that implements convenience
-      # methods found in Bunny::Socket.
-      class SSLSocket < Bunny::SSLSocket
-
-        def initialize(*args)
-          super
-          @__bunny_socket_eof_flag__ = false
-        end
-
-        # Reads given number of bytes with an optional timeout
-        #
-        # @param [Integer] count How many bytes to read
-        # @param [Integer] timeout Timeout
-        #
-        # @return [String] Data read from the socket
-        # @api public
-        def read_fully(count, timeout = nil)
-          return nil if @__bunny_socket_eof_flag__
-
-          value = ''
-          begin
-            loop do
-              value << read_nonblock(count - value.bytesize)
-              break if value.bytesize >= count
-            end
-          rescue EOFError => e
-            @__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 => e
-            if IO.select([self], nil, nil, timeout)
-              retry
-            else
-              raise Timeout::Error, "IO timeout when reading #{count} bytes"
-            end
-          end
-          value
-        end
-      end
-    rescue LoadError => le
-      puts "Could not load OpenSSL"
-    end
-  end
-end

data/lib/bunny/versioned_delivery_tag.rb

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