amq-client 0.7.0.alpha34 → 0.7.0.alpha35

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

@@ -1,289 +1,11 @@
 # encoding: utf-8
 
-# http://coolio.github.com
-
-require "cool.io"
-require "amq/client"
-require "amq/client/framing/string/frame"
+require "amq/client/async/adapters/coolio"
 
 module AMQ
   module Client
-    #
-    # CoolioClient is a drop-in replacement for EventMachineClient, if you prefer
-    # 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.
-      #
-      # @api private
-      # @private
-      class Socket < ::Coolio::TCPSocket
-        attr_accessor :adapter
-
-        # Connects to given host/port and sets parent adapter.
-        #
-        # @param [CoolioClient]
-        # @param [String]
-        # @param [Fixnum]
-        def self.connect(adapter, host, port)
-          socket = super(host, port)
-          socket.adapter = adapter
-          socket
-        end
-
-        # Triggers socket_connect callback
-        def on_connect
-          #puts "On connect"
-          adapter.socket_connected
-        end
-
-        # Triggers on_read callback
-        def on_read(data)
-          # puts "Received data"
-          # puts_data(data)
-          adapter.receive_data(data)
-        end
-
-        # Triggers socket_disconnect callback
-        def on_close
-          adapter.socket_disconnected
-        end
-
-        # Triggers tcp_connection_failed callback
-        def on_connect_failed
-          adapter.tcp_connection_failed
-        end
-
-        # Sends raw data through the socket
-        #
-        # param [String] Binary data
-        def send_raw(data)
-          # puts "Sending data"
-          # puts_data(data)
-          write(data)
-        end
-
-        protected
-        # Debugging routine
-        def puts_data(data)
-          puts "    As string:     #{data.inspect}"
-          puts "    As byte array: #{data.bytes.to_a.inspect}"
-        end
-      end
-
-
-
-      # Cool.io socket for multiplexing et al.
-      #
-      # @private
-      attr_accessor :socket
-
-      # Hash with available callbacks
-      attr_accessor :callbacks
-
-      # Creates a socket and attaches it to cool.io default loop.
-      #
-      # Called from CoolioClient.connect
-      #
-      # @see AMQ::Client::Adapter::ClassMethods#connect
-      # @param [Hash] connection settings
-      # @api private
-      def establish_connection(settings)
-        @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
-      # @see #on_open
-      # @api private
-      def register_connection_callback(&block)
-        self.on_open(&block)
-      end
-
-      # Performs basic initialization. Do not use this method directly, use
-      # CoolioClient.connect instead
-      #
-      # @see AMQ::Client::Adapter::ClassMethods#connect
-      # @api private
-      def initialize
-        # Be careful with default values for #ruby hashes: h = Hash.new(Array.new); h[:key] ||= 1
-        # won't assign anything to :key. MK.
-        @callbacks    = Hash.new
-
-        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)
-      #
-      # @api public
-      def on_open(&block)
-        define_callback :connect, &block
-      end
-      alias on_connection on_open
-
-      # Sets a callback for disconnection (as in client-side disconnection)
-      #
-      # @api public
-      def on_closed(&block)
-        define_callback :disconnect, &block
-      end
-      alias on_disconnection on_closed
-
-      # Sets a callback for tcp connection failure (as in can't make initial connection)
-      def on_tcp_connection_failure(&block)
-        define_callback :tcp_connection_failure, &block
-      end
-
-
-      # Called by AMQ::Client::Connection after we receive connection.open-ok.
-      #
-      # @api private
-      def connection_successful
-        @authenticating = false
-        opened!
-
-        exec_callback_yielding_self(:connect)
-      end
-
-
-      # Called by AMQ::Client::Connection after we receive connection.close-ok.
-      #
-      # @api private
-      def disconnection_successful
-        exec_callback_yielding_self(:disconnect)
-        close_connection
-        closed!
-      end
-
-
-
-      # Called when socket is connected but before handshake is done
-      #
-      # @api private
-      def socket_connected
-        post_init
-      end
-
-      # Called after socket is closed
-      #
-      # @api private
-      def socket_disconnected
-      end
-
-      alias close disconnect
-
-
-      self.handle(Protocol::Connection::Start) do |connection, frame|
-        connection.handle_start(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
-      # @api private
-      def send_raw(data)
-        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.
-      #
-      # @param [String] chunk with binary data received. It could be one frame,
-      #   more than one frame or less than one frame.
-      # @api private
-      def receive_data(chunk)
-        @chunk_buffer << chunk
-        while frame = get_next_frame
-          receive_frame(AMQ::Client::Framing::String::Frame.decode(frame))
-        end
-      end
-
-      # Closes the socket.
-      #
-      # @api private
-      def close_connection
-        @socket.close
-      end
-
-      # Returns class used for tcp connection failures.
-      #
-      # @api private
-      def self.tcp_connection_failure_exception_class
-        AMQ::Client::TCPConnectionFailed
-      end # self.tcp_connection_failure_exception_class
-
-      protected
-
-      # @api private
-      def post_init
-        self.reset
-        self.handshake
-      end
-
-      # @api private
-      def reset
-        @chunk_buffer = ""
-        @frames       = Array.new
-      end
-    end # CoolioClient
+    # backwards compatibility
+    # @private
+    CoolioClient = Async::CoolioClient
   end # Client
 end # AMQ

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

@@ -1,389 +1,11 @@
 # encoding: utf-8
 
-require "eventmachine"
-require "amq/client"
-require "amq/client/framing/string/frame"
+require "amq/client/async/adapters/eventmachine"
 
 module AMQ
   module Client
-    class EventMachineClient < EM::Connection
-
-      #
-      # Behaviors
-      #
-
-      include AMQ::Client::Adapter
-
-
-      #
-      # API
-      #
-
-      # Initiates connection to AMQP broker. If callback is given, runs it when (and if) AMQP connection
-      # succeeds.
-      #
-      # @option settings [String] :host ("127.0.0.1") Hostname AMQ broker runs on.
-      # @option settings [String] :port (5672) Port AMQ broker listens on.
-      # @option settings [String] :vhost ("/") Virtual host to use.
-      # @option settings [String] :user ("guest") Username to use for authentication.
-      # @option settings [String] :pass ("guest") Password to use for authentication.
-      # @option settings [String] :ssl (false) Should be use TLS (SSL) for connection?
-      # @option settings [String] :timeout (nil) Connection timeout.
-      # @option settings [String] :logging (false) Turns logging on or off.
-      # @option settings [String] :broker (nil) Broker name (use if you intend to use broker-specific features).
-      # @option settings [Fixnum] :frame_max (131072) Maximum frame size to use. If broker cannot support frames this large, broker's maximum value will be used instead.
-      #
-      # @param [Hash] settings
-      def self.connect(settings = {}, &block)
-        @settings = Settings.configure(settings)
-
-        instance = EventMachine.connect(@settings[:host], @settings[:port], self, @settings)
-        instance.register_connection_callback(&block)
-
-        instance
-      end
-
-      # Reconnect after a period of wait.
-      #
-      # @param [Fixnum]  period Period of time, in seconds, to wait before reconnection attempt.
-      # @param [Boolean] force  If true, enforces immediate reconnection.
-      # @api public
-      def reconnect(force = false, period = 5)
-        if @reconnecting and not force
-          EventMachine::Timer.new(period) {
-            reconnect(true, period)
-          }
-          return
-        end
-
-        if !@reconnecting
-          @reconnecting = true
-
-          self.handle_connection_interruption
-          self.reset
-        end
-
-        EventMachine.reconnect(@settings[:host], @settings[:port], self)
-      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.
-      #
-      # @see on_possible_authentication_failure
-      # @api public
-      def on_open(&block)
-        @connection_deferrable.callback(&block)
-      end # on_open(&block)
-      alias on_connection on_open
-
-      # Defines a callback that will be run when broker confirms connection termination
-      # (client receives connection.close-ok). You can define more than one callback.
-      #
-      # @api public
-      def on_closed(&block)
-        @disconnection_deferrable.callback(&block)
-      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 initial TCP connection fails.
-      # 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)
-        unless block.nil?
-          # delay calling block we were given till after we receive
-          # connection.open-ok. Connection will notify us when
-          # that happens.
-          self.on_open do
-            block.call(self)
-          end
-        end
-      end
-
-
-
-
-      def initialize(*args)
-        super(*args)
-
-        self.logger   = self.class.logger
-
-        @frames            = Array.new
-        @channels          = Hash.new
-        @callbacks         = Hash.new
-
-        opening!
-
-        # track TCP connection state, used to detect initial TCP connection failures.
-        @tcp_connection_established       = false
-        @tcp_connection_failed            = false
-        @intentionally_closing_connection = false
-
-        # EventMachine::Connection's and Adapter's constructors arity
-        # make it easier to use *args. MK.
-        @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)
-        }
-        @on_possible_authentication_failure = @settings[:on_possible_authentication_failure] || Proc.new { |settings|
-          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
-          @last_server_heartbeat = Time.now
-          EventMachine.add_periodic_timer(self.heartbeat_interval, &method(:send_heartbeat))
-        end
-      end # initialize(*args)
-
-
-
-      # 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).
-      #
-      # @return [Boolean]
-      # @api public
-      def authenticating?
-        @authenticating
-      end # authenticating?
-
-      # IS TCP connection estabilished and currently active?
-      # @return [Boolean]
-      # @api public
-      def tcp_connection_established?
-        @tcp_connection_established
-      end # tcp_connection_established?
-
-
-
-
-
-
-      #
-      # 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.
-      # @private
-      def post_init
-        reset
-
-        # note that upgrading to TLS in #connection_completed causes
-        # Erlang SSL app that RabbitMQ relies on to report
-        # error on TCP connection <0.1465.0>:{ssl_upgrade_error,"record overflow"}
-        # and close TCP connection down. Investigation of this issue is likely
-        # to take some time and to not be worth in as long as #post_init
-        # works fine. MK.
-        upgrade_to_tls_if_necessary
-      rescue Exception => error
-        raise error
-      end # post_init
-
-
-
-      # Called by EventMachine reactor once TCP connection is successfully estabilished.
-      # @private
-      def connection_completed
-        # we only can safely set this value here because EventMachine is a lovely piece of
-        # software that calls #post_init before #unbind even when TCP connection
-        # fails. MK.
-        @tcp_connection_established       = true
-        # 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
-
-        @reconnecting                     = false
-
-        self.handshake
-      end
-
-      # @private
-      def close_connection(*args)
-        @intentionally_closing_connection = true
-
-        super(*args)
-      end
-
-      # Called by EventMachine reactor when
-      #
-      # * We close TCP connection down
-      # * Our peer closes TCP connection down
-      # * There is a network connection issue
-      # * Initial TCP connection fails
-      # @private
-      def unbind(exception = nil)
-        if !@tcp_connection_established && !@had_successfull_connected_before && !@intentionally_closing_connection
-          @tcp_connection_failed = true
-          self.tcp_connection_failed
-        end
-
-        closing!
-        @tcp_connection_established = false
-
-        self.handle_connection_interruption
-        @disconnection_deferrable.succeed
-
-        closed!
-
-
-        self.tcp_connection_lost if !@intentionally_closing_connection && @had_successfull_connected_before
-
-        # since AMQP spec dictates that authentication failure is a protocol exception
-        # and protocol exceptions result in connection closure, check whether we are
-        # in the authentication stage. If so, it is likely to signal an authentication
-        # issue. Java client behaves the same way. MK.
-        if authenticating? && !@intentionally_closing_connection
-          @on_possible_authentication_failure.call(@settings) if @on_possible_authentication_failure
-        end
-      end # unbind
-
-
-      #
-      # EventMachine receives data in chunks, sometimes those chunks are smaller
-      # than the size of AMQP frame. That's why you need to add some kind of buffer.
-      #
-      # @private
-      def receive_data(chunk)
-        @chunk_buffer << chunk
-        while frame = get_next_frame
-          self.receive_frame(AMQ::Client::Framing::String::Frame.decode(frame))
-        end
-      end
-
-
-      # Called by AMQ::Client::Connection after we receive connection.open-ok.
-      # @api public
-      def connection_successful
-        @authenticating = false
-        opened!
-
-        @connection_deferrable.succeed
-      end # connection_successful
-
-
-      # Called by AMQ::Client::Connection after we receive connection.close-ok.
-      #
-      # @api public
-      def disconnection_successful
-        @disconnection_deferrable.succeed
-
-        # true for "after writing buffered data"
-        self.close_connection(true)
-        self.reset
-        closed!
-      end # disconnection_successful
-
-
-
-
-
-      self.handle(Protocol::Connection::Start) do |connection, frame|
-        connection.handle_start(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
-
-
-
-
-      protected
-
-
-      def reset
-        @size      = 0
-        @payload   = ""
-        @frames    = Array.new
-
-        @chunk_buffer                 = ""
-        @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
-        # any more data. This is why we need to explicitly track whether we are past
-        # authentication stage to signal possible authentication failures.
-        @authenticating           = false
-      end
-
-      def upgrade_to_tls_if_necessary
-        tls_options = @settings[:ssl]
-
-        if tls_options.is_a?(Hash)
-          start_tls(tls_options)
-        elsif tls_options
-          start_tls
-        end
-      end # upgrade_to_tls_if_necessary
-    end # EventMachineClient
+    # backwards compatibility
+    # @private
+    EventMachineClient = Async::EventMachineClient
   end # Client
 end # AMQ