amqp 1.1.0.pre1 → 1.1.0.pre2

data/lib/amqp/consumer.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 
-require "amq/client/async/consumer"
+require "amqp/consumer_tag_generator"
 
 module AMQP
   # AMQP consumers are entities that handle messages delivered to them ("push API" as opposed to "pull API") by AMQP broker.
@@ -11,7 +11,15 @@ module AMQP
   # @see AMQP::Queue
   # @see AMQP::Queue#subscribe
   # @see AMQP::Queue#cancel
-  class Consumer < AMQ::Client::Async::Consumer
+  class Consumer
+
+    #
+    # Behaviours
+    #
+
+    include Callbacks
+    extend  ProtocolMethodHandlers
+
 
     #
     # API
@@ -27,25 +35,38 @@ module AMQP
     attr_reader :arguments
 
 
-    # @return [AMQ::Client::ConsumerTagGenerator] Consumer tag generator
+    # @return [AMQP::ConsumerTagGenerator] Consumer tag generator
     def self.tag_generator
-      @tag_generator ||= AMQ::Client::ConsumerTagGenerator.new
+      @tag_generator ||= AMQP::ConsumerTagGenerator.new
     end # self.tag_generator
 
-    # @param [AMQ::Client::ConsumerTagGenerator] Assigns consumer tag generator that will be used by consumer instances
-    # @return [AMQ::Client::ConsumerTagGenerator] Provided argument
+    # @param [AMQP::ConsumerTagGenerator] Assigns consumer tag generator that will be used by consumer instances
+    # @return [AMQP::ConsumerTagGenerator] Provided argument
     def self.tag_generator=(generator)
       @tag_generator = generator
     end
 
 
-    def initialize(channel, queue, consumer_tag = nil, exclusive = false, no_ack = false, arguments = {}, no_local = false)
-      super(channel, queue, (consumer_tag || self.class.tag_generator.generate_for(queue)), exclusive, no_ack, arguments, no_local)
+    def initialize(channel, queue, consumer_tag = nil, 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 || self.class.tag_generator.generate_for(queue)
+      @exclusive     = exclusive
+      @no_ack        = no_ack
+      @arguments     = arguments
+
+      @no_local     = no_local
+
+      self.register_with_channel
+      self.register_with_queue
     end # initialize
 
     # @return [Boolean] true if this consumer is exclusive (other consumers for the same queue are not allowed)
     def exclusive?
-      super
+      !!@exclusive
     end # exclusive?
 
 
@@ -55,7 +76,12 @@ module AMQP
     def consume(nowait = false, &block)
       @channel.once_open do
         @queue.once_declared do
-          super(nowait, &block)
+          @connection.send_frame(AMQ::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
       end
 
@@ -72,7 +98,10 @@ module AMQP
           @consumer_tag = self.class.tag_generator.generate_for(@queue)
           self.register_with_channel
 
-          super(&block)
+          @connection.send_frame(AMQ::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
       end
 
@@ -83,7 +112,20 @@ module AMQP
     def cancel(nowait = false, &block)
       @channel.once_open do
         @queue.once_declared do
-          super(nowait, &block)
+          @connection.send_frame(AMQ::Protocol::Basic::Cancel.encode(@channel.id, @consumer_tag, nowait))
+          self.clear_callbacks(:delivery)
+          self.clear_callbacks(:consume)
+          self.clear_callbacks(:scancel)
+
+          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
       end
 
@@ -129,30 +171,67 @@ module AMQP
         end
       }
 
-      super(&delivery_shim)
+      self.append_callback(:delivery, &delivery_shim)
+
+      self
     end # on_delivery(&block)
 
 
+    # @return [String] Readable representation of relevant object state.
+    def inspect
+      "#<AMQP::Consumer:#{@consumer_tag}> queue=#{@queue.name} channel=#{@channel.id} callbacks=#{@callbacks.inspect}"
+    end # inspect
+
+
+    def on_cancel(&block)
+      self.append_callback(:scancel, &block)
+
+      self
+    end # on_cancel(&block)
+
+    def handle_cancel(basic_cancel)
+      self.exec_callback(:scancel, basic_cancel)
+    end # handle_cancel(basic_cancel)
+
+
+
     # @group Acknowledging & Rejecting Messages
 
     # Acknowledge a delivery tag.
     # @return [Consumer]  self
     #
     # @api public
-    # @see http://files.travis-ci.org/docs/amqp/0.9.1/AMQP091Reference.pdf AMQP 0.9.1 protocol documentation (Section 1.8.3.13.)
+    # @see http://bit.ly/htCzCX AMQP 0.9.1 protocol documentation (Section 1.8.3.13.)
     def acknowledge(delivery_tag)
-      super(delivery_tag)
+      @channel.acknowledge(delivery_tag)
+
+      self
     end # acknowledge(delivery_tag)
 
     #
     # @return [Consumer]  self
     #
     # @api public
-    # @see http://files.travis-ci.org/docs/amqp/0.9.1/AMQP091Reference.pdf AMQP 0.9.1 protocol documentation (Section 1.8.3.14.)
+    # @see http://bit.ly/htCzCX AMQP 0.9.1 protocol documentation (Section 1.8.3.14.)
     def reject(delivery_tag, requeue = true)
-      super(delivery_tag, requeue)
+      @channel.reject(delivery_tag, requeue)
+
+      self
     end # reject(delivery_tag, requeue = true)
 
+    # 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
+    # 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
+
     # @endgroup
 
 
@@ -163,10 +242,15 @@ module AMQP
     #
     # @api public
     def on_connection_interruption(&block)
-      super(&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.
@@ -174,17 +258,19 @@ module AMQP
     #
     # @api public
     def before_recovery(&block)
-      super(&block)
+      self.redefine_callback(:before_recovery, &block)
     end # before_recovery(&block)
 
-    # 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)
-      super(&block)
-    end # on_recovery(&block)
-    alias after_recovery on_recovery
+    # @private
+    def run_before_recovery_callbacks
+      self.exec_callback_yielding_self(:before_recovery)
+    end
+
+    # @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
@@ -192,17 +278,99 @@ module AMQP
     #
     # @api plugin
     def auto_recover
-      super
+      self.exec_callback_yielding_self(:before_recovery)
+      self.resubscribe
+      self.exec_callback_yielding_self(:after_recovery)
     end # auto_recover
 
     # @endgroup
 
 
-    # @return [String] Readable representation of relevant object state.
-    def inspect
-      "#<AMQP::Consumer:#{@consumer_tag}> queue=#{@queue.name} channel=#{@channel.id} callbacks=#{@callbacks.inspect}"
-    end # inspect
+    def to_s
+      "#<#{self.class.name} @consumer_tag=#{@consumer_tag} @queue=#{@queue.name} @channel=#{@channel.id}>"
+    end
+
+
+    #
+    # 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(AMQ::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(AMQ::Protocol::Basic::CancelOk) do |connection, frame|
+      channel  = connection.channels[frame.channel]
+      consumer = channel.consumers_awaiting_cancel_ok.shift
+
+      consumer.handle_cancel_ok(frame.decode_payload)
+    end
+
+
+    self.handle(AMQ::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
+
+      # Handle the delivery only if the consumer still exists.
+      # The broker has been known to deliver a few messages after the consumer has been shut down.
+      consumer.handle_delivery(basic_deliver, metadata, payload) if consumer
+    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
+
+    handle(AMQ::Protocol::Basic::Cancel) do |connection, method_frame|
+      channel      = connection.channels[method_frame.channel]
+      basic_cancel = method_frame.decode_payload
+      consumer     = channel.consumers[basic_cancel.consumer_tag]
+
+      # Handle the delivery only if the consumer still exists.
+      consumer.handle_cancel(basic_cancel) if consumer
+    end
   end # Consumer
 end # AMQP

data/lib/amqp/consumer_tag_generator.rb

@@ -0,0 +1,20 @@
+module AMQP
+  class ConsumerTagGenerator
+
+    #
+    # API
+    #
+
+    # @return [String] Generated consumer tag
+    def generate
+      "#{Kernel.rand}-#{Time.now.to_i * 1000}-#{Kernel.rand(999_999_999_999)}"
+    end # generate
+
+    # @return [String] Generated consumer tag
+    def generate_for(queue)
+      raise ArgumentError, "argument must respond to :name" unless queue.respond_to?(:name)
+
+      "#{queue.name}-#{Time.now.to_i * 1000}-#{Kernel.rand(999_999_999_999)}"
+    end # generate_for(queue)
+  end # ConsumerTagGenerator
+end

data/lib/amqp/deferrable.rb

@@ -0,0 +1,5 @@
+require "eventmachine"
+
+module AMQP
+  Deferrable = EventMachine::DefaultDeferrable
+end

data/lib/amqp/entity.rb

@@ -0,0 +1,71 @@
+require "amqp/openable"
+require "amqp/callbacks"
+
+module AMQP
+  module RegisterEntityMixin
+    # @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 # define_method
+    end # register_entity
+  end # RegisterEntityMixin
+
+  module ProtocolMethodHandlers
+    def handle(klass, &block)
+      HandlersRegistry.register(klass, &block)
+    end
+
+    def handlers
+      HandlersRegistry.handlers
+    end
+  end # ProtocolMethodHandlers
+
+
+  # AMQ entities, as implemented by AMQP, have callbacks and can run them
+  # when necessary.
+  #
+  # @note Exchanges and queues implementation is based on this class.
+  #
+  # @abstract
+  module Entity
+
+    #
+    # Behaviors
+    #
+
+    include Openable
+    include Callbacks
+
+    #
+    # API
+    #
+
+    # @return [Array<#call>]
+    attr_reader :callbacks
+
+
+    def initialize(connection)
+      @connection = connection
+      # 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
+    end # initialize
+  end # Entity
+
+  # Common behavior of AMQ entities that can be either client or server-named, for example, exchanges and queues.
+  module ServerNamedEntity
+
+    # @return [Boolean] true if this entity is anonymous (server-named)
+    def server_named?
+      @server_named || @name.nil? || @name.empty?
+    end
+    # backwards compabitility. MK.
+    alias anonymous? server_named?
+  end # ServerNamedEntity
+end

data/lib/amqp/exchange.rb

@@ -1,7 +1,5 @@
 # encoding: utf-8
 
-require "amq/client/exchange"
-
 module AMQP
 
   # h2. What are AMQP exchanges?
@@ -137,13 +135,23 @@ module AMQP
   # @see http://files.travis-ci.org/docs/amqp/0.9.1/AMQP091Specification.pdf AMQP 0.9.1 specification (Section 2.1.1)
   # @see http://files.travis-ci.org/docs/amqp/0.9.1/AMQP091Specification.pdf AMQP 0.9.1 specification (Section 2.1.5)
   # @see http://files.travis-ci.org/docs/amqp/0.9.1/AMQP091Specification.pdf AMQP 0.9.1 specification (Section 3.1.3)
-  class Exchange < AMQ::Client::Exchange
+  class Exchange
+
+
+    #
+    # Behaviours
+    #
+
+    include Entity
+    extend  ProtocolMethodHandlers
+
 
     #
     # API
     #
 
     DEFAULT_CONTENT_TYPE = "application/octet-stream".freeze
+    BUILTIN_TYPES = [:fanout, :direct, :topic, :headers].freeze
 
 
     # The default exchange. Default exchange is a direct exchange that is predefined.
@@ -191,6 +199,13 @@ module AMQP
     #                 from the broker arrives.
     attr_accessor :on_declare
 
+    # Channel this exchange belongs to.
+    attr_reader :channel
+
+    # @return [Hash] Additional arguments given on queue declaration. Typically used by AMQP extensions.
+    attr_reader :arguments
+
+
     # @return [String]
     attr_reader :default_routing_key
     alias key default_routing_key
@@ -301,18 +316,31 @@ module AMQP
 
       @status                  = :unknown
       @default_publish_options = (opts.delete(:default_publish_options) || {
-                                    :routing_key  => @default_routing_key,
-                                    :mandatory    => false,
-                                    :immediate    => false
-                                  }).freeze
+          :routing_key  => @default_routing_key,
+          :mandatory    => false,
+          :immediate    => false
+        }).freeze
 
       @default_headers = (opts.delete(:default_headers) || {
-                            :content_type => DEFAULT_CONTENT_TYPE,
-                            :persistent   => false,
-                            :priority     => 0
-                          }).freeze
+          :content_type => DEFAULT_CONTENT_TYPE,
+          :persistent   => false,
+          :priority     => 0
+        }).freeze
+
+      if !(BUILTIN_TYPES.include?(type.to_sym) || type.to_s =~ /^x-.+/i)
+        raise UnknownExchangeTypeError.new(BUILTIN_TYPES, type)
+      end
+
+      @channel    = channel
+      @name       = name
+      @type       = type
+
+      # register pre-declared exchanges
+      if @name == AMQ::Protocol::EMPTY_STRING || @name =~ /^amq\.(direct|fanout|topic|match|headers)/
+        @channel.register_exchange(self)
+      end
 
-      super(channel.connection, channel, name, type)
+      super(channel.connection)
 
       # The AMQP 0.8 specification (as well as 0.9.1) in 1.1.4.2 mentiones
       # that Exchange.Declare-Ok confirms the name of the exchange (because
@@ -338,9 +366,9 @@ module AMQP
                 end
               end
 
-              self.declare(passive = @opts[:passive], durable = @opts[:durable], auto_delete = @opts[:auto_delete], nowait = @opts[:nowait], @opts[:arguments], &shim)
+              self.exchange_declare(passive = @opts[:passive], durable = @opts[:durable], auto_delete = @opts[:auto_delete], nowait = @opts[:nowait], @opts[:arguments], &shim)
             else
-              self.declare(passive = @opts[:passive], durable = @opts[:durable], auto_delete = @opts[:auto_delete], nowait = @opts[:nowait], @opts[:arguments])
+              self.exchange_declare(passive = @opts[:passive], durable = @opts[:durable], auto_delete = @opts[:auto_delete], nowait = @opts[:nowait], @opts[:arguments])
             end
           end
         end
@@ -360,6 +388,42 @@ module AMQP
       @channel
     end
 
+    # @return [Boolean] true if this exchange is of type `fanout`
+    # @api public
+    def fanout?
+      @type == :fanout
+    end
+
+    # @return [Boolean] true if this exchange is of type `direct`
+    # @api public
+    def direct?
+      @type == :direct
+    end
+
+    # @return [Boolean] true if this exchange is of type `topic`
+    # @api public
+    def topic?
+      @type == :topic
+    end
+
+    # @return [Boolean] true if this exchange is of type `headers`
+    # @api public
+    def headers?
+      @type == :headers
+    end
+
+    # @return [Boolean] true if this exchange is of a custom type (begins with x-)
+    # @api public
+    def custom_type?
+      @type.to_s =~ /^x-.+/i
+    end # custom_type?
+
+    # @return [Boolean] true if this exchange is a pre-defined one (amq.direct, amq.fanout, amq.match and so on)
+    def predefined?
+      @name && ((@name == AMQ::Protocol::EMPTY_STRING) || !!(@name =~ /^amq\.(direct|fanout|topic|headers|match)/i))
+    end # predefined?
+
+
     # Publishes message to the exchange. The message will be routed to queues by the exchange
     # and distributed to any active consumers. Routing logic is determined by exchange type and
     # configuration as well as message attributes (like :routing_key or message headers).
@@ -475,9 +539,9 @@ module AMQP
       @channel.once_open do
         properties                 = @default_headers.merge(options)
         properties[:delivery_mode] = properties.delete(:persistent) ? 2 : 1
-        super(payload.to_s, opts[:key] || opts[:routing_key] || @default_routing_key, properties, opts[:mandatory], opts[:immediate])
+        basic_publish(payload.to_s, opts[:key] || opts[:routing_key] || @default_routing_key, properties, opts[:mandatory], opts[:immediate])
 
-        # don't pass block to AMQ::Client::Exchange#publish because it will be executed
+        # don't pass block to AMQP::Exchange#publish because it will be executed
         # immediately and we want to do it later. See ruby-amqp/amqp/#67 MK.
         EventMachine.next_tick(&block) if block
       end
@@ -506,7 +570,7 @@ module AMQP
     # @api public
     def delete(opts = {}, &block)
       @channel.once_open do
-        super(opts.fetch(:if_unused, false), opts.fetch(:nowait, false), &block)
+        exchange_delete(opts.fetch(:if_unused, false), opts.fetch(:nowait, false), &block)
       end
 
       # backwards compatibility
@@ -544,6 +608,191 @@ module AMQP
     end
 
 
+    # @group Declaration
+
+    # @api public
+    def exchange_declare(passive = false, durable = false, auto_delete = false, nowait = false, arguments = nil, &block)
+      # for re-declaration
+      @passive     = passive
+      @durable     = durable
+      @auto_delete = auto_delete
+      @arguments   = arguments
+
+      @connection.send_frame(AMQ::Protocol::Exchange::Declare.encode(@channel.id, @name, @type.to_s, passive, durable, auto_delete, false, nowait, arguments))
+
+      unless nowait
+        self.define_callback(:declare, &block)
+        @channel.exchanges_awaiting_declare_ok.push(self)
+      end
+
+      self
+    end
+
+
+    # @api public
+    def redeclare(&block)
+      nowait = block.nil?
+      @connection.send_frame(AMQ::Protocol::Exchange::Declare.encode(@channel.id, @name, @type.to_s, @passive, @durable, @auto_delete, false, nowait, @arguments))
+
+      unless nowait
+        self.define_callback(:declare, &block)
+        @channel.exchanges_awaiting_declare_ok.push(self)
+      end
+
+      self
+    end # redeclare(&block)
+
+    # @endgroup
+
+
+    # @api public
+    def exchange_delete(if_unused = false, nowait = false, &block)
+      @connection.send_frame(AMQ::Protocol::Exchange::Delete.encode(@channel.id, @name, if_unused, nowait))
+
+      unless nowait
+        self.define_callback(:delete, &block)
+
+        # TODO: delete itself from exchanges cache
+        @channel.exchanges_awaiting_delete_ok.push(self)
+      end
+
+      self
+    end # delete(if_unused = false, nowait = false)
+
+
+
+    # @group Publishing Messages
+
+    # @api public
+    def basic_publish(payload, routing_key = AMQ::Protocol::EMPTY_STRING, user_headers = {}, mandatory = false, immediate = false, frame_size = nil)
+      headers = { :priority => 0, :delivery_mode => 2, :content_type => "application/octet-stream" }.merge(user_headers)
+      @connection.send_frameset(AMQ::Protocol::Basic::Publish.encode(@channel.id, payload, headers, @name, routing_key, mandatory, immediate, (frame_size || @connection.frame_max)), @channel)
+
+      # publisher confirms support. MK.
+      @channel.exec_callback(:after_publish)
+      self
+    end
+
+
+    # @api public
+    def on_return(&block)
+      self.redefine_callback(:return, &block)
+
+      self
+    end # on_return(&block)
+
+    # @endgroup
+
+
+
+    # @group Error Handling and 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.redeclare unless predefined?
+    end # auto_recover
+
+    # @endgroup
+
+
+
+    #
+    # Implementation
+    #
+
+
+    def handle_declare_ok(method)
+      @name = method.exchange if self.anonymous?
+      @channel.register_exchange(self)
+
+      self.exec_callback_once_yielding_self(:declare, method)
+    end
+
+    def handle_delete_ok(method)
+      self.exec_callback_once(:delete, method)
+    end # handle_delete_ok(method)
+
+
+
+    self.handle(AMQ::Protocol::Exchange::DeclareOk) do |connection, frame|
+      method   = frame.decode_payload
+      channel  = connection.channels[frame.channel]
+      exchange = channel.exchanges_awaiting_declare_ok.shift
+
+      exchange.handle_declare_ok(method)
+    end # handle
+
+
+    self.handle(AMQ::Protocol::Exchange::DeleteOk) do |connection, frame|
+      channel  = connection.channels[frame.channel]
+      exchange = channel.exchanges_awaiting_delete_ok.shift
+      exchange.handle_delete_ok(frame.decode_payload)
+    end # handle
+
+
+    self.handle(AMQ::Protocol::Basic::Return) do |connection, frame, content_frames|
+      channel  = connection.channels[frame.channel]
+      method   = frame.decode_payload
+      exchange = channel.find_exchange(method.exchange)
+
+      header   = content_frames.shift
+      body     = content_frames.map { |frame| frame.payload }.join
+
+      exchange.exec_callback(:return, method, header, body)
+    end
+
+
+
     protected
 
     # @private