amq-client 0.5.0

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

@@ -0,0 +1,221 @@
+# encoding: utf-8
+
+# http://coolio.github.com
+
+require "cool.io"
+require "amq/client"
+
+require "amq/client/framing/string/frame"
+
+module AMQ
+  module Client
+    class Coolio
+      class Socket < ::Coolio::TCPSocket
+        attr_accessor :adapter
+
+        def self.connect(adapter, host, port)
+          socket = super(host, port)
+          socket.adapter = adapter
+          socket
+        end
+
+        def on_connect
+          #puts "On connect"
+          adapter.on_socket_connect
+        end
+
+        def on_read(data)
+          # puts "Received data"
+          # puts_data(data)
+          adapter.on_read(data)
+        end
+
+        # This handler should never trigger in normal circumstances
+        def on_close
+          adapter.on_socket_disconnect
+        end
+
+        def send_raw(data)
+          # puts "Sending data"
+          # puts_data(data)
+          write(data)
+        end
+
+        protected
+        def puts_data(data)
+          puts "    As string:     #{data.inspect}"
+          puts "    As byte array: #{data.bytes.to_a.inspect}"
+        end
+      end
+
+      # Behaviors
+      include AMQ::Client::Adapter
+
+      self.sync = false
+
+      # API
+      attr_accessor :socket
+      attr_accessor :callbacks
+      attr_accessor :connections
+
+      class << self
+        def connect(settings, &block)
+          settings        = self.settings.merge(settings)
+          host, port      = settings[:host], settings[:port]
+          instance        = new
+          socket          = Socket.connect(instance, settings[:host], settings[:port])
+          socket.attach Cool.io::Loop.default
+          instance.socket = socket
+          instance.on_connection(&block)
+          instance
+        end
+      end
+
+      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   = {}
+        @connections = []
+        super
+      end
+
+      # sets a callback for connection
+      def on_connection(&block)
+        define_callback :connect, &block
+      end
+
+      # sets a callback for disconnection
+      def on_disconnection(&block)
+        define_callback :disconnect, &block
+      end
+
+      def on_open(&block)
+        define_callback :open, &block
+      end # on_open(&block)
+
+
+      # called by AMQ::Client::Connection after we receive connection.open-ok.
+      def connection_successful
+        exec_callback_yielding_self(:connect)
+      end
+
+      # called by AMQ::Client::Connection after we receive connection.close-ok.
+      def disconnection_successful
+        exec_callback_yielding_self(:disconnect)
+        close_connection
+      end
+
+      def open_successful
+        @authenticating = false
+        exec_callback_yielding_self(:open)
+      end # open_successful
+
+
+      # triggered when socket is connected but before handshake is done
+      def on_socket_connect
+        post_init
+      end
+
+      # triggered after socket is closed
+      def on_socket_disconnect
+      end
+
+      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.
+      def on_read(chunk)
+        @chunk_buffer << chunk
+        while frame = get_next_frame
+          receive_frame(AMQ::Client::Framing::String::Frame.decode(frame))
+        end
+      end
+
+      def close_connection
+        @socket.close
+      end
+
+
+
+      #
+      # Callbacks
+      #
+
+      def redefine_callback(event, callable = nil, &block)
+        f = (callable || block)
+        # yes, re-assign!
+        @callbacks[event] = [f]
+
+        self
+      end
+
+      def define_callback(event, callable = nil, &block)
+        f = (callable || block)
+        @callbacks[event] ||= []
+
+        @callbacks[event] << f if f
+
+        self
+      end # define_callback(event, &block)
+      alias append_callback define_callback
+
+      def prepend_callback(event, &block)
+        @callbacks[event] ||= []
+        @callbacks[event].unshift(block)
+
+        self
+      end # prepend_callback(event, &block)
+
+
+      def exec_callback(name, *args, &block)
+        callbacks = Array(self.callbacks[name])
+        callbacks.map { |c| c.call(*args, &block) } if callbacks.any?
+      end
+
+      def exec_callback_once(name, *args, &block)
+        callbacks = Array(self.callbacks.delete(name))
+        callbacks.map { |c| c.call(*args, &block) } if callbacks.any?
+      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?
+      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?
+      end
+
+
+
+      protected
+
+      def post_init
+        reset
+        handshake
+      end
+
+      def reset
+        @chunk_buffer = ""
+      end
+
+      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

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

@@ -0,0 +1,228 @@
+# encoding: utf-8
+
+require "amq/client"
+require "amq/client/channel"
+require "amq/client/exchange"
+require "amq/client/framing/string/frame"
+
+require "eventmachine"
+
+module AMQ
+  module Client
+    class EventMachineClient < EM::Connection
+
+      class Deferrable
+        include EventMachine::Deferrable
+      end
+
+      #
+      # Behaviors
+      #
+
+      include AMQ::Client::Adapter
+
+      self.sync = false
+
+      register_entity :channel,  AMQ::Client::Channel
+      register_entity :exchange, AMQ::Client::Exchange
+
+      #
+      # API
+      #
+
+      def self.connect(settings = nil, &block)
+        settings = AMQ::Client::Settings.configure(settings)
+        instance = EM.connect(settings[:host], settings[:port], self, settings)
+
+        unless block.nil?
+          # delay calling block we were given till after we receive
+          # connection.open-ok. Connection will notify us when
+          # that happens.
+          instance.on_connection do
+            block.call(instance)
+          end
+        end
+
+        instance
+      end
+
+
+      attr_reader :connections
+
+
+      def initialize(*args)
+        super(*args)
+
+        # EventMachine::Connection's and Adapter's constructors arity
+        # make it easier to use *args. MK.
+        @settings                 = args.first
+        @connections              = Array.new
+        @on_possible_authentication_failure = @settings[:on_possible_authentication_failure]
+
+        @chunk_buffer             = ""
+        @connection_deferrable    = Deferrable.new
+        @disconnection_deferrable = Deferrable.new
+
+        @authenticating           = false
+
+        # succeeds when connection is open, that is, vhost is selected
+        # and client is given green light to proceed.
+        @connection_opened_deferrable = Deferrable.new
+
+        @tcp_connection_established   = false
+
+        if self.heartbeat_interval > 0
+          @last_server_heartbeat = Time.now
+          EM.add_periodic_timer(self.heartbeat_interval, &method(:send_heartbeat))
+        end
+      end # initialize(*args)
+
+
+      def establish_connection(settings)
+        # an intentional no-op
+      end
+
+      alias send_raw send_data
+
+
+      def authenticating?
+        @authenticating
+      end # authenticating?
+
+      def tcp_connection_established?
+        @tcp_connection_established
+      end # tcp_connection_established?
+
+      #
+      # Implementation
+      #
+
+      def post_init
+        reset
+
+        @tcp_connection_established = true
+
+        self.handshake
+      rescue Exception => error
+        raise error
+      end # post_init
+
+      #
+      # 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.
+      #
+      def receive_data(chunk)
+        @chunk_buffer << chunk
+        while frame = get_next_frame
+          self.receive_frame(AMQ::Client::Framing::String::Frame.decode(frame))
+        end
+      end
+
+      def unbind
+        closing!
+
+        @tcp_connection_established = false
+
+        @connections.each { |c| c.on_connection_interruption }
+        @disconnection_deferrable.succeed
+
+        closed!
+
+        # 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?
+          if sync?
+            raise PossibleAuthenticationFailureError.new(@settings)
+          else
+            @on_possible_authentication_failure.call(@settings) if @on_possible_authentication_failure
+          end
+        end
+      end # unbind
+
+
+
+      def on_connection(&block)
+        @connection_deferrable.callback(&block)
+      end # on_connection(&block)
+
+      # called by AMQ::Client::Connection after we receive connection.open-ok.
+      def connection_successful
+        @connection_deferrable.succeed
+      end # connection_successful
+
+
+      def on_open(&block)
+        @connection_opened_deferrable.callback(&block)
+      end # on_open(&block)
+
+      def open_successful
+        @authenticating = false
+        @connection_opened_deferrable.succeed
+
+        opened!
+      end # open_successful
+
+
+      def on_disconnection(&block)
+        @disconnection_deferrable.callback(&block)
+      end # on_disconnection(&block)
+
+      # called by AMQ::Client::Connection after we receive connection.close-ok.
+      def disconnection_successful
+        @disconnection_deferrable.succeed
+
+        self.close_connection
+        closed!
+      end # disconnection_successful
+
+
+
+      def on_possible_authentication_failure(&block)
+        @on_possible_authentication_failure = block
+      end
+
+
+      protected
+
+      def handshake(mechanism = "PLAIN", response = nil, locale = "en_GB")
+        username = @settings[:user] || @settings[:username]
+        password = @settings[:pass] || @settings[:password]
+
+        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
+
+      def reset
+        @size    = 0
+        @payload = ""
+        @frames  = Array.new
+      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
+    end # EventMachineClient
+  end # Client
+end # AMQ

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

@@ -0,0 +1,89 @@
+# encoding: utf-8
+
+require "socket"
+require "amq/client"
+require "amq/client/channel"
+require "amq/client/exchange"
+require "amq/client/queue"
+require "amq/client/framing/io/frame"
+
+module AMQ
+  module Client
+    class SocketClient
+
+      #
+      # Behaviors
+      #
+
+      include AMQ::Client::Adapter
+
+      self.sync = true
+
+      register_entity :channel,  AMQ::Client::Channel
+      register_entity :exchange, AMQ::Client::Exchange
+      register_entity :queue,    AMQ::Client::Queue
+
+
+      #
+      # API
+      #
+
+      def establish_connection(settings)
+        # NOTE: this doesn't work with "localhost", I don't know why:
+        settings[:host] = "127.0.0.1" if settings[:host] == "localhost"
+        @socket         = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+        sockaddr        = Socket.pack_sockaddr_in(settings[:port], settings[:host])
+
+        @socket.connect(sockaddr)
+      rescue Errno::ECONNREFUSED => exception
+        message = "Don't forget to start an AMQP broker first!\nThe original message: #{exception.message}"
+        raise exception.class.new(message)
+      rescue Exception => exception
+        self.disconnect if self.connected?
+        raise exception
+      end
+
+      def connection
+        @socket
+      end # connection
+
+      def connected?
+        @socket && !@socket.closed?
+      end
+
+      def close_connection
+        @socket.close
+      end
+
+      def send_raw(data)
+        @socket.write(data)
+      end
+
+      def receive
+        frame = AMQ::Client::Framing::IO::Frame.decode(@socket)
+        self.receive_frame(frame)
+        frame
+      end
+
+      def receive_async
+        # NOTE: this might work with Socket#eof? as well, it can be better ...
+        # self.receive unless @socket.eof?
+
+        @sockets ||= [@socket] # It'll be always only one socket, but we don't want to create many arrays, mind the GC!
+        array = IO.select(@sockets, nil, nil, nil)
+        array[0].each do |socket|
+          res = self.receive
+        end
+        res
+      end
+
+      def read_until_receives(klass)
+        if self.sync?
+          until (frame = self.receive) && frame.is_a?(Protocol::MethodFrame) && frame.method_class == klass
+            sleep 0.1
+          end
+        end
+      end
+    end
+  end
+end