amq-client 0.7.0.alpha35 → 0.8.0

data/lib/amq/client/async/adapter.rb

@@ -100,7 +100,7 @@ module AMQ
             #       AMQ protocol defines two-step process of closing connection (send Connection.Close
             #       to the peer and wait for Connection.Close-Ok), implemented by {Adapter#disconnect}
             def close_connection
-              raise MissingInterfaceMethodError.new("AMQ::Client.close_connection")
+              raise NotImplementedError
             end unless defined?(:close_connection) # since it is a module, this method may already be defined
           end
         end # self.included(host)
@@ -196,11 +196,12 @@ module AMQ
         #
 
 
+
         # Establish socket connection to the server.
         #
         # @api plugin
         def establish_connection(settings)
-          raise MissingInterfaceMethodError.new("AMQ::Client#establish_connection(settings)")
+          raise NotImplementedError
         end
 
         # Properly close connection with AMQ broker, as described in
@@ -224,6 +225,8 @@ module AMQ
         end
 
 
+
+
         # Sends AMQ protocol header (also known as preamble).
         #
         # @note This must be implemented by all AMQP clients.
@@ -244,11 +247,19 @@ module AMQ
           end
         end
 
-        # Sends multiple frames, one by one.
+        # Sends multiple frames, one by one. For thread safety this method takes a channel
+        # object and synchronizes on it.
         #
         # @api public
-        def send_frameset(frames)
-          frames.each { |frame| self.send_frame(frame) }
+        def send_frameset(frames, channel)
+          # some (many) developers end up sharing channels between threads and when multiple
+          # threads publish on the same channel aggressively, at some point frames will be
+          # delivered out of order and broker will raise 505 UNEXPECTED_FRAME exception.
+          # If we synchronize on the channel, however, this is both thread safe and pretty fine-grained
+          # locking. Note that "single frame" methods do not need this kind of synchronization. MK.
+          channel.synchronize do
+            frames.each { |frame| self.send_frame(frame) }
+          end
         end # send_frameset(frames)
 
 
@@ -274,18 +285,166 @@ module AMQ
         end # vhost
 
 
+
+        # @group Error Handling and Recovery
+
+        # Called when initial TCP connection fails.
+        # @api public
+        def tcp_connection_failed
+          @recovered = false
+
+          @on_tcp_connection_failure.call(@settings) if @on_tcp_connection_failure
+        end
+
         # Called when previously established TCP connection fails.
         # @api public
         def tcp_connection_lost
+          @recovered = false
+
           @on_tcp_connection_loss.call(self, @settings) if @on_tcp_connection_loss
+          self.handle_connection_interruption
         end
 
-        # Called when initial TCP connection fails.
+        # @return [Boolean]
+        def reconnecting?
+          @reconnecting
+        end # reconnecting?
+
+
+        # Defines a callback that will be run when initial TCP connection fails.
+        # You can define only one callback.
+        #
         # @api public
-        def tcp_connection_failed
-          @on_tcp_connection_failure.call(@settings) if @on_tcp_connection_failure
+        def on_tcp_connection_failure(&block)
+          @on_tcp_connection_failure = block
         end
 
+        # Defines a callback that will be run when TCP connection to AMQP broker is lost (interrupted).
+        # You can define only one callback.
+        #
+        # @api public
+        def on_tcp_connection_loss(&block)
+          @on_tcp_connection_loss = block
+        end
+
+        # Defines a callback that will be run when TCP connection is closed before authentication
+        # finishes. Usually this means authentication failure. You can define only one callback.
+        #
+        # @api public
+        def on_possible_authentication_failure(&block)
+          @on_possible_authentication_failure = block
+        end
+
+
+        # Defines a callback that will be executed when connection is closed after
+        # connection-level exception. Only one callback can be defined (the one defined last
+        # replaces previously added ones).
+        #
+        # @api public
+        def on_error(&block)
+          self.redefine_callback(:error, &block)
+        end
+
+
+        # Defines a callback that will be executed after TCP connection is interrupted (typically because of a network failure).
+        # Only one callback can be defined (the one defined last replaces previously added ones).
+        #
+        # @api public
+        def on_connection_interruption(&block)
+          self.redefine_callback(:after_connection_interruption, &block)
+        end # on_connection_interruption(&block)
+        alias after_connection_interruption on_connection_interruption
+
+
+        # @private
+        # @api plugin
+        def handle_connection_interruption
+          @channels.each { |n, c| c.handle_connection_interruption }
+          self.exec_callback_yielding_self(:after_connection_interruption)
+        end # handle_connection_interruption
+
+
+
+        # Defines a callback that will be executed after TCP connection has recovered after a network failure
+        # but before AMQP connection is re-opened.
+        # Only one callback can be defined (the one defined last replaces previously added ones).
+        #
+        # @api public
+        def before_recovery(&block)
+          self.redefine_callback(:before_recovery, &block)
+        end # before_recovery(&block)
+
+        # @private
+        def run_before_recovery_callbacks
+          self.exec_callback_yielding_self(:before_recovery, @settings)
+
+          @channels.each { |n, ch| ch.run_before_recovery_callbacks }
+        end
+
+
+        # Defines a callback that will be executed after AMQP connection has recovered after a network failure..
+        # Only one callback can be defined (the one defined last replaces previously added ones).
+        #
+        # @api public
+        def on_recovery(&block)
+          self.redefine_callback(:after_recovery, &block)
+        end # on_recovery(&block)
+        alias after_recovery on_recovery
+
+        # @private
+        def run_after_recovery_callbacks
+          self.exec_callback_yielding_self(:after_recovery, @settings)
+
+          @channels.each { |n, ch| ch.run_after_recovery_callbacks }
+        end
+
+
+        # @return [Boolean] whether connection is in the automatic recovery mode
+        # @api public
+        def auto_recovering?
+          !!@auto_recovery
+        end # auto_recovering?
+        alias auto_recovery? auto_recovering?
+
+
+        # Performs recovery of channels that are in the automatic recovery mode. Does not run recovery
+        # callbacks.
+        #
+        # @see Channel#auto_recover
+        # @see Queue#auto_recover
+        # @see Exchange#auto_recover
+        # @api plugin
+        def auto_recover
+          @channels.select { |channel_id, ch| ch.auto_recovering? }.each { |n, ch| ch.auto_recover }
+        end # auto_recover
+
+
+        # Performs recovery of channels that are in the automatic recovery mode. "before recovery" callbacks
+        # are run immediately, "after recovery" callbacks are run after AMQP connection is re-established and
+        # auto recovery is performed (using #auto_recover).
+        #
+        # Use this method if you want to run automatic recovery process after handling a connection-level exception,
+        # for example, 320 CONNECTION_FORCED (used by RabbitMQ when it is shut down gracefully).
+        #
+        # @see Channel#auto_recover
+        # @see Queue#auto_recover
+        # @see Exchange#auto_recover
+        # @api plugin
+        def start_automatic_recovery
+          self.run_before_recovery_callbacks
+          self.register_connection_callback do
+            # always run automatic recovery, because it is per-channel
+            # and connection has to start it. Channels that did not opt-in for
+            # autorecovery won't be selected. MK.
+            self.auto_recover
+            self.run_after_recovery_callbacks
+          end
+        end # start_automatic_recovery
+
+
+        # @endgroup
+
+
 
 
         #
@@ -298,7 +457,7 @@ module AMQ
         # @note This must be implemented by all AMQP clients.
         # @api plugin
         def send_raw(data)
-          raise MissingInterfaceMethodError.new("AMQ::Client#send_raw(data)")
+          raise NotImplementedError
         end
 
         # Sends connection preamble to the broker.
@@ -358,7 +517,8 @@ module AMQ
             @last_server_heartbeat = Time.now
           else
             if callable = AMQ::Client::HandlersRegistry.find(frame.method_class)
-              callable.call(self, frames.first, frames[1..-1])
+              f = frames.shift
+              callable.call(self, f, frames)
             else
               raise MissingHandlerError.new(frames.first)
             end
@@ -380,20 +540,6 @@ module AMQ
 
 
 
-        # @group Error handling
-
-        # Defines a callback that will be executed when channel is closed after
-        # channel-level exception. Only one callback can be defined (the one defined last
-        # replaces previously added ones).
-        #
-        # @api public
-        def on_error(&block)
-          self.redefine_callback(:error, &block)
-        end
-
-        # @endgroup
-
-
 
 
         # Handles connection.start.
@@ -449,8 +595,6 @@ module AMQ
         # @api plugin
         # @see http://bit.ly/htCzCX AMQP 0.9.1 protocol documentation (Section 1.5.2.9)
         def handle_close(conn_close)
-          self.handle_connection_interruption
-
           closed!
           # TODO: use proper exception class, provide protocol class (we know conn_close.class_id and conn_close.method_id) as well!
           self.exec_callback_yielding_self(:error, conn_close)
@@ -466,11 +610,6 @@ module AMQ
           self.disconnection_successful
         end # handle_close_ok(close_ok)
 
-        # @api plugin
-        def handle_connection_interruption
-          @channels.each { |n, c| c.handle_connection_interruption }
-        end # handle_connection_interruption
-
 
 
         protected

data/lib/amq/client/async/adapters/coolio.rb

@@ -122,6 +122,8 @@ module AMQ
           @locale            = @settings.fetch(:locale, "en_GB")
           @client_properties = Settings.client_properties.merge(@settings.fetch(:client_properties, Hash.new))
 
+          @auto_recovery     = (!!@settings[:auto_recovery])
+
           socket
         end
 
@@ -276,6 +278,21 @@ module AMQ
 
         # @api private
         def post_init
+          if @had_successfully_connected_before
+            @recovered = true
+
+            self.exec_callback_yielding_self(:before_recovery, @settings)
+
+            self.register_connection_callback do
+              self.auto_recover
+              self.exec_callback_yielding_self(:after_recovery, @settings)
+            end
+          end
+
+          # now we can set it. MK.
+          @had_successfully_connected_before = true
+          @reconnecting                     = false
+
           self.reset
           self.handshake
         end
@@ -285,7 +302,7 @@ module AMQ
           @chunk_buffer = ""
           @frames       = Array.new
         end
-      end # CoolioClient      
+      end # CoolioClient
     end # Async
   end # Client
 end # AMQ

data/lib/amq/client/async/adapters/event_machine.rb

@@ -21,6 +21,8 @@ module AMQ
         # API
         #
 
+        # @group Connection operations
+
         # Initiates connection to AMQP broker. If callback is given, runs it when (and if) AMQP connection
         # succeeds.
         #
@@ -60,15 +62,42 @@ module AMQ
 
           if !@reconnecting
             @reconnecting = true
+            self.reset
+          end
+
+          EventMachine.reconnect(@settings[:host], @settings[:port], self)
+        end
 
-            self.handle_connection_interruption
+        # Similar to #reconnect, but uses different connection settings
+        # @see #reconnect
+        # @api public
+        def reconnect_to(settings, period = 5)
+          if !@reconnecting
+            @reconnecting = true
             self.reset
           end
 
+          @settings = Settings.configure(settings)
           EventMachine.reconnect(@settings[:host], @settings[:port], self)
         end
 
 
+        # Periodically try to reconnect.
+        #
+        # @param [Fixnum]  period Period of time, in seconds, to wait before reconnection attempt.
+        # @param [Boolean] force  If true, enforces immediate reconnection.
+        # @api public
+        def periodically_reconnect(period = 5)
+          @reconnecting = true
+          self.reset
+
+          @periodic_reconnection_timer = EventMachine::PeriodicTimer.new(period) {
+            EventMachine.reconnect(@settings[:host], @settings[:port], self)
+          }
+        end
+
+        # @endgroup
+
 
 
 
@@ -92,30 +121,6 @@ module AMQ
         end # on_closed(&block)
         alias on_disconnection on_closed
 
-        # Defines a callback that will be run when initial TCP connection fails.
-        # You can define only one callback.
-        #
-        # @api public
-        def on_tcp_connection_failure(&block)
-          @on_tcp_connection_failure = block
-        end
-
-        # Defines a callback that will be run when TCP connection to AMQP broker is lost (interrupted).
-        # You can define only one callback.
-        #
-        # @api public
-        def on_tcp_connection_loss(&block)
-          @on_tcp_connection_loss = block
-        end
-
-        # Defines a callback that will be run when TCP connection is closed before authentication
-        # finishes. Usually this means authentication failure. You can define only one callback.
-        #
-        # @api public
-        def on_possible_authentication_failure(&block)
-          @on_possible_authentication_failure = block
-        end
-
         # @see #on_open
         # @private
         def register_connection_callback(&block)
@@ -162,6 +167,8 @@ module AMQ
           @locale            = @settings.fetch(:locale, "en_GB")
           @client_properties = Settings.client_properties.merge(@settings.fetch(:client_properties, Hash.new))
 
+          @auto_recovery     = (!!@settings[:auto_recovery])
+
           self.reset
           self.set_pending_connect_timeout((@settings[:timeout] || 3).to_f) unless defined?(JRUBY_VERSION)
 
@@ -203,8 +210,6 @@ module AMQ
 
 
 
-
-
         #
         # Implementation
         #
@@ -243,11 +248,22 @@ module AMQ
           # software that calls #post_init before #unbind even when TCP connection
           # fails. MK.
           @tcp_connection_established       = true
+          @periodic_reconnection_timer.cancel if @periodic_reconnection_timer
+
+
           # again, this is because #unbind is called in different situations
           # and there is no easy way to tell initial connection failure
           # from connection loss. Not in EventMachine 0.12.x, anyway. MK.
-          @had_successfull_connected_before = true
 
+          if @had_successfully_connected_before
+            @recovered = true
+
+
+            self.start_automatic_recovery
+          end
+
+          # now we can set it. MK.
+          @had_successfully_connected_before = true
           @reconnecting                     = false
 
           self.handshake
@@ -268,7 +284,7 @@ module AMQ
         # * Initial TCP connection fails
         # @private
         def unbind(exception = nil)
-          if !@tcp_connection_established && !@had_successfull_connected_before && !@intentionally_closing_connection
+          if !@tcp_connection_established && !@had_successfully_connected_before && !@intentionally_closing_connection
             @tcp_connection_failed = true
             self.tcp_connection_failed
           end
@@ -276,13 +292,13 @@ module AMQ
           closing!
           @tcp_connection_established = false
 
-          self.handle_connection_interruption
+          self.handle_connection_interruption if @reconnecting
           @disconnection_deferrable.succeed
 
           closed!
 
 
-          self.tcp_connection_lost if !@intentionally_closing_connection && @had_successfull_connected_before
+          self.tcp_connection_lost if !@intentionally_closing_connection && @had_successfully_connected_before
 
           # since AMQP spec dictates that authentication failure is a protocol exception
           # and protocol exceptions result in connection closure, check whether we are
@@ -386,7 +402,7 @@ module AMQ
             start_tls
           end
         end # upgrade_to_tls_if_necessary
-      end # EventMachineClient      
+      end # EventMachineClient
     end # Async
   end # Client
 end # AMQ