amq-client 0.7.0.alpha25 → 0.7.0.alpha26

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

@@ -13,6 +13,19 @@ module AMQ
     # cool.io style.
     #
     class CoolioClient
+
+      #
+      # Behaviors
+      #
+
+      include AMQ::Client::Adapter
+
+
+      #
+      # API
+      #
+
+
       #
       # Cool.io socket delegates most of its operations to the parent adapter.
       # Thus, 99.9% of the time you don't need to deal with this class.
@@ -73,17 +86,7 @@ module AMQ
         end
       end
 
-      #
-      # Behaviors
-      #
 
-      include AMQ::Client::Adapter
-      include AMQ::Client::Callbacks
-
-
-      #
-      # API
-      #
 
       # Cool.io socket for multiplexing et al.
       #
@@ -93,11 +96,6 @@ module AMQ
       # Hash with available callbacks
       attr_accessor :callbacks
 
-      # AMQP connections
-      #
-      # @see AMQ::Client::Connection
-      attr_accessor :connections
-
       # Creates a socket and attaches it to cool.io default loop.
       #
       # Called from CoolioClient.connect
@@ -106,9 +104,24 @@ module AMQ
       # @param [Hash] connection settings
       # @api private
       def establish_connection(settings)
-        socket = Socket.connect(self, settings[:host], settings[:port])
+        @settings     = Settings.configure(settings)
+
+        socket = Socket.connect(self, @settings[:host], @settings[:port])
         socket.attach(Cool.io::Loop.default)
         self.socket = socket
+
+
+        @on_tcp_connection_failure          = @settings[:on_tcp_connection_failure] || Proc.new { |settings|
+          raise self.class.tcp_connection_failure_exception_class.new(settings)
+        }
+        @on_possible_authentication_failure = @settings[:on_possible_authentication_failure] || Proc.new { |settings|
+          raise self.class.authentication_failure_exception_class.new(settings)
+        }
+
+        @locale            = @settings.fetch(:locale, "en_GB")
+        @client_properties = Settings.client_properties.merge(@settings.fetch(:client_properties, Hash.new))
+
+        socket
       end
 
       # Registers on_open callback
@@ -127,11 +140,13 @@ module AMQ
         # Be careful with default values for #ruby hashes: h = Hash.new(Array.new); h[:key] ||= 1
         # won't assign anything to :key. MK.
         @callbacks   = {}
-        @connections = []
-        super
-        if settings[:on_tcp_connection_failure]
-          on_tcp_connection_failure(&settings.delete(:on_tcp_connection_failure))
-        end
+
+        self.logger   = self.class.logger
+
+        @frames            = Array.new
+        @channels          = Hash.new
+
+        @mechanism         = "PLAIN"
       end
 
       # Sets a callback for successful connection (after we receive open-ok)
@@ -177,16 +192,6 @@ module AMQ
       end
 
 
-      # Called by Socket if it could not connect.
-      #
-      # @api private
-      def tcp_connection_failed
-        if has_callback?(:tcp_connection_failure)
-          exec_callback_yielding_self(:tcp_connection_failure)
-        else
-          raise self.class.tcp_connection_failure_exception_class.new(settings)
-        end
-      end # tcp_connection_failed
 
       # Called when socket is connected but before handshake is done
       #
@@ -201,6 +206,35 @@ module AMQ
       def socket_disconnected
       end
 
+      alias close disconnect
+
+
+      self.handle(Protocol::Connection::Start) do |connection, frame|
+        connection.start_ok(frame.decode_payload)
+      end
+
+      self.handle(Protocol::Connection::Tune) do |connection, frame|
+        connection.handle_tune(frame.decode_payload)
+
+        connection.open(connection.vhost)
+      end
+
+      self.handle(Protocol::Connection::OpenOk) do |connection, frame|
+        connection.handle_open_ok(frame.decode_payload)
+      end
+
+      self.handle(Protocol::Connection::Close) do |connection, frame|
+        connection.handle_close(frame.decode_payload)
+      end
+
+      self.handle(Protocol::Connection::CloseOk) do |connection, frame|
+        connection.handle_close_ok(frame.decode_payload)
+      end
+
+
+
+
+
       # Sends raw data through the socket
       #
       # @param [String] binary data
@@ -209,6 +243,7 @@ module AMQ
         socket.send_raw data
       end
 
+
       # The story about the buffering is kinda similar to EventMachine,
       # you keep receiving more than one frame in a single packet.
       #
@@ -240,32 +275,15 @@ module AMQ
 
       # @api private
       def post_init
-        reset
-        handshake
+        self.reset
+        self.handshake
       end
 
       # @api private
       def reset
         @chunk_buffer = ""
+        @frames       = Array.new
       end
-
-      # Returns next frame from buffer whenever possible
-      #
-      # @api private
-      def get_next_frame
-        return nil unless @chunk_buffer.size > 7 # otherwise, cannot read the length
-        # octet + short
-        offset = 1 + 2
-        # length
-        payload_length = @chunk_buffer[offset, 4].unpack('N')[0]
-        # 4 bytes for long payload length, 1 byte final octet
-        frame_length = offset + 4 + payload_length + 1
-        if frame_length <= @chunk_buffer.size
-          @chunk_buffer.slice!(0, frame_length)
-        else
-          nil
-        end
-      end
-    end
-  end
-end
+    end # CoolioClient
+  end # Client
+end # AMQ

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

@@ -7,10 +7,6 @@ require "amq/client/framing/string/frame"
 module AMQ
   module Client
     class EventMachineClient < EM::Connection
-      # @private
-      class Deferrable
-        include EventMachine::Deferrable
-      end
 
       #
       # Behaviors
@@ -23,10 +19,7 @@ module AMQ
       # API
       #
 
-      attr_reader :connections
-
-
-      def self.connect(settings = nil, &block)
+      def self.connect(settings = {}, &block)
         @settings = Settings.configure(settings)
 
         instance = EventMachine.connect(@settings[:host], @settings[:port], self, @settings)
@@ -50,7 +43,8 @@ module AMQ
 
         if !@reconnecting
           @reconnecting = true
-          @connections.each { |c| c.handle_connection_interruption }
+
+          self.handle_connection_interruption
           self.reset
         end
 
@@ -58,6 +52,9 @@ module AMQ
       end
 
 
+
+
+
       # Defines a callback that will be executed when AMQP connection is considered open:
       # client and broker has agreed on max channel identifier and maximum allowed frame
       # size and authentication succeeds. You can define more than one callback.
@@ -116,10 +113,18 @@ module AMQ
       end
 
 
+
+
       def initialize(*args)
         super(*args)
+
+        self.logger   = self.class.logger
+
+        @frames            = Array.new
+        @channels          = Hash.new
+
         opening!
-        @connections                        = Array.new
+
         # track TCP connection state, used to detect initial TCP connection failures.
         @tcp_connection_established       = false
         @tcp_connection_failed            = false
@@ -127,7 +132,7 @@ module AMQ
 
         # EventMachine::Connection's and Adapter's constructors arity
         # make it easier to use *args. MK.
-        @settings                           = args.first
+        @settings                           = Settings.configure(args.first)
         @on_tcp_connection_failure          = @settings[:on_tcp_connection_failure] || Proc.new { |settings|
           raise self.class.tcp_connection_failure_exception_class.new(settings)
         }
@@ -135,9 +140,11 @@ module AMQ
           raise self.class.authentication_failure_exception_class.new(settings)
         }
 
+        @mechanism         = "PLAIN"
+        @locale            = @settings.fetch(:locale, "en_GB")
+        @client_properties = Settings.client_properties.merge(@settings.fetch(:client_properties, Hash.new))
 
         self.reset
-
         self.set_pending_connect_timeout((@settings[:timeout] || 3).to_f) unless defined?(JRUBY_VERSION)
 
         if self.heartbeat_interval > 0
@@ -147,7 +154,17 @@ module AMQ
       end # initialize(*args)
 
 
-      alias send_raw send_data
+
+      # For EventMachine adapter, this is a no-op.
+      # @api public
+      def establish_connection(settings)
+        # Unfortunately there doesn't seem to be any sane way
+        # how to get EventMachine connect to the instance level.
+      end
+
+      alias close disconnect
+
+
 
       # Whether we are in authentication state (after TCP connection was estabilished
       # but before broker authenticated us).
@@ -165,12 +182,8 @@ module AMQ
         @tcp_connection_established
       end # tcp_connection_established?
 
-      # For EventMachine adapter, this is a no-op.
-      # @api public
-      def establish_connection(settings)
-        # Unfortunately there doesn't seem to be any sane way
-        # how to get EventMachine connect to the instance level.
-      end
+
+
 
 
 
@@ -178,6 +191,13 @@ module AMQ
       # Implementation
       #
 
+      # Backwards compatibility with 0.7.0.a25. MK.
+      Deferrable = EventMachine::DefaultDeferrable
+
+
+      alias send_raw send_data
+
+
       # EventMachine reactor callback. Is run when TCP connection is estabilished
       # but before resumption of the network loop. Note that this includes cases
       # when TCP connection has failed.
@@ -196,6 +216,8 @@ module AMQ
         raise error
       end # post_init
 
+
+
       # Called by EventMachine reactor once TCP connection is successfully estabilished.
       # @private
       def connection_completed
@@ -236,7 +258,7 @@ module AMQ
         closing!
         @tcp_connection_established = false
 
-        @connections.each { |c| c.handle_connection_interruption }
+        self.handle_connection_interruption
         @disconnection_deferrable.succeed
 
         closed!
@@ -283,38 +305,43 @@ module AMQ
       def disconnection_successful
         @disconnection_deferrable.succeed
 
-        self.close_connection
+        # true for "after writing buffered data"
+        self.close_connection(true)
         self.reset
         closed!
       end # disconnection_successful
 
 
-      # Called when previously established TCP connection fails.
-      # @api public
-      def tcp_connection_lost
-        @on_tcp_connection_loss.call(self, @settings) if @on_tcp_connection_loss
+
+
+
+      self.handle(Protocol::Connection::Start) do |connection, frame|
+        connection.start_ok(frame.decode_payload)
       end
 
-      # Called when initial TCP connection fails.
-      # @api public
-      def tcp_connection_failed
-        @on_tcp_connection_failure.call(@settings) if @on_tcp_connection_failure
+      self.handle(Protocol::Connection::Tune) do |connection, frame|
+        connection.handle_tune(frame.decode_payload)
+
+        connection.open(connection.vhost)
       end
 
+      self.handle(Protocol::Connection::OpenOk) do |connection, frame|
+        connection.handle_open_ok(frame.decode_payload)
+      end
 
-      protected
+      self.handle(Protocol::Connection::Close) do |connection, frame|
+        connection.handle_close(frame.decode_payload)
+      end
 
-      def handshake(mechanism = "PLAIN", response = nil, locale = "en_GB")
-        username = @settings[:user] || @settings[:username]
-        password = @settings[:pass] || @settings[:password]
+      self.handle(Protocol::Connection::CloseOk) do |connection, frame|
+        connection.handle_close_ok(frame.decode_payload)
+      end
 
-        # self.logger.info "[authentication] Credentials are #{username}/#{'*' * password.bytesize}"
 
-        self.connection = AMQ::Client::Connection.new(self, mechanism, self.encode_credentials(username, password), locale)
 
-        @authenticating = true
-        self.send_preamble
-      end
+
+      protected
+
 
       def reset
         @size    = 0
@@ -322,8 +349,8 @@ module AMQ
         @frames  = Array.new
 
         @chunk_buffer                 = ""
-        @connection_deferrable        = Deferrable.new
-        @disconnection_deferrable     = Deferrable.new
+        @connection_deferrable        = EventMachine::DefaultDeferrable.new
+        @disconnection_deferrable     = EventMachine::DefaultDeferrable.new
 
         # used to track down whether authentication succeeded. AMQP 0.9.1 dictates
         # that on authentication failure broker must close TCP connection without sending
@@ -332,26 +359,6 @@ module AMQ
         @authenticating           = false
       end
 
-      # @see http://tools.ietf.org/rfc/rfc2595.txt RFC 2595
-      def encode_credentials(username, password)
-        "\0#{username}\0#{password}"
-      end # encode_credentials(username, password)
-
-      def get_next_frame
-        return unless @chunk_buffer.size > 7 # otherwise, cannot read the length
-        # octet + short
-        offset = 3 # 1 + 2
-        # length
-        payload_length = @chunk_buffer[offset, 4].unpack('N')[0]
-        # 5: 4 bytes for long payload length, 1 byte final octet
-        frame_length = offset + 5 + payload_length
-        if frame_length <= @chunk_buffer.size
-          @chunk_buffer.slice!(0, frame_length)
-        else
-          nil
-        end
-      end # get_next_frame
-
       def upgrade_to_tls_if_necessary
         tls_options = @settings[:ssl]
 

data/lib/amq/client/callbacks.rb

@@ -33,23 +33,32 @@ module AMQ
 
 
       def exec_callback(name, *args, &block)
-        callbacks = Array(self.callbacks[name])
-        callbacks.map { |c| c.call(*args, &block) } if callbacks.any?
+        list = Array(self.callbacks[name])
+        if list.any?
+          list.each { |c| c.call(*args, &block) }
+        end
       end
 
       def exec_callback_once(name, *args, &block)
-        callbacks = Array(self.callbacks.delete(name))
-        callbacks.map { |c| c.call(*args, &block) } if callbacks.any?
+        list = (self.callbacks.delete(name) || Array.new)
+        if list.any?
+          list.each { |c| c.call(*args, &block) }
+        end
       end
 
       def exec_callback_yielding_self(name, *args, &block)
-        callbacks = Array(self.callbacks[name])
-        callbacks.map { |c| c.call(self, *args, &block) } if callbacks.any?
+        list = Array(self.callbacks[name])
+        if list.any?
+          list.each { |c| c.call(self, *args, &block) }
+        end
       end
 
       def exec_callback_once_yielding_self(name, *args, &block)
-        callbacks = Array(self.callbacks.delete(name))
-        callbacks.map { |c| c.call(self, *args, &block) } if callbacks.any?
+        list = (self.callbacks.delete(name) || Array.new)
+
+        if list.any?
+          list.each { |c| c.call(self, *args, &block) }
+        end
       end
 
       def has_callback?(name)
@@ -57,4 +66,4 @@ module AMQ
       end # has_callback?
     end # Callbacks
   end # Client
-end # AMQ
+end # AMQ