bunny 1.0.7 → 2.24.0

data/lib/bunny/reader_loop.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "thread"
 
 module Bunny
@@ -9,11 +11,17 @@ module Bunny
   # @private
   class ReaderLoop
 
-    def initialize(transport, session, session_thread)
-      @transport      = transport
-      @session        = session
-      @session_thread = session_thread
-      @logger         = @session.logger
+    def initialize(transport, session, session_error_handler)
+      @transport             = transport
+      @session               = session
+      @session_error_handler = session_error_handler
+      @logger                = @session.logger
+
+      @mutex                 = Mutex.new
+
+      @stopping              = false
+      @stopped               = false
+      @network_is_down       = false
     end
 
 
@@ -29,34 +37,39 @@ module Bunny
     def run_loop
       loop do
         begin
-          break if @stopping || @network_is_down
+          break if @mutex.synchronize { @stopping || @stopped || @network_is_down }
           run_once
-        rescue Errno::EBADF => ebadf
-          break if @stopping
-          # ignored, happens when we loop after the transport has already been closed
-        rescue AMQ::Protocol::EmptyResponseError, IOError, SystemCallError => e
-          break if @stopping
-          log_exception(e)
+        rescue AMQ::Protocol::EmptyResponseError, IOError, SystemCallError, Timeout::Error,
+               OpenSSL::OpenSSLError => e
+          break if terminate? || @session.closing? || @session.closed?
 
           @network_is_down = true
-
           if @session.automatically_recover?
+            log_exception(e, level: :warn)
             @session.handle_network_failure(e)
           else
-            @session_thread.raise(Bunny::NetworkFailure.new("detected a network failure: #{e.message}", e))
+            log_exception(e)
+            @session_error_handler.raise(Bunny::NetworkFailure.new("detected a network failure: #{e.message}", e))
           end
         rescue ShutdownSignal => _
+          @mutex.synchronize { @stopping = true }
           break
         rescue Exception => e
-          break if @stopping
-          log_exception(e)
+          break if terminate?
+          if !(@session.closing? || @session.closed?)
+            log_exception(e)
 
-          @network_is_down = true
-          @session_thread.raise(Bunny::NetworkFailure.new("caught an unexpected exception in the network loop: #{e.message}", e))
+            @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
 
-      @stopped = true
+      @mutex.synchronize { @stopped = true }
     end
 
     def run_once
@@ -65,7 +78,7 @@ module Bunny
 
       if !frame.final? || frame.method_class.has_content?
         header   = @transport.read_next_frame
-        content  = ''
+        content  = +''
 
         if header.body_size > 0
           loop do
@@ -83,11 +96,21 @@ module Bunny
     end
 
     def stop
-      @stopping = true
+      @mutex.synchronize { @stopping = true }
     end
 
     def stopped?
-      @stopped
+      @mutex.synchronize { @stopped }
+    end
+
+    def stopping?
+      @mutex.synchronize { @stopping }
+    end
+
+    def terminate_with(e)
+      @mutex.synchronize { @stopping = true }
+
+      self.raise(e)
     end
 
     def raise(e)
@@ -95,7 +118,14 @@ module Bunny
     end
 
     def join
-      @thread.join if @thread
+      # Thread#join can/would trigger a re-raise of an unhandled exception in this thread.
+      # In addition, Thread.handle_interrupt can be used by other libraries or application code
+      # that would make this join operation fail with an obscure exception.
+      # So we try to save everyone some really unpleasant debugging time by introducing
+      # this condition which typically would not evaluate to true anyway.
+      #
+      # See ruby-amqp/bunny#589 and ruby-amqp/bunny#590 for background.
+      @thread.join if @thread && @thread != Thread.current
     end
 
     def kill
@@ -105,12 +135,26 @@ module Bunny
       end
     end
 
-    def log_exception(e)
-      @logger.error "Exception in the reader loop: #{e.class.name}: #{e.message}"
-      @logger.error "Backtrace: "
-      e.backtrace.each do |line|
-        @logger.error "\t#{line}"
+    protected
+
+    def log_exception(e, level: :error)
+      if !(io_error?(e) && (@session.closing? || @session.closed?))
+        @logger.send level, "Exception in the reader loop: #{e.class.name}: #{e.message}"
+        @logger.send level, "Backtrace: "
+        e.backtrace.each do |line|
+          @logger.send level, "\t#{line}"
+        end
+      end
+    end
+
+    def io_error?(e)
+      [AMQ::Protocol::EmptyResponseError, IOError, SystemCallError].any? do |klazz|
+        e.is_a?(klazz)
       end
     end
+
+    def terminate?
+      @mutex.synchronize { @stopping || @stopped }
+    end
   end
 end

data/lib/bunny/return_info.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Bunny
   # Wraps AMQ::Protocol::Basic::Return to
   # provide access to the delivery properties as immutable hash as