amq-client 0.7.0.alpha35 → 0.8.0

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

@@ -1 +1,3 @@
-require "amq/client/async/adapters/event_machine"
+# encoding: utf-8
+
+require "amq/client/async/adapters/event_machine"

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

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 module AMQ
   module Client
     module Async
@@ -34,28 +36,28 @@ module AMQ
 
 
         def exec_callback(name, *args, &block)
-          list = Array(self.callbacks[name])
+          list = Array(@callbacks[name])
           if list.any?
             list.each { |c| c.call(*args, &block) }
           end
         end
 
         def exec_callback_once(name, *args, &block)
-          list = (self.callbacks.delete(name) || Array.new)
+          list = (@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)
-          list = Array(self.callbacks[name])
+          list = Array(@callbacks[name])
           if list.any?
             list.each { |c| c.call(self, *args, &block) }
           end
         end
 
         def exec_callback_once_yielding_self(name, *args, &block)
-          list = (self.callbacks.delete(name) || Array.new)
+          list = (@callbacks.delete(name) || Array.new)
 
           if list.any?
             list.each { |c| c.call(self, *args, &block) }
@@ -63,9 +65,9 @@ module AMQ
         end
 
         def has_callback?(name)
-          self.callbacks[name] && !self.callbacks[name].empty?
+          @callbacks[name] && !@callbacks[name].empty?
         end # has_callback?
-      end # Callbacks      
+      end # Callbacks
     end # Async
   end # Client
-end # AMQ
+end # AMQ

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

@@ -25,30 +25,29 @@ module AMQ
         #
 
 
-        class ChannelOutOfBadError < StandardError # TODO: inherit from some AMQP error class defined in amq-protocol or use it straight away.
-          def initialize(max, given)
-            super("Channel max is #{max}, #{given} given.")
-          end
-        end
-
-
         DEFAULT_REPLY_TEXT = "Goodbye".freeze
 
         attr_reader :id
 
         attr_reader :exchanges_awaiting_declare_ok, :exchanges_awaiting_delete_ok
-        attr_reader :queues_awaiting_declare_ok, :queues_awaiting_delete_ok, :queues_awaiting_bind_ok, :queues_awaiting_unbind_ok, :queues_awaiting_purge_ok, :queues_awaiting_consume_ok, :queues_awaiting_cancel_ok, :queues_awaiting_get_response
+        attr_reader :queues_awaiting_declare_ok, :queues_awaiting_delete_ok, :queues_awaiting_bind_ok, :queues_awaiting_unbind_ok, :queues_awaiting_purge_ok, :queues_awaiting_get_response
+        attr_reader :consumers_awaiting_consume_ok, :consumers_awaiting_cancel_ok
 
         attr_accessor :flow_is_active
 
 
-        def initialize(connection, id)
+        def initialize(connection, id, options = {})
           super(connection)
 
           @id        = id
           @exchanges = Hash.new
           @queues    = Hash.new
           @consumers = Hash.new
+          @options       = { :auto_recovery => connection.auto_recovering? }.merge(options)
+          @auto_recovery = (!!@options[:auto_recovery])
+
+          # we must synchronize frameset delivery. MK.
+          @mutex     = Mutex.new
 
           reset_state!
 
@@ -62,10 +61,17 @@ module AMQ
                         end
 
           if channel_max != 0 && !(0..channel_max).include?(id)
-            raise ChannelOutOfBadError.new(channel_max, id)
+            raise ArgumentError.new("Max channel for the connection is #{channel_max}, given: #{id}")
           end
         end
 
+        # @return [Boolean] true if this channel uses automatic recovery mode
+        def auto_recovering?
+          @auto_recovery
+        end # auto_recovering?
+
+
+        # @return [Hash<String, Consumer>]
         def consumers
           @consumers
         end # consumers
@@ -88,6 +94,12 @@ module AMQ
           @connection
         end # connection
 
+        # Synchronizes given block using this channel's mutex.
+        # @api public
+        def synchronize(&block)
+          @mutex.synchronize(&block)
+        end
+
 
         # @group Channel lifecycle
 
@@ -101,6 +113,7 @@ module AMQ
 
           self.redefine_callback :open, &block
         end
+        alias reopen open
 
         # Closes AMQP channel.
         #
@@ -245,6 +258,77 @@ module AMQ
           self.define_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
+        def handle_connection_interruption(method = nil)
+          @queues.each    { |name, q| q.handle_connection_interruption(method) }
+          @exchanges.each { |name, e| e.handle_connection_interruption(method) }
+
+          self.exec_callback_yielding_self(:after_connection_interruption)
+          self.reset_state!
+        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)
+
+          @queues.each    { |name, q| q.run_before_recovery_callbacks }
+          @exchanges.each { |name, e| e.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)
+
+          @queues.each    { |name, q| q.run_after_recovery_callbacks }
+          @exchanges.each { |name, e| e.run_after_recovery_callbacks }
+        end
+
+
+        # Called by associated connection object when AMQP connection has been re-established
+        # (for example, after a network failure).
+        #
+        # @api plugin
+        def auto_recover
+          return unless auto_recovering?
+
+          self.open do
+            # exchanges must be recovered first because queue recovery includes recovery of bindings. MK.
+            @exchanges.each { |name, e| e.auto_recover }
+            @queues.each    { |name, q| q.auto_recover }
+          end
+        end # auto_recover
+
         # @endgroup
 
 
@@ -268,17 +352,26 @@ module AMQ
           @exchanges[name]
         end
 
+        # @api plugin
+        # @private
         def register_queue(queue)
           raise ArgumentError, "argument is nil!" if queue.nil?
 
           @queues[queue.name] = queue
         end # register_queue(queue)
 
+        # @api plugin
+        # @private
         def find_queue(name)
           @queues[name]
         end
 
 
+        RECOVERY_EVENTS = [:after_connection_interruption, :before_recovery, :after_recovery].freeze
+
+
+        # @api plugin
+        # @private
         def reset_state!
           @flow_is_active                = true
 
@@ -291,31 +384,31 @@ module AMQ
           @queues_awaiting_purge_ok      = Array.new
           @queues_awaiting_bind_ok       = Array.new
           @queues_awaiting_unbind_ok     = Array.new
-          @queues_awaiting_consume_ok    = Array.new
-          @queues_awaiting_cancel_ok     = Array.new
+          @consumers_awaiting_consume_ok = Array.new
+          @consumers_awaiting_cancel_ok  = Array.new
 
           @queues_awaiting_get_response  = Array.new
 
-          @callbacks                     = Hash.new
+          @callbacks                     = @callbacks.delete_if { |k, v| !RECOVERY_EVENTS.include?(k) }
         end # reset_state!
 
 
-        def handle_connection_interruption(method = nil)
-          self.reset_state!
-        end # handle_connection_interruption
-
-
-
+        # @api plugin
+        # @private
         def handle_open_ok(open_ok)
           self.status = :opened
           self.exec_callback_once_yielding_self(:open, open_ok)
         end
 
+        # @api plugin
+        # @private
         def handle_close_ok(close_ok)
           self.status = :closed
           self.exec_callback_once_yielding_self(:close, close_ok)
         end
 
+        # @api plugin
+        # @private
         def handle_close(channel_close)
           self.status = :closed
           self.exec_callback_yielding_self(:error, channel_close)
@@ -379,7 +472,7 @@ module AMQ
           channel = connection.channels[frame.channel]
           channel.exec_callback(:tx_rollback, frame.decode_payload)
         end
-      end # Channel      
+      end # Channel
     end # Async
   end # Client
 end # AMQ

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

@@ -0,0 +1,270 @@
+# encoding: utf-8
+
+require "amq/client/async/callbacks"
+require "amq/client/consumer_tag_generator"
+
+module AMQ
+  module Client
+    module Async
+      class Consumer
+
+        #
+        # Behaviors
+        #
+
+        include Async::Callbacks
+        extend Async::ProtocolMethodHandlers
+
+
+
+        #
+        # API
+        #
+
+        attr_reader :channel
+        attr_reader :queue
+        attr_reader :consumer_tag
+        attr_reader :arguments
+
+
+        def self.tag_generator
+          @tag_generator ||= AMQ::Client::ConsumerTagGenerator.new
+        end # self.tag_generator
+
+        def self.tag_generator=(generator)
+          @tag_generator = generator
+        end
+
+
+        def initialize(channel, queue, consumer_tag = self.class.tag_generator.generate_for(queue), exclusive = false, no_ack = false, arguments = {}, no_local = false, &block)
+          @callbacks    = Hash.new
+
+          @channel       = channel            || raise(ArgumentError, "channel is nil")
+          @connection    = channel.connection || raise(ArgumentError, "connection is nil")
+          @queue         = queue        || raise(ArgumentError, "queue is nil")
+          @consumer_tag  = consumer_tag
+          @exclusive     = exclusive
+          @no_ack        = no_ack
+          @arguments     = arguments
+
+          @no_local     = no_local
+
+          self.register_with_channel
+          self.register_with_queue
+        end # initialize
+
+
+        def exclusive?
+          !!@exclusive
+        end # exclusive?
+
+
+
+        def consume(nowait = false, &block)
+          @connection.send_frame(Protocol::Basic::Consume.encode(@channel.id, @queue.name, @consumer_tag, @no_local, @no_ack, @exclusive, nowait, @arguments))
+          self.redefine_callback(:consume, &block)
+
+          @channel.consumers_awaiting_consume_ok.push(self)
+
+          self
+        end # consume(nowait = false, &block)
+
+        # Used by automatic recovery code.
+        # @api plugin
+        def resubscribe(&block)
+          @connection.send_frame(Protocol::Basic::Consume.encode(@channel.id, @queue.name, @consumer_tag, @no_local, @no_ack, @exclusive, block.nil?, @arguments))
+          self.redefine_callback(:consume, &block) if block
+
+          self
+        end # resubscribe(&block)
+
+
+        def cancel(nowait = false, &block)
+          @connection.send_frame(Protocol::Basic::Cancel.encode(@channel.id, @consumer_tag, nowait))
+          self.clear_callbacks(:delivery)
+          self.clear_callbacks(:consume)
+
+          self.unregister_with_channel
+          self.unregister_with_queue
+
+          if !nowait
+            self.redefine_callback(:cancel, &block)
+            @channel.consumers_awaiting_cancel_ok.push(self)
+          end
+
+          self
+        end # cancel(nowait = false, &block)
+
+
+
+        def on_delivery(&block)
+          self.append_callback(:delivery, &block)
+
+          self
+        end # on_delivery(&block)
+
+
+        # @group Acknowledging & Rejecting Messages
+
+        # Acknowledge a delivery tag.
+        # @return [Consumer]  self
+        #
+        # @api public
+        # @see http://bit.ly/htCzCX AMQP 0.9.1 protocol documentation (Section 1.8.3.13.)
+        def acknowledge(delivery_tag)
+          @channel.acknowledge(delivery_tag)
+
+          self
+        end # acknowledge(delivery_tag)
+
+        #
+        # @return [Consumer]  self
+        #
+        # @api public
+        # @see http://bit.ly/htCzCX AMQP 0.9.1 protocol documentation (Section 1.8.3.14.)
+        def reject(delivery_tag, requeue = true)
+          @channel.reject(delivery_tag, requeue)
+
+          self
+        end # reject(delivery_tag, requeue = true)
+
+        # @endgroup
+
+
+        # @group Error Handling & Recovery
+
+        # 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
+        def handle_connection_interruption(method = nil)
+          self.exec_callback_yielding_self(:after_connection_interruption)
+        end # handle_connection_interruption
+
+
+        # Defines a callback that will be executed after TCP connection is 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)
+        end
+
+
+        # Defines a callback that will be executed when AMQP connection is 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)
+        end
+
+
+
+        # Called by associated connection object when AMQP connection has been re-established
+        # (for example, after a network failure).
+        #
+        # @api plugin
+        def auto_recover
+          self.exec_callback_yielding_self(:before_recovery)
+          self.resubscribe
+          self.exec_callback_yielding_self(:after_recovery)
+        end # auto_recover
+
+        # @endgroup
+
+
+
+
+        #
+        # Implementation
+        #
+
+        def handle_delivery(basic_deliver, metadata, payload)
+          self.exec_callback(:delivery, basic_deliver, metadata, payload)
+        end # handle_delivery(basic_deliver, metadata, payload)
+
+        def handle_consume_ok(consume_ok)
+          self.exec_callback_once(:consume, consume_ok)
+        end # handle_consume_ok(consume_ok)
+
+        def handle_cancel_ok(cancel_ok)
+          @consumer_tag = nil
+
+          # detach from object graph so that this object will be garbage-collected
+          @queue        = nil
+          @channel      = nil
+          @connection   = nil
+
+          self.exec_callback_once(:cancel, cancel_ok)
+        end # handle_cancel_ok(method)
+
+
+
+        self.handle(Protocol::Basic::ConsumeOk) do |connection, frame|
+          channel  = connection.channels[frame.channel]
+          consumer = channel.consumers_awaiting_consume_ok.shift
+
+          consumer.handle_consume_ok(frame.decode_payload)
+        end
+
+
+        self.handle(Protocol::Basic::CancelOk) do |connection, frame|
+          channel  = connection.channels[frame.channel]
+          consumer = channel.consumers_awaiting_cancel_ok.shift
+
+          consumer.handle_consume_ok(frame.decode_payload)
+        end
+
+
+        self.handle(Protocol::Basic::Deliver) do |connection, method_frame, content_frames|
+          channel       = connection.channels[method_frame.channel]
+          basic_deliver = method_frame.decode_payload
+          consumer      = channel.consumers[basic_deliver.consumer_tag]
+
+          metadata = content_frames.shift
+          payload  = content_frames.map { |frame| frame.payload }.join
+
+          consumer.handle_delivery(basic_deliver, metadata, payload)
+        end
+
+
+        protected
+
+        def register_with_channel
+          @channel.consumers[@consumer_tag] = self
+        end # register_with_channel
+
+        def register_with_queue
+          @queue.consumers[@consumer_tag]   = self
+        end # register_with_queue
+
+        def unregister_with_channel
+          @channel.consumers.delete(@consumer_tag)
+        end # register_with_channel
+
+        def unregister_with_queue
+          @queue.consumers.delete(@consumer_tag)
+        end # register_with_queue
+      end # Consumer
+    end # Async
+  end # Client
+end # AMQ