amqp 0.8.0.rc12 → 0.8.0.rc13

data/examples/publishing/{publishing_and_immediately_stopping_event_loop.rb → publishing_a_one_off_message.rb}

@@ -8,12 +8,6 @@ $:.unshift(File.expand_path("../../../lib", __FILE__))
 
 require 'amqp'
 
-if RUBY_VERSION == "1.8.7"
-  class Array
-    alias sample choice
-  end
-end
-
 puts "=> Publishing and immediately stopping the event loop in the callback"
 puts
 
@@ -23,15 +17,18 @@ puts
 #          http://bit.ly/lQP1Al
 
 EventMachine.run do
-  client   = AMQP.connect(:host => '127.0.0.1')
-  channel  = AMQP::Channel.new(client)
-  channel.on_error { puts 'channel error'; EM.stop }
+  connection = AMQP.connect(:host => '127.0.0.1')
+  channel    = AMQP::Channel.new(connection)
+  channel.on_error do |ch, channel_close|
+    puts "Channel-level error: #{channel_close.reply_text}, shutting down..."
+    connection.close { EventMachine.stop }
+  end
 
   queue    = channel.queue("some_topic", :auto_delete => true)
   exchange = channel.topic("foo", :durable => true, :auto_delete => true)
 
-  exchange.publish( 'hello world', :routing_key => "some_topic", :persistent => true, :nowait => false ) do
-    puts 'enqueued message for publishing on next event loop tick'
-    EventMachine.stop
+  exchange.publish('hello world', :routing_key => "some_topic", :persistent => true, :nowait => false ) do
+    puts 'About to disconnect'
+    connection.close { EventMachine.stop }
   end
 end

data/examples/publishing/publishing_callback.rb

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require "bundler"
+Bundler.setup
+
+$:.unshift(File.expand_path("../../../lib", __FILE__))
+
+require 'amqp'
+
+puts "=> Using a callback to #publish. It is run on the _next_ EventMachine loop run."
+puts
+
+EventMachine.run do
+  connection = AMQP.connect(:host => '127.0.0.1')
+  channel    = AMQP::Channel.new(connection)
+  channel.on_error do |ch, channel_close|
+    puts "Channel-level error: #{channel_close.reply_text}, shutting down..."
+    connection.close { EventMachine.stop }
+  end
+
+  queue    = channel.queue("amqpgem.examples.publishing.queue1", :auto_delete => true)
+  exchange = channel.fanout("amqpgem.examples.topic", :durable => true, :auto_delete => true)
+
+  queue.bind(exchange, :routing_key => "some_topic")
+
+
+  # Don't be deceived: this callback is run on the next event loop tick. There is no guarantee that your
+  # data was sent: there is buffering going on on multiple layers (C++ core of EventMachine, libc functions,
+  # kernel uses buffering for many I/O system calls).
+  #
+  # This callback is simply for convenience. In a distributed environment, the only way to know when your data
+  # is sent is when you receive an acknowledgement. TCP works that way. MK.
+
+  100.times do |i|
+    exchange.publish("hello world #{i}", :routing_key => "some_topic", :persistent => true) do
+      puts "Callback #{i} has fired"
+    end
+  end
+
+  exchange.publish("hello world 101", :routing_key => "some_topic", :persistent => false) do
+    puts "Callback 101 has fired"
+  end
+
+  exchange.publish("hello world 102", :routing_key => "some_topic", :persistent => true) do
+    puts "Callback 102 has fired"
+  end
+
+  EventMachine.add_timer(1) do
+    connection.close { EventMachine.stop }
+  end
+end

data/examples/publishing/returned_messages.rb

@@ -19,17 +19,17 @@ puts
 
 AMQP.start(:host => '127.0.0.1') do |connection|
   channel  = AMQP.channel
-  channel.on_error { EM.stop; raise 'channel error' }
+  channel.on_error { |ch, channel_close| EventMachine.stop; raise "channel error: #{channel_close.reply_text}" }
 
   exchange = channel.fanout("amq.fanout")
-  exchange.on_return do |basic_return, header, payload|
+  exchange.on_return do |basic_return, metadata, payload|
     puts "#{payload} was returned! reply_code = #{basic_return.reply_code}, reply_text = #{basic_return.reply_text}"
   end
 
   EventMachine.add_timer(0.3) {
     10.times do |i|
       exchange.publish("Message ##{i}", :immediate => true)
-    end    
+    end
   }
 
   EventMachine.add_timer(2) {

data/examples/queues/accessing_message_metadata.rb

@@ -0,0 +1,60 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require "bundler"
+Bundler.setup
+
+$:.unshift(File.expand_path("../../../lib", __FILE__))
+
+require 'amqp'
+
+EventMachine.run do
+  connection = AMQP.connect(:host => '127.0.0.1')
+  puts "Connected to AMQP broker. Running #{AMQP::VERSION} version of the gem..."
+
+  channel  = AMQP::Channel.new(connection)
+  queue    = channel.queue("amqpgem.examples.hello_world", :auto_delete => true)
+  exchange = channel.direct("amq.direct")
+
+  queue.bind(exchange)
+
+  channel.on_error do |ch, channel_close|
+    puts channel_close.reply_text
+    connection.close { EventMachine.stop }
+  end
+
+  queue.subscribe do |metadata, payload|
+    puts "metadata.routing_key : #{metadata.routing_key}"
+    puts "metadata.content_type: #{metadata.content_type}"
+    puts "metadata.priority    : #{metadata.priority}"
+    puts "metadata.headers     : #{metadata.headers.inspect}"
+    puts "metadata.timestamp   : #{metadata.timestamp.inspect}"
+    puts "metadata.type        : #{metadata.type}"
+    puts "metadata.delivery_tag: #{metadata.delivery_tag}"
+    puts "metadata.redelivered : #{metadata.redelivered}"
+
+    puts "metadata.app_id      : #{metadata.app_id}"
+    puts "metadata.exchange    : #{metadata.exchange}"
+    puts
+    puts "Received a message: #{payload}. Disconnecting..."
+
+    connection.close {
+      EventMachine.stop { exit }
+    }
+  end
+
+  exchange.publish("Hello, world!",
+                   :app_id      => "amqpgem.example",
+                   :priority    => 8,
+                   :type        => "kinda.checkin",
+                   # headers table keys can be anything
+                   :headers     => {
+                     :coordinates => {
+                       :latitude  => 59.35,
+                       :longitude => 18.066667
+                     },
+                     :participants => 11,
+                     :venue        => "Stockholm"
+                   },
+                   :timestamp   => Time.now.to_i)
+end

data/examples/queues/queue_status.rb

@@ -8,13 +8,6 @@ $:.unshift(File.expand_path("../../../lib", __FILE__))
 
 require 'amqp'
 
-if RUBY_VERSION == "1.8.7"
-  class Array
-    alias sample choice
-  end
-end
-
-
 puts "=> Queue#status example"
 puts
 AMQP.start(:host => 'localhost') do |connection|

data/examples/queues/rejecting_messages_without_requeueuing.rb

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require "bundler"
+Bundler.setup
+
+$:.unshift(File.expand_path("../../../lib", __FILE__))
+
+require 'amqp'
+
+if RUBY_VERSION == "1.8.7"
+  class Array
+    alias sample choice
+  end
+end
+
+
+puts "=> Queue#status example"
+puts
+AMQP.start(:host => 'localhost') do |connection|
+  channel   = AMQP::Channel.new(connection)
+
+  exchange = channel.fanout("amqpgem.integration.queue.status.fanout", :auto_delete => true)
+  queue    = channel.queue("amqpgem.integration.queue.status.queue", :auto_delete => true)
+
+  queue.bind(exchange).subscribe do |metadata, payload|
+    puts "Rejecting #{payload}"
+    channel.reject(metadata.delivery_tag)
+  end
+
+  100.times do |i|
+    print "."
+    exchange.publish(Time.now.to_i.to_s + "_#{i}", :key => queue.name)
+  end
+  $stdout.flush
+
+
+  show_stopper = Proc.new do
+    $stdout.puts "Stopping..."
+    connection.close {
+      EventMachine.stop { exit }
+    }
+  end
+
+  Signal.trap "INT", show_stopper
+  EventMachine.add_timer(2, show_stopper)
+end

data/examples/queues/using_explicit_acknowledgements.rb

@@ -0,0 +1,96 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require "bundler"
+Bundler.setup
+
+$:.unshift(File.expand_path("../../../lib", __FILE__))
+
+require 'amqp'
+
+puts "=> Subscribing for messages using explicit acknowledgements model"
+puts
+
+# this example uses Kernel#sleep and thus we must run EventMachine reactor in
+# a separate thread, or nothing will be sent/received while we sleep() on the current thread.
+t = Thread.new { EventMachine.run }
+sleep(0.5)
+
+# open two connections to imitate two apps
+connection1 = AMQP.connect
+connection2 = AMQP.connect
+connection3 = AMQP.connect
+
+channel_exception_handler = Proc.new { |ch, channel_close| EventMachine.stop; raise "channel error: #{channel_close.reply_text}" }
+
+# open two channels
+channel1    = AMQP::Channel.new(connection1)
+channel1.on_error(&channel_exception_handler)
+# first app will be given up to 3 messages at a time. If it doesn't
+# ack any messages after it was delivered 3, messages will be routed to
+# the app #2.
+channel1.prefetch(3)
+
+channel2    = AMQP::Channel.new(connection2)
+channel2.on_error(&channel_exception_handler)
+# app #2 processes messages one-by-one and has to send and ack every time
+channel2.prefetch(1)
+
+# app 3 will just publish messages
+channel3    = AMQP::Channel.new(connection3)
+channel3.on_error(&channel_exception_handler)
+
+exchange = channel3.direct("amq.direct")
+
+queue1    = channel1.queue("amqpgem.examples.acknowledgements.explicit", :auto_delete => false)
+# purge the queue so that we don't get any redeliveries from previous runs
+queue1.purge
+queue1.bind(exchange).subscribe(:ack => true) do |metadata, payload|
+  # do some work
+  sleep(0.2)
+
+  # acknowledge some messages, they will be removed from the queue
+  if rand > 0.5
+    # FYI: there is a shortcut, metadata.ack
+    channel1.acknowledge(metadata.delivery_tag, false)
+    puts "[consumer1] Got message ##{metadata.headers['i']}, ack-ed"
+  else
+    # some messages are not ack-ed and will remain in the queue for redelivery
+    # when app #1 connection is closed (either properly or due to a crash)
+    puts "[consumer1] Got message ##{metadata.headers['i']}, SKIPPPED"
+  end
+end
+
+queue2    = channel2.queue!("amqpgem.examples.acknowledgements.explicit", :auto_delete => false)
+queue2.subscribe(:ack => true) do |metadata, payload|
+  metadata.ack
+  # app 2 always acks messages
+  puts "[consumer2] Received #{payload}, redelivered = #{metadata.redelivered}, ack-ed"
+end
+
+# after some time one of the consumers quits/crashes
+EventMachine.add_timer(4.0) {
+  connection1.close
+  puts "----- Connection 1 is now closed (we pretend that it has crashed) -----"
+}
+
+EventMachine.add_timer(10.0) do
+  # purge the queue so that we don't get any redeliveries on the next run
+  queue2.purge {
+    connection2.close {
+      connection3.close { EventMachine.stop }
+    }
+  }
+end
+
+
+i = 0
+EventMachine.add_periodic_timer(0.8) {
+  3.times do
+    exchange.publish("Message ##{i}", :headers => { :i => i })
+    i += 1
+  end
+}
+
+
+t.join

data/examples/routing/headers_routing.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require "bundler"
+Bundler.setup
+
+$:.unshift(File.expand_path("../../../lib", __FILE__))
+
+require 'amqp'
+
+puts "=> Headers routing example"
+puts
+AMQP.start do |connection|
+  channel   = AMQP::Channel.new(connection)
+  channel.on_error do |ch, channel_close|
+    puts "A channel-level exception: #{channel_close.inspect}"
+  end
+
+  exchange = channel.headers("amq.match", :durable => true)
+
+  channel.queue("", :auto_delete => true).bind(exchange, :arguments => { 'x-match' => 'all', :arch => "x64", :os => 'linux' }).subscribe do |metadata, payload|
+    puts "[linux/x64] Got a message: #{payload}"
+  end
+  channel.queue("", :auto_delete => true).bind(exchange, :arguments => { 'x-match' => 'all', :arch => "x32", :os => 'linux' }).subscribe do |metadata, payload|
+    puts "[linux/x32] Got a message: #{payload}"
+  end
+  channel.queue("", :auto_delete => true).bind(exchange, :arguments => { 'x-match' => 'any', :os => 'linux', :arch => "__any__" }).subscribe do |metadata, payload|
+    puts "[linux] Got a message: #{payload}"
+  end
+  channel.queue("", :auto_delete => true).bind(exchange, :arguments => { 'x-match' => 'any', :os => 'macosx', :cores => 8 }).subscribe do |metadata, payload|
+    puts "[macosx|octocore] Got a message: #{payload}"
+  end
+
+
+  EventMachine.add_timer(0.5) do
+    exchange.publish "For linux/x64",   :headers => { :arch => "x64", :os => 'linux' }
+    exchange.publish "For linux/x32",   :headers => { :arch => "x32", :os => 'linux' }
+    exchange.publish "For linux",       :headers => { :os => 'linux'  }
+    exchange.publish "For OS X",        :headers => { :os => 'macosx' }
+    exchange.publish "For solaris/x64", :headers => { :os => 'solaris', :arch => 'x64' }
+    exchange.publish "For ocotocore",   :headers => { :cores => 8  }
+  end
+
+
+  show_stopper = Proc.new do
+    $stdout.puts "Stopping..."
+    connection.close {
+      EventMachine.stop { exit }
+    }
+  end
+
+  Signal.trap "INT", show_stopper
+  EventMachine.add_timer(2, show_stopper)
+end

data/lib/amqp/channel.rb

@@ -205,6 +205,7 @@ module AMQP
     def initialize(connection = nil, id = self.class.next_channel_id, options = {}, &block)
       raise 'AMQP can only be used from within EM.run {}' unless EM.reactor_running?
 
+      @options    = options
       @connection = connection || AMQP.connection || AMQP.start
 
       super(@connection, id)
@@ -241,20 +242,10 @@ module AMQP
       end # @connection.on_open
     end
 
-    # Takes a block that will be deferred till the moment when channel is considered open
-    # (channel.open-ok is received from the broker). If you need to delay an operation
-    # till the moment channel is open, this method is what you are looking for.
-    #
-    # Multiple callbacks are supported. If when this moment is called, channel is already
-    # open, block is executed immediately.
-    #
-    # @api public
-    def once_open(&block)
-      @channel_is_open_deferrable.callback(&block)
-    end # once_open(&block)
-    alias once_opened once_open
 
 
+    # @group Declaring exchanges
+
     # Defines, intializes and returns a direct Exchange instance.
     #
     # Learn more about direct exchanges in {Exchange Exchange class documentation}.
@@ -336,6 +327,7 @@ module AMQP
 
         validate_parameters_match!(exchange, extended_opts)
 
+        block.call(exchange) if block
         exchange
       else
         register_exchange(Exchange.new(self, :direct, name, opts, &block))
@@ -443,6 +435,7 @@ module AMQP
 
         validate_parameters_match!(exchange, extended_opts)
 
+        block.call(exchange) if block
         exchange
       else
         register_exchange(Exchange.new(self, :fanout, name, opts, &block))
@@ -558,6 +551,7 @@ module AMQP
 
         validate_parameters_match!(exchange, extended_opts)
 
+        block.call(exchange) if block
         exchange
       else
         register_exchange(Exchange.new(self, :topic, name, opts, &block))
@@ -601,9 +595,53 @@ module AMQP
     # @raise [AMQP::Error] Raised when exchange is declared with  :passive => true and the exchange does not exist.
     #
     #
-    # @example Using fanout exchange to deliver messages to multiple consumers
+    # @example Using headers exchange to route messages based on multiple attributes (OS, architecture, # of cores)
+    #
+    #   puts "=> Headers routing example"
+    #   puts
+    #   AMQP.start do |connection|
+    #     channel   = AMQP::Channel.new(connection)
+    #     channel.on_error do |ch, channel_close|
+    #       puts "A channel-level exception: #{channel_close.inspect}"
+    #     end
+    #
+    #     exchange = channel.headers("amq.match", :durable => true)
+    #
+    #     channel.queue("", :auto_delete => true).bind(exchange, :arguments => { 'x-match' => 'all', :arch => "x64", :os => 'linux' }).subscribe do |metadata, payload|
+    #       puts "[linux/x64] Got a message: #{payload}"
+    #     end
+    #     channel.queue("", :auto_delete => true).bind(exchange, :arguments => { 'x-match' => 'all', :arch => "x32", :os => 'linux' }).subscribe do |metadata, payload|
+    #       puts "[linux/x32] Got a message: #{payload}"
+    #     end
+    #     channel.queue("", :auto_delete => true).bind(exchange, :arguments => { 'x-match' => 'any', :os => 'linux', :arch => "__any__" }).subscribe do |metadata, payload|
+    #       puts "[linux] Got a message: #{payload}"
+    #     end
+    #     channel.queue("", :auto_delete => true).bind(exchange, :arguments => { 'x-match' => 'any', :os => 'macosx', :cores => 8 }).subscribe do |metadata, payload|
+    #       puts "[macosx|octocore] Got a message: #{payload}"
+    #     end
+    #
+    #
+    #     EventMachine.add_timer(0.5) do
+    #       exchange.publish "For linux/x64",   :headers => { :arch => "x64", :os => 'linux' }
+    #       exchange.publish "For linux/x32",   :headers => { :arch => "x32", :os => 'linux' }
+    #       exchange.publish "For linux",       :headers => { :os => 'linux'  }
+    #       exchange.publish "For OS X",        :headers => { :os => 'macosx' }
+    #       exchange.publish "For solaris/x64", :headers => { :os => 'solaris', :arch => 'x64' }
+    #       exchange.publish "For ocotocore",   :headers => { :cores => 8  }
+    #     end
+    #
+    #
+    #     show_stopper = Proc.new do
+    #       $stdout.puts "Stopping..."
+    #       connection.close {
+    #         EventMachine.stop { exit }
+    #       }
+    #     end
+    #
+    #     Signal.trap "INT", show_stopper
+    #     EventMachine.add_timer(2, show_stopper)
+    #   end
     #
-    #   # TODO
     #
     #
     # @see Exchange
@@ -619,12 +657,18 @@ module AMQP
 
         validate_parameters_match!(exchange, extended_opts)
 
+        block.call(exchange) if block
         exchange
       else
         register_exchange(Exchange.new(self, :headers, name, opts, &block))
       end
     end
 
+    # @endgroup
+
+
+    # @group Declaring queues
+
 
     # Declares and returns a Queue instance associated with this channel. See {Queue Queue class documentation} for
     # more information about queues.
@@ -714,19 +758,13 @@ module AMQP
 
         validate_parameters_match!(queue, extended_opts)
 
+        block.call(queue) if block
         queue
       else
         self.queue!(name, opts, &block)
       end
     end
 
-    # Returns true if channel is not closed.
-    # @return [Boolean]
-    # @api public
-    def open?
-      self.status == :opened || self.status == :opening
-    end # open?
-
     # Same as {Channel#queue} but when queue with the same name already exists in this channel
     # object's cache, this method will replace existing queue with a newly defined one. Consider
     # using {Channel#queue} instead.
@@ -753,6 +791,9 @@ module AMQP
       register_queue(queue)
     end
 
+    # @endgroup
+
+
 
     # Instantiates and returns an RPC instance associated with this channel.
     #
@@ -763,8 +804,8 @@ module AMQP
     #
     # Marshalling and unmarshalling the objects is handled internally. This
     # marshalling is subject to the same restrictions as defined in the
-    # Marshal[http://ruby-doc.org/core/classes/Marshal.html] standard
-    # library. See that documentation for further reference.
+    # [http://ruby-doc.org/core/classes/Marshal.html Marshal module} in the Ruby standard
+    # library.
     #
     # When the optional object is not passed, the returned rpc reference is
     # used to send messages and arguments to the queue. See {AMQP::RPC#method_missing}
@@ -787,6 +828,82 @@ module AMQP
 
 
 
+    # Returns a hash of all rpc proxy objects.
+    #
+    # Most of the time, this method is not
+    # called by application code.
+    # @api plugin
+    def rpcs
+      @rpcs.values
+    end
+
+
+
+    # @group Channel lifecycle
+
+    # Opens AMQP channel.
+    #
+    # @note Instantiated channels are opened by default. This method should only be used for error recovery after network connection loss.
+    # @api public
+    def open(&block)
+      super(&block)
+    end
+
+    # @return [Boolean] true if channel is not closed.
+    # @api public
+    def open?
+      self.status == :opened || self.status == :opening
+    end # open?
+
+    # Takes a block that will be deferred till the moment when channel is considered open
+    # (channel.open-ok is received from the broker). If you need to delay an operation
+    # till the moment channel is open, this method is what you are looking for.
+    #
+    # Multiple callbacks are supported. If when this moment is called, channel is already
+    # open, block is executed immediately.
+    #
+    # @api public
+    def once_open(&block)
+      @channel_is_open_deferrable.callback(&block)
+    end # once_open(&block)
+    alias once_opened once_open
+
+    # Closes AMQP channel.
+    #
+    # @api public
+    def close(reply_code = 200, reply_text = DEFAULT_REPLY_TEXT, class_id = 0, method_id = 0, &block)
+      super(reply_code, reply_text, class_id, method_id, &block)
+    end
+
+    # @endgroup
+
+
+
+
+    # @group QoS and flow handling
+
+    # Asks the peer to pause or restart the flow of content data sent to a consumer.
+    # This is a simple flow­control mechanism that a peer can use to avoid overflowing its
+    # queues or otherwise finding itself receiving more messages than it can process. Note that
+    # this method is not intended for window control. It does not affect contents returned to
+    # Queue#get callers.
+    #
+    # @param [Boolean] Desired flow state.
+    #
+    # @see http://bit.ly/htCzCX AMQP 0.9.1 protocol documentation (Section 1.5.2.3.)
+    # @api public
+    def flow(active = false, &block)
+      super(active, &block)
+    end
+
+    # @return [Boolean]  True if flow in this channel is active (messages will be delivered to consumers that use this channel).
+    #
+    # @api public
+    def flow_is_active?
+      @flow_is_active
+    end # flow_is_active?
+
+
 
     # @param [Fixnum] Message count
     # @param [Boolean] global (false)
@@ -803,18 +920,106 @@ module AMQP
       self
     end
 
+    # @endgroup
 
 
-    # Returns a hash of all rpc proxy objects.
+
+    # @group Message acknowledgements
+
+    # Acknowledge one or all messages on the channel.
     #
-    # Most of the time, this method is not
-    # called by application code.
-    # @api plugin
-    def rpcs
-      @rpcs.values
+    # @api public
+    # @see #reject
+    # @see #recover
+    # @see http://bit.ly/htCzCX AMQP 0.9.1 protocol documentation (Section 1.8.3.13.)
+    def acknowledge(delivery_tag, multiple = false)
+      super(delivery_tag, multiple)
+    end # acknowledge(delivery_tag, multiple = false)
+
+    # Reject a message with given delivery tag.
+    #
+    # @api public
+    # @see #acknowledge
+    # @see #recover
+    # @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)
+    end # reject(delivery_tag, requeue = true)
+
+    # Notifies AMQ broker that consumer has recovered and unacknowledged messages need
+    # to be redelivered.
+    #
+    # @return [Channel]  self
+    #
+    # @note RabbitMQ as of 2.3.1 does not support basic.recover with requeue = false.
+    # @see http://bit.ly/htCzCX AMQP 0.9.1 protocol documentation (Section 1.8.3.16.)
+    # @see #acknowledge
+    # @api public
+    def recover(requeue = true, &block)
+      super(requeue, &block)
+    end # recover(requeue = false, &block)
+
+    # @endgroup
+
+
+
+
+    # @group Transactions
+
+    # Sets the channel to use standard transactions. One must use this method at least
+    # once on a channel before using #tx_tommit or tx_rollback methods.
+    #
+    # @api public
+    def tx_select(&block)
+      super(&block)
+    end # tx_select(&block)
+
+    # Commits AMQP transaction.
+    #
+    # @api public
+    def tx_commit(&block)
+      super(&block)
+    end # tx_commit(&block)
+
+    # Rolls AMQP transaction back.
+    #
+    # @api public
+    def tx_rollback(&block)
+      super(&block)
+    end # tx_rollback(&block)
+
+
+    # @endgroup
+
+
+
+
+
+    # @group Error handling
+
+    # Defines a callback that will be executed when channel is closed after
+    # channel-level exception.
+    #
+    # @api public
+    def on_error(&block)
+      super(&block)
     end
 
 
+    # Defines a global callback to be run on channel-level exception across
+    # all channels. Consider using Channel#on_error instead. This method is here for sake
+    # of backwards compatibility with 0.6.x and 0.7.x releases.
+    # @see AMQP::Channel#on_error
+    # @deprecated
+    # @api public
+    def self.on_error(&block)
+      self.error(&block)
+    end # self.on_error(&block)
+
+    # @endgroup
+
+
+
 
     #
     # Implementation
@@ -838,15 +1043,6 @@ module AMQP
       end
     end
 
-    # Defines a global callback to be run on channel-level exception across
-    # all channels. Consider using Channel#on_error instead. This method is here for sake
-    # of backwards compatibility with 0.6.x and 0.7.x releases.
-    # @see AMQP::Channel#on_error
-    # @deprecated
-    # @api public
-    def self.on_error(&block)
-      self.error(&block)
-    end # self.on_error(&block)
 
     # Overrides AMQ::Client::Channel version to also call global callback
     # (if defined) for backwards compatibility.
@@ -867,12 +1063,19 @@ module AMQP
     #
     # @private
     # @api plugin
-    def reset
+    def reset(&block)
       # See AMQ::Client::Channel
       self.reset_state!
 
       # there is no way to reset a deferrable; we have to use a new instance. MK.
       @channel_is_open_deferrable = AMQ::Client::EventMachineClient::Deferrable.new
+      @channel_is_open_deferrable.callback(&block)
+
+      @connection.on_connection do
+        @channel_is_open_deferrable.succeed
+
+        self.prefetch(@options[:prefetch], false) if @options[:prefetch]
+      end
     end
 
     # @private
@@ -930,8 +1133,9 @@ module AMQP
     # Backwards compatibility with 0.6.x
     #
 
-    # unique identifier
+    # unique identifier of the default thread-local channel
     # @deprecated
+    # @private
     def self.id
       Thread.current[:mq_id] ||= "#{`hostname`.strip}-#{Process.pid}-#{Thread.current.object_id}"
     end
@@ -956,6 +1160,7 @@ module AMQP
 
     # @private
     def validate_parameters_match!(entity, parameters)
+      parameters.delete(:no_declare)
       unless entity.opts == parameters || parameters[:passive]
         raise AMQP::IncompatibleOptionsError.new(entity.name, entity.opts, parameters)
       end