amq-client 0.7.0.alpha3 → 0.7.0.alpha4

data/.gitignore

@@ -6,3 +6,4 @@ doc/*
 .rvmrc
 # see http://bit.ly/h2WJPm for reasoning
 Gemfile.lock
+vendor

data/Gemfile

@@ -3,16 +3,17 @@
 source :rubygems
 
 # Use local clones if possible.
+# If you want to use your local copy, just symlink it to vendor.
 def custom_gem(name, options = Hash.new)
-  local_path = File.expand_path("../../#{name}", __FILE__)
-  if ENV["USE_AMQP_CUSTOM_GEMS"] && File.directory?(local_path)
+  local_path = File.expand_path("../vendor/#{name}", __FILE__)
+  if File.exist?(local_path)
     gem name, options.merge(:path => local_path).delete_if { |key, _| [:git, :branch].include?(key) }
   else
     gem name, options
   end
 end
 
-gem "eventmachine", "0.12.10" #, "1.0.0.beta.3"
+gem "eventmachine"
 # cool.io uses iobuffer that won't compile on JRuby
 # (and, probably, Windows)
 gem "cool.io", :platform => :ruby

data/amq-client.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |s|
   s.extra_rdoc_files = ["README.textile"] + Dir.glob("doc/*")
 
   # Dependencies
-  s.add_dependency "eventmachine", "~> 0.12.10"
+  s.add_dependency "eventmachine"
   s.add_dependency "amq-protocol"
 
 

data/examples/coolio_adapter/example_helper.rb

@@ -17,7 +17,7 @@ end
 
 
 def amq_client_example(description = "", &block)
-  AMQ::Client::Coolio.connect(:port => 5672, :vhost => "/amq_client_testbed") do |client|
+  AMQ::Client::CoolioClient.connect(:port => 5672, :vhost => "/amq_client_testbed") do |client|
     begin
       puts
       puts

data/examples/eventmachine_adapter/connection_loss_handler.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+__dir = File.join(File.dirname(File.expand_path(__FILE__)))
+require File.join(__dir, "example_helper")
+
+
+EM.run do
+  reconnector = Proc.new { |client, settings|
+    puts "Asked to reconnect to #{settings[:host]}:#{settings[:port]}"
+
+
+  }
+
+
+  AMQ::Client::EventMachineClient.connect(:port     => 5672,
+                                          :vhost    => "/amq_client_testbed",
+                                          :user     => "amq_client_gem",
+                                          :password => "amq_client_gem_password",
+                                          :connection_timeout        => 0.3,
+                                          :on_tcp_connection_failure => Proc.new { |settings| puts "Failed to connect, this was NOT expected"; EM.stop }) do |client|
+
+    client.on_tcp_connection_loss do |cl, settings|
+      puts "tcp_connection_loss handler kicks in"
+      cl.reconnect(1)
+    end
+
+    show_stopper = Proc.new {
+      client.disconnect {
+        puts "Disconnected. Exiting…"
+        EM.stop
+      }
+    }
+    
+    Signal.trap "INT",  show_stopper
+    Signal.trap "TERM", show_stopper
+    
+    EM.add_timer(30, show_stopper)
+
+
+    puts "Connected, authenticated. To really exercise this example, shut AMQP broker down for a few seconds. If you don't it will exit gracefully in 30 seconds."
+  end
+end

data/lib/amq/client.rb

@@ -3,6 +3,9 @@
 require "amq/client/version"
 require "amq/client/exceptions"
 require "amq/client/adapter"
+require "amq/client/channel"
+require "amq/client/exchange"
+require "amq/client/queue"
 
 begin
   require "amq/protocol/client"
@@ -13,3 +16,55 @@ rescue LoadError => exception
     raise exception
   end
 end
+
+module AMQ
+  module Client
+    # List all the available as a hash of {adapter_name: metadata},
+    # where metadata are hash with :path and :const_name keys.
+    #
+    # @example
+    #   AMQ::Client.adapters[:socket]
+    #   # => {path: full_path, const_name: "SocketClient"}}
+    # @return [Hash]
+    # @api public
+    def self.adapters
+      @adapters ||= begin
+        root = File.expand_path("../client/adapters", __FILE__)
+        Dir.glob("#{root}/*.rb").inject(Hash.new) do |buffer, path|
+          name = path.match(/([^\/]+)\.rb$/)[1]
+          const_base = name.to_s.gsub(/(^|_)(.)/) { $2.upcase! }
+          meta = {:path => path, :const_name => "#{const_base}Client"}
+          buffer.merge!(name.to_sym => meta)
+        end
+      end
+    end
+
+    # Establishes connection to AMQ broker using given adapter
+    # (defaults to the socket adapter) and returns it. The new
+    # connection object is yielded to the block if it is given.
+    #
+    # @example
+    #   AMQ::Client.connect(adapter: "socket") do |client|
+    #     # Use the client.
+    #   end
+    # @param [Hash] Connection parameters, including :adapter to use.
+    # @api public
+    def self.connect(settings = nil, &block)
+      adapter  = (settings && settings.delete(:adapter)) || :socket
+      adapter  = load_adapter(adapter)
+      adapter.connect(settings, &block)
+    end
+
+    # Loads adapter from amq/client/adapters.
+    #
+    # @raise [InvalidAdapterNameError] When loading attempt failed (LoadError was raised).
+    def self.load_adapter(adapter)
+      meta = self.adapters[adapter.to_sym]
+
+      require meta[:path]
+      const_get(meta[:const_name])
+    rescue LoadError
+      raise InvalidAdapterNameError.new(adapter)
+    end
+  end
+end

data/lib/amq/client/adapter.rb

@@ -4,6 +4,7 @@ require "amq/client/logging"
 require "amq/client/settings"
 require "amq/client/entity"
 require "amq/client/connection"
+require "amq/client/channel"
 
 module AMQ
   # For overview of AMQP client adapters API, see {AMQ::Client::Adapter}
@@ -104,55 +105,25 @@ module AMQ
         end
 
 
-        # @example Registering Channel implementation
-        #  Adapter.register_entity(:channel, Channel)
-        #   # ... so then I can do:
-        #  channel = client.channel(1)
-        #  # instead of:
-        #  channel = Channel.new(client, 1)
-        def register_entity(name, klass)
-          define_method(name) do |*args, &block|
-            klass.new(self, *args, &block)
-          end
-        end
-
         # Establishes connection to AMQ broker and returns it. New connection object is yielded to
         # the block if it is given.
         #
+        # @example Specifying adapter via the :adapter option
+        #   AMQ::Client::Adapter.connect(adapter: "socket")
+        # @example Specifying using custom adapter class
+        #   AMQ::Client::SocketClient.connect
         # @param [Hash] Connection parameters, including :adapter to use.
         # @api public
         def connect(settings = nil, &block)
-          if settings && settings[:adapter]
-            adapter = load_adapter(settings[:adapter])
-          else
-            adapter = self
-          end
+          # TODO: this doesn't look very nice, do we need it?
+          # Let's make it an instance thing by instance = self.new(settings)
+          @settings = settings = Settings.configure(settings)
 
-          @settings = AMQ::Client::Settings.configure(settings)
-          instance  = adapter.new
-          instance.establish_connection(@settings)
-          # We don't need anything more, once the server receives the preable, he sends Connection.Start, we just have to reply.
+          instance = self.new
+          instance.establish_connection(settings)
+          instance.register_connection_callback(&block)
 
-          if block
-            block.call(instance)
-
-            instance.disconnect
-          else
-            instance
-          end
-        end
-
-
-        # Loads adapter from amq/client/adapters.
-        #
-        # @raise [InvalidAdapterNameError] When loading attempt failed (LoadError was raised).
-        def load_adapter(adapter)
-          require "amq/client/adapters/#{adapter}"
-
-          const_name = adapter.to_s.gsub(/(^|_)(.)/) { $2.upcase! }
-          const_get(const_name)
-        rescue LoadError
-          raise InvalidAdapterNameError.new(adapter)
+          instance
         end
 
         # @see AMQ::Client::Adapter
@@ -184,17 +155,14 @@ module AMQ
 
       include AMQ::Client::StatusMixin
 
+      extend RegisterEntityMixin
+
+      register_entity :channel,  AMQ::Client::Channel
 
       #
       # API
       #
 
-      def self.load_adapter(adapter)
-        ClassMethods.load_adapter(adapter)
-      end
-
-
-
       def initialize(*args)
         super(*args)
 
@@ -229,6 +197,8 @@ module AMQ
       # @todo This method should await broker's response with Close-Ok. {http://github.com/michaelklishin MK}.
       # @see  #close_connection
       def disconnect(reply_code = 200, reply_text = "Goodbye", &block)
+        @intentionally_closing_connection = true
+
         self.on_disconnection(&block)
         closing!
         self.connection.close(reply_code, reply_text)
@@ -352,5 +322,3 @@ module AMQ
     end # Adapter
   end # Client
 end # AMQ
-
-require "amq/client/channel"

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

@@ -4,12 +4,11 @@
 
 require "cool.io"
 require "amq/client"
-
 require "amq/client/framing/string/frame"
 
 module AMQ
   module Client
-    class Coolio
+    class CoolioClient
       class Socket < ::Coolio::TCPSocket
         attr_accessor :adapter
 
@@ -48,27 +47,31 @@ module AMQ
         end
       end
 
+      #
       # Behaviors
+      #
+
       include AMQ::Client::Adapter
+      include AMQ::Client::CallbacksMixin
 
       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
+      def establish_connection(settings)
+        socket = Socket.connect(self, settings[:host], settings[:port])
+        socket.attach(Cool.io::Loop.default)
+        self.socket = socket
+      end
+
+      def register_connection_callback(&block)
+        self.on_connection(&block)
       end
 
       def initialize
@@ -138,59 +141,6 @@ module AMQ
       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

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

@@ -1,12 +1,9 @@
 # encoding: utf-8
 
+require "eventmachine"
 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
@@ -23,27 +20,52 @@ module AMQ
 
       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)
+        @settings = settings = Settings.configure(settings)
+
         instance = EventMachine.connect(settings[:host], settings[:port], self, settings)
+        instance.register_connection_callback(&block)
+
+        instance
+      end
+
+
+      def reconnect(period = 5, force = false)
+        if @reconnecting and not force
+          EventMachine::Timer.new(period) {
+            reconnect(period, true)
+          }
+          return
+        end
+
+        if !@reconnecting
+          @reconnecting = true
+          @connections.each { |c| c.handle_connection_interruption }
+          self.reset
+        end
+
+        self.reconnect(@settings[:host], @settings[:port])
+      end
+
+
+      def establish_connection(settings)
+        # Unfortunately there doesn't seem to be any sane way
+        # how to get EventMachine connect to the instance level.
+      end
 
+      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.
-          instance.on_connection do
-            block.call(instance)
+          self.on_connection do
+            block.call(self)
           end
         end
-
-        instance
       end
 
 
@@ -53,24 +75,21 @@ module AMQ
       def initialize(*args)
         super(*args)
 
+        @connections                        = Array.new
+        # 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                 = args.first
-        @connections              = Array.new
+        @settings                           = args.first
         @on_possible_authentication_failure = @settings[:on_possible_authentication_failure]
-        @on_tcp_connection_failure          = @settings[:on_tcp_connection_failure] || Proc.new { |settings| raise AMQ::Client::TCPConnectionFailed.new(settings) }
+        @on_tcp_connection_failure          = @settings[:on_tcp_connection_failure] || Proc.new { |settings|
+          raise AMQ::Client::TCPConnectionFailed.new(settings)
+        }
 
-        @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
+        self.reset
 
         if self.heartbeat_interval > 0
           @last_server_heartbeat = Time.now
@@ -79,10 +98,6 @@ module AMQ
       end # initialize(*args)
 
 
-      def establish_connection(settings)
-        # an intentional no-op
-      end
-
       alias send_raw send_data
 
 
@@ -111,8 +126,6 @@ module AMQ
         # to take some time and to not be worth in as long as #post_init
         # works fine. MK.
         upgrade_to_tls_if_necessary
-
-        self.handshake
       rescue Exception => error
         raise error
       end # post_init
@@ -121,8 +134,22 @@ module AMQ
       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. Yes, it makes as much sense to me MK.
-        @tcp_connection_established = true
+        # 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
+
+      def close_connection(*args)
+        @intentionally_closing_connection = true
+
+        super(*args)
       end
 
       # Called by EventMachine reactor when
@@ -132,19 +159,22 @@ module AMQ
       # * There is a network connection issue
       # * Initial TCP connection fails
       def unbind
-        if !@tcp_connection_established
+        if !@tcp_connection_established && !@had_successfull_connected_before
+          @tcp_connection_failed = true
           self.tcp_connection_failed
         end
 
         closing!
-
         @tcp_connection_established = false
 
-        @connections.each { |c| c.on_connection_interruption }
+        @connections.each { |c| c.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
@@ -170,23 +200,35 @@ module AMQ
         end
       end
 
-
-
+      # Defines a callback that will be executed when AMQP connection is considered open,
+      # after client and broker has agreed on max channel identifier and maximum allowed frame
+      # size. You can define more than one callback.
+      #
+      # @see #on_open
+      # @api public
       def on_connection(&block)
         @connection_deferrable.callback(&block)
       end # on_connection(&block)
 
-      # called by AMQ::Client::Connection after we receive connection.open-ok.
+      # Called by AMQ::Client::Connection after we receive connection.open-ok.
+      # @api public
       def connection_successful
         @connection_deferrable.succeed
       end # connection_successful
 
 
-
+      # Defines a callback that will be executed when AMQP connection is considered open,
+      # before client and broker has agreed on max channel identifier and maximum allowed frame
+      # size. You can define more than one callback.
+      #
+      # @see #on_connection
+      # @api public
       def on_open(&block)
         @connection_opened_deferrable.callback(&block)
       end # on_open(&block)
 
+      # Called by AMQ::Client::Connection after we receive connection.tune.
+      # @api public
       def open_successful
         @authenticating = false
         @connection_opened_deferrable.succeed
@@ -195,31 +237,61 @@ module AMQ
       end # open_successful
 
 
-
+      # 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_disconnection(&block)
         @disconnection_deferrable.callback(&block)
       end # on_disconnection(&block)
 
-      # called by AMQ::Client::Connection after we receive connection.close-ok.
+      # Called by AMQ::Client::Connection after we receive connection.close-ok.
+      #
+      # @api public
       def disconnection_successful
         @disconnection_deferrable.succeed
 
         self.close_connection
+        self.reset
         closed!
       end # disconnection_successful
 
 
-
+      # 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
 
+      # Called when initial TCP connection fails.
+      # @api public
       def tcp_connection_failed
         @on_tcp_connection_failure.call(@settings) if @on_tcp_connection_failure
       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
+
+      # Called when initial TCP connection fails.
+      # @api public
+      def tcp_connection_lost
+        @on_tcp_connection_loss.call(self, @settings) if @on_tcp_connection_loss
+      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
@@ -243,6 +315,19 @@ module AMQ
         @size    = 0
         @payload = ""
         @frames  = Array.new
+
+        @chunk_buffer                 = ""
+        @connection_deferrable        = Deferrable.new
+        @disconnection_deferrable     = Deferrable.new
+        # succeeds when connection is open, that is, vhost is selected
+        # and client is given green light to proceed.
+        @connection_opened_deferrable = Deferrable.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
 
       # @see http://tools.ietf.org/rfc/rfc2595.txt RFC 2595
@@ -272,7 +357,7 @@ module AMQ
           start_tls(tls_options)
         elsif tls_options
           start_tls
-        end        
+        end
       end
     end # EventMachineClient
   end # Client