bunny 0.8.0 → 0.9.0.pre1

data/.gitignore

@@ -9,4 +9,10 @@
 Gemfile.lock
 .rbx/*
 .tags
-.tags_sorted_by_file
+.tags_sorted_by_file
+.Apple*
+bin/*
+.bundle/*
+vendor/*
+playground/*
+*.org

data/.travis.yml

@@ -1,11 +1,21 @@
 bundler_args: --without development
-script: "bundle exec rspec spec"
+before_script: "./bin/ci/before_build.sh"
+script: "bundle exec rspec -c spec"
 rvm:
   - 1.8.7
-  - ree
   - 1.9.2
   - 1.9.3
+  - ruby-head
   - rbx-18mode
-  # - rbx-19mode
+  - rbx-19mode
+  - jruby-19mode
 notifications:
-  email: false
+  email: michael@defprotocol.org
+services:
+  - rabbitmq
+branches:
+  only:
+    - master
+    - 0.8.x-stable
+    - 0.9.x-stable
+    - migrate_to_amq_protocol

data/ChangeLog.md

@@ -0,0 +1,72 @@
+# Changes between Bunny 0.8.x and 0.9.0
+
+## New convenience functions: Bunny::Channel#fanout, Bunny::Channel#topic
+
+`Bunny::Channel#fanout`, `Bunny::Channel#topic`, `Bunny::Channel#direct`, `Bunny::Channel#headers`,
+and`Bunny::Channel#default_exchange` are new convenience methods to instantiate exchanges:
+
+``` ruby
+conn = Bunny.new
+conn.start
+
+ch = conn.create_channel
+x  = ch.fanout("logging.events", :durable => true)
+```
+
+
+## Bunny::Queue#pop and consumer handlers (Bunny::Queue#subscribe) signatures have changed
+
+Bunny `< 0.9.x` example:
+
+``` ruby
+h = queue.pop
+
+puts h[:delivery_info], h[:header], h[:payload]
+```
+
+Bunny `>= 0.9.x` example:
+
+``` ruby
+delivery_info, properties, payload = queue.pop
+```
+
+The improve is both in that Ruby has positional destructuring, e.g.
+
+``` ruby
+delivery_info, _, content = q.pop
+```
+
+but not hash destructuring, like, say, Clojure does.
+
+In addition we return nil for content when it should be nil
+(basic.get-empty) and unify these arguments betwee
+
+ * Bunny::Queue#pop
+
+ * Consumer (Bunny::Queue#subscribe, etc) handlers
+
+ * Returned message handlers
+
+The unification moment was the driving factor.
+
+
+
+## Bunny::Client#write now raises Bunny::ConnectionError
+
+Bunny::Client#write now raises `Bunny::ConnectionError` instead of `Bunny::ServerDownError` when network
+I/O operations fail.
+
+
+## Bunny::Client.create_channel now uses a bitset-based allocator
+
+Instead of reusing channel instances, `Bunny::Client.create_channel` now opens new channels and
+uses bitset-based allocator to keep track of used channel ids. This avoids situations when
+channels are reused or shared without developer's explicit intent but also work well for
+long running applications that aggressively open and release channels.
+
+This is also how amqp gem and RabbitMQ Java client manage channel ids.
+
+
+## Bunny::ServerDownError is now Bunny::TCPConnectionFailed
+
+`Bunny::ServerDownError` is now an alias for `Bunny::TCPConnectionFailed`

data/Gemfile

@@ -21,19 +21,25 @@ extend Module.new {
 
 gem "SystemTimer", "1.2", :platform => :ruby_18
 
-group :development do
-  gem "rake"
-
-  gem "yard", ">= 0.7.2"
-
-  # Yard tags this buddy along.
-  gem "RedCloth",  :platform => :mri
-
-  gem "changelog"
-end
+gem "rake"
+gem "effin_utf8"
 
 group :test do
-  gem "rspec", "~> 2.6.0"
+  gem "rspec", "~> 2.8.0"
 end
 
 gemspec
+
+# 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("../vendor/#{name}", __FILE__)
+  if File.exist?(local_path)
+    puts "Using #{name} from #{local_path}..."
+    gem name, options.merge(:path => local_path).delete_if { |key, _| [:git, :branch].include?(key) }
+  else
+    gem name, options
+  end
+end
+
+custom_gem "amq-protocol", :git => "git://github.com/ruby-amqp/amq-protocol.git", :branch => "master"

data/README.md

@@ -0,0 +1,82 @@
+# About Bunny
+
+Bunny is a synchronous RabbitMQ client that focuses on ease of use.
+
+
+## Supported Ruby Versions
+
+It supports Ruby 1.9.3, 1.9.2, 1.8.7, Rubinius 2 and JRuby.
+
+
+## Supported RabbitMQ Versions
+
+Bunny versions `< 0.7.x` support RabbitMQ 1.x and 2.x. Bunny `0.8.x` and later versions only
+supports RabbitMQ 2.x.
+
+
+## Important: Bunny is about to undergo a lot of internal changes
+
+Bunny is a very old library with **a lot** of missing functionality. It also implements an older version of the spec
+and may or may not work with future RabbitMQ versions. As such, Bunny is about to undergo serious internal changes.
+We will make our best to keep them as backwards compatible as possible but within reason.
+
+See [this announcement](https://groups.google.com/forum/?fromgroups#!topic/ruby-amqp/crNVGEuHm68) to learn more.
+
+In the meantime, consider using [Hot Bunnies](http://github.com/ruby-amqp/hot_bunnies) (JRuby-only) or [amqp gem](http://rubyamqp.info) instead.
+
+
+## Quick Start for Bunny 0.7.x and 0.8.x
+
+``` ruby
+require "bunny"
+
+b = Bunny.new(:logging => true)
+
+# start a communication session with the amqp server
+b.start
+
+# declare a queue
+q = b.queue("test1")
+
+# declare default direct exchange which is bound to all queues
+e = b.exchange("")
+
+# publish a message to the exchange which then gets routed to the queue
+e.publish("Hello, everybody!", :key => 'test1')
+
+# get message from the queue
+msg = q.pop[:payload]
+
+puts "This is the message: " + msg + "\n\n"
+
+# close the connection
+b.stop
+```
+
+... or just:
+
+```
+require "bunny"
+
+# Create a direct queue named "my_testq"
+Bunny.run { |c| c.queue("my_testq") }
+```
+
+## Community & Getting Help
+
+Please use [Ruby RabbitMQ clients Google Group](http://groups.google.com/group/ruby-amqp) for any questions you may
+have.
+
+For news and updates, [follow @rubyamqp](http://twitter.com/rubyamqp) on Twitter.
+
+
+
+## Other Resources
+
+* [AMQP 0.9.1 model explained](): introductory explanation of the AMQP v0.9.1 specification with particular reference to RabbitMQ.
+
+
+## Links
+
+* [Source code](http://github.com/ruby-amqp/bunny)
+* [Blog](http://bunnyamqp.wordpress.com)

data/bunny.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |s|
   s.name = "bunny"
   s.version = Bunny::VERSION.dup
   s.homepage = "http://github.com/ruby-amqp/bunny"
-  s.summary = "Synchronous Ruby AMQP 0.8.0 client"
-  s.description = "A synchronous Ruby AMQP client that enables interaction with AMQP-compliant brokers."
+  s.summary = "Easy to use synchronous Ruby client for RabbitMQ"
+  s.description = "Easy to use synchronous Ruby client for RabbitMQ"
 
   # Sorted alphabetically.
   s.authors = [
@@ -27,20 +27,13 @@ Gem::Specification.new do |s|
     "c2thZXNAcmFpbHNleHByZXNzLmRl\n"].
     map { |mail| Base64.decode64(mail) }
 
+  # Dependencies
+  s.add_dependency "amq-protocol", ">= 1.0.0"
+
   # Files.
   s.has_rdoc = true
-  s.extra_rdoc_files = ["README.textile"]
-  s.rdoc_options = ["--main", "README.rdoc"]
+  s.extra_rdoc_files = ["README.md"]
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- spec/*`.split("\n")
   s.require_paths = ["lib"]
-
-  begin
-    require "changelog"
-    s.post_install_message = CHANGELOG.new.version_changes
-  rescue LoadError
-  end
-
-  # RubyForge
-  s.rubyforge_project = "bunny-amqp"
 end

data/examples/connection/heartbeat.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require "bundler"
+Bundler.setup
+
+$:.unshift(File.expand_path("../../../lib", __FILE__))
+
+require 'bunny'
+
+
+b = Bunny.new(:heartbeat_interval => 2)
+b.start
+
+c = b.create_channel
+
+sleep 10

data/lib/bunny.rb

@@ -1,54 +1,67 @@
-# encoding: utf-8
+# -*- encoding: utf-8; mode: ruby -*-
 
-require "socket"
-require "thread"
 require "timeout"
-require "logger"
 
-require File.expand_path("../bunny/version", __FILE__)
-# if we don't require the version file the same way as in the gemspec,
-# the version file will be loaded twice. and we hate warnings.
+require "bunny/version"
+require "amq/protocol/client"
+
+require "bunny/framing"
+require "bunny/exceptions"
+require "bunny/socket"
+
+# Core entities: connection, channel, exchange, queue, consumer
+require "bunny/session"
+require "bunny/channel"
+require "bunny/exchange"
+require "bunny/queue"
+require "bunny/consumer"
 
 module Bunny
+  PROTOCOL_VERSION = AMQ::Protocol::PROTOCOL_VERSION
+
+  # unifies Ruby standard library's Timeout (which is not accurate on
+  # Ruby 1.8 and has other issues) and SystemTimer (the gem)
+  Timer = if RUBY_VERSION < "1.9"
+            begin
+              require "bunny/system_timer"
+              Bunny::SystemTimer
+            rescue LoadError
+              Timeout
+            end
+          else
+            Timeout
+          end
 
-  class ConnectionError < StandardError; end
-  class ForcedChannelCloseError < StandardError; end
-  class ForcedConnectionCloseError < StandardError; end
-  class MessageError < StandardError; end
-  class ProtocolError < StandardError; end
-  class ServerDownError < StandardError; end
-  class UnsubscribeError < StandardError; end
-  class AcknowledgementError < StandardError; end
 
-  # Returns the Bunny version number
+  #
+  # API
+  #
 
   def self.version
     VERSION
   end
 
-  # Print deprecation warning.
-  def self.deprecation_warning(method, version, explanation)
-    warn "~ #{method} will be removed in Bunny #{version}. #{explanation}"
+  def self.protocol_version
+    AMQ::Protocol::PROTOCOL_VERSION
   end
 
-  # Instantiates new Bunny::Client
 
-  def self.new(connection_string_or_opts = Hash.new, opts = Hash.new)
-    # Set up Bunny
+  def self.new(connection_string_or_opts = {}, opts = {}, &block)
     if connection_string_or_opts.respond_to?(:keys) && opts.empty?
       opts = connection_string_or_opts
     end
 
-    # Return client
-    setup(connection_string_or_opts, opts)
+    conn = Session.new(connection_string_or_opts, opts)
+    @default_connection ||= conn
+
+    conn
   end
 
-  # Runs a code block using a Bunny connection
+
   def self.run(connection_string_or_opts = {}, opts = {}, &block)
     raise ArgumentError, 'Bunny#run requires a block' unless block
 
-    # Set up Bunny
-    client = setup(connection_string_or_opts, opts)
+    client = Client.new(connection_string_or_opts, opts)
 
     begin
       client.start
@@ -57,35 +70,6 @@ module Bunny
       client.stop
     end
 
-    # Return success
     :run_ok
   end
-
-  Timer = if RUBY_VERSION < "1.9"
-            begin
-              require File.expand_path(File.join(File.dirname(__FILE__), 'system_timer.rb'))
-              Bunny::SystemTimer
-            rescue LoadError
-              Timeout
-            end
-          else
-            Timeout
-          end
-
-  private
-
-  def self.setup(*args)
-    # AMQP 0-9-1 specification
-    require 'qrack/qrack'
-    require 'bunny/client'
-    require 'bunny/exchange'
-    require 'bunny/queue'
-    require 'bunny/channel'
-    require 'bunny/subscription'
-
-    include Qrack
-
-    client = Bunny::Client.new(*args)
-  end
-
 end

data/lib/bunny/channel.rb

@@ -1,39 +1,635 @@
-# encoding: utf-8
+require "thread"
+require "amq/int_allocator"
+
+require "bunny/consumer_work_pool"
+
+require "bunny/exchange"
+require "bunny/queue"
+require "bunny/message_metadata"
 
 module Bunny
-  class Channel < Qrack::Channel
+  class Channel
+
+    #
+    # API
+    #
+
+    attr_accessor :id, :connection, :status, :work_pool
+
+
+    def initialize(connection = nil, id = nil, work_pool = ConsumerWorkPool.new(1))
+      @connection = connection
+      @id         = id || @connection.next_channel_id
+      @status     = :opening
+
+      @connection.register_channel(self)
 
-    def initialize(client)
-      super
+      @queues     = Hash.new
+      @exchanges  = Hash.new
+      @consumers  = Hash.new
+      @work_pool  = work_pool
+
+      # synchronizes frameset delivery. MK.
+      @mutex          = Mutex.new
+      @consumer_mutex = Mutex.new
+
+      @continuations = ::Queue.new
     end
 
+
     def open
-      client.channel = self
-      client.send_frame(Qrack::Protocol::Channel::Open.new)
+      @connection.open_channel(self)
+      @status = :open
+
+      self
+    end
+
+    def close
+      @connection.close_channel(self)
+      closed!
+    end
 
-      method = client.next_method
+    def open?
+      @status == :open
+    end
 
-      client.check_response(method, Qrack::Protocol::Channel::OpenOk, "Cannot open channel #{number}")
+    def closed?
+      @status == :closed
+    end
+
+    def queue(name = AMQ::Protocol::EMPTY_STRING, opts = {})
+      q = find_queue(name) || Bunny::Queue.new(self, name, opts)
 
-      @active = true
-      :open_ok
+      register_queue(q)
     end
 
-    def close
-      client.channel = self
-      client.send_frame(Qrack::Protocol::Channel::Close.new(:reply_code => 200, :reply_text => 'bye', :method_id => 0, :class_id => 0))
 
-      method = client.next_method
+    #
+    # Backwards compatibility with 0.8.0
+    #
 
-      client.check_response(method, Qrack::Protocol::Channel::CloseOk, "Error closing channel #{number}")
+    def number
+      self.id
+    end
 
-      @active = false
-      :close_ok
+    def active
+      @active
     end
 
-    def open?
-      active
+    def client
+      @connection
+    end
+
+    def frame_size
+      @connection.frame_max
     end
 
+
+    #
+    # Higher-level API, similar to amqp gem
+    #
+
+    def fanout(name, opts = {})
+      Exchange.new(self, :fanout, name, opts)
+    end
+
+    def direct(name, opts = {})
+      Exchange.new(self, :direct, name, opts)
+    end
+
+    def topic(name, opts = {})
+      Exchange.new(self, :topic, name, opts)
+    end
+
+    def headers(name, opts = {})
+      Exchange.new(self, :headers, name, opts)
+    end
+
+    def default_exchange
+      self.direct("", :no_declare => true)
+    end
+
+    def prefetch(prefetch_count)
+      self.basic_qos(prefetch_count, false)
+    end
+
+    def flow(active)
+      channel_flow(active)
+    end
+
+    def recover(ignored = true)
+      # RabbitMQ only supports basic.recover with requeue = true
+      basic_recover(true)
+    end
+
+    def reject(delivery_tag, requeue = false)
+      basic_reject(delivery_tag, requeue)
+    end
+
+    def ack(delivery_tag, multiple)
+      basic_ack(delivery_tag, multiple)
+    end
+    alias acknowledge ack
+
+    def nack(delivery_tag, requeue, multiple = false)
+      basic_nack(delivery_tag, requeue, multiple)
+    end
+
+    def on_error(&block)
+      @default_error_handler = block
+    end
+
+
+    #
+    # Lower-level API, exposes protocol operations as they are defined in the protocol,
+    # without any OO sugar on top, by design.
+    #
+
+    # basic.*
+
+    def basic_publish(payload, exchange, routing_key, opts = {})
+      raise_if_no_longer_open!
+
+      exchange_name = if exchange.respond_to?(:name)
+                        exchange.name
+                      else
+                        exchange
+                      end
+
+      meta = { :priority => 0, :delivery_mode => 2, :content_type => "application/octet-stream" }.
+        merge(opts)
+      @connection.send_frameset(AMQ::Protocol::Basic::Publish.encode(@id, payload, meta, exchange_name, routing_key, meta[:mandatory], false, (frame_size || @connection.frame_max)), self)
+
+      self
+    end
+
+    def basic_get(queue, opts = {:ack => true})
+      raise_if_no_longer_open!
+
+      @connection.send_frame(AMQ::Protocol::Basic::Get.encode(@id, queue, !opts[:ack]))
+      @last_basic_get_response = @continuations.pop
+
+      raise_if_continuation_resulted_in_a_channel_error!
+      @last_basic_get_response
+    end
+
+    def basic_qos(prefetch_count, global = false)
+      raise ArgumentError.new("prefetch count must be a positive integer, given: #{prefetch_count}") if prefetch_count < 0
+      raise_if_no_longer_open!
+
+      @connection.send_frame(AMQ::Protocol::Basic::Qos.encode(@id, 0, prefetch_count, global))
+
+      Bunny::Timer.timeout(1, ClientTimeout) do
+        @last_basic_qos_ok = @continuations.pop
+      end
+      raise_if_continuation_resulted_in_a_channel_error!
+
+      @last_basic_qos_ok
+    end
+
+    def basic_recover(requeue)
+      raise_if_no_longer_open!
+
+      @connection.send_frame(AMQ::Protocol::Basic::Recover.encode(@id, requeue))
+      Bunny::Timer.timeout(1, ClientTimeout) do
+        @last_basic_recover_ok = @continuations.pop
+      end
+      raise_if_continuation_resulted_in_a_channel_error!
+
+      @last_basic_recover_ok
+    end
+
+    def basic_reject(delivery_tag, requeue)
+      raise_if_no_longer_open!
+      @connection.send_frame(AMQ::Protocol::Basic::Reject.encode(@id, delivery_tag, requeue))
+
+      nil
+    end
+
+    def basic_ack(delivery_tag, multiple)
+      raise_if_no_longer_open!
+      @connection.send_frame(AMQ::Protocol::Basic::Ack.encode(@id, delivery_tag, multiple))
+
+      nil
+    end
+
+    def basic_nack(delivery_tag, requeue, multiple = false)
+      raise_if_no_longer_open!
+      @connection.send_frame(AMQ::Protocol::Basic::Nack.encode(@id, delivery_tag, requeue, multiple))
+
+      nil
+    end
+
+    def basic_consume(queue, consumer_tag = generate_consumer_tag, no_ack = false, exclusive = false, arguments = nil, &block)
+      raise_if_no_longer_open!
+      maybe_start_consumer_work_pool!
+
+      queue_name = if queue.respond_to?(:name)
+                     queue.name
+                   else
+                     queue
+                   end
+
+      @connection.send_frame(AMQ::Protocol::Basic::Consume.encode(@id, queue_name, consumer_tag, false, no_ack, exclusive, false, arguments))
+      Bunny::Timer.timeout(1, ClientTimeout) do
+        @last_basic_consume_ok = @continuations.pop
+      end
+
+      @consumer_mutex.synchronize do
+        c = Consumer.new(self, queue, consumer_tag, no_ack, exclusive, arguments)
+        c.on_delivery(&block) if block
+
+        @consumers[@last_basic_consume_ok.consumer_tag] = c
+      end
+
+      @last_basic_consume_ok
+    end
+
+    def basic_cancel(consumer_tag)
+      @connection.send_frame(AMQ::Protocol::Basic::Cancel.encode(@id, consumer_tag, false))
+
+      Bunny::Timer.timeout(1, ClientTimeout) do
+        @last_basic_cancel_ok = @continuations.pop
+      end
+
+      @last_basic_cancel_ok
+    end
+
+
+    # queue.*
+
+    def queue_declare(name, opts = {})
+      raise_if_no_longer_open!
+
+      @connection.send_frame(AMQ::Protocol::Queue::Declare.encode(@id, name, opts.fetch(:passive, false), opts.fetch(:durable, false), opts.fetch(:exclusive, false), opts.fetch(:auto_delete, false), false, opts[:arguments]))
+      @last_queue_declare_ok = @continuations.pop
+
+      raise_if_continuation_resulted_in_a_channel_error!
+
+      @last_queue_declare_ok
+    end
+
+    def queue_delete(name, opts = {})
+      raise_if_no_longer_open!
+
+      @connection.send_frame(AMQ::Protocol::Queue::Delete.encode(@id, name, opts[:if_unused], opts[:if_empty], false))
+      Bunny::Timer.timeout(1, ClientTimeout) do
+        @last_queue_delete_ok = @continuations.pop
+      end
+      raise_if_continuation_resulted_in_a_channel_error!
+
+      @last_queue_delete_ok
+    end
+
+    def queue_purge(name, opts = {})
+      raise_if_no_longer_open!
+
+      @connection.send_frame(AMQ::Protocol::Queue::Purge.encode(@id, name, false))
+
+      Bunny::Timer.timeout(1, ClientTimeout) do
+        @last_queue_purge_ok = @continuations.pop
+      end
+      raise_if_continuation_resulted_in_a_channel_error!
+
+      @last_queue_purge_ok
+    end
+
+    def queue_bind(name, exchange, opts = {})
+      raise_if_no_longer_open!
+
+      exchange_name = if exchange.respond_to?(:name)
+                        exchange.name
+                      else
+                        exchange
+                      end
+
+      @connection.send_frame(AMQ::Protocol::Queue::Bind.encode(@id, name, exchange_name, opts[:routing_key], false, opts[:arguments]))
+      Bunny::Timer.timeout(1, ClientTimeout) do
+        @last_queue_bind_ok = @continuations.pop
+      end
+
+      raise_if_continuation_resulted_in_a_channel_error!
+      @last_queue_bind_ok
+    end
+
+    def queue_unbind(name, exchange, opts = {})
+      raise_if_no_longer_open!
+
+      exchange_name = if exchange.respond_to?(:name)
+                        exchange.name
+                      else
+                        exchange
+                      end
+
+      @connection.send_frame(AMQ::Protocol::Queue::Unbind.encode(@id, name, exchange_name, opts[:routing_key], opts[:arguments]))
+      Bunny::Timer.timeout(1, ClientTimeout) do
+        @last_queue_unbind_ok = @continuations.pop
+      end
+
+      raise_if_continuation_resulted_in_a_channel_error!
+      @last_queue_unbind_ok
+    end
+
+
+    # exchange.*
+
+    def exchange_declare(name, type, opts = {})
+      raise_if_no_longer_open!
+
+      @connection.send_frame(AMQ::Protocol::Exchange::Declare.encode(@id, name, type.to_s, opts.fetch(:passive, false), opts.fetch(:durable, false), opts.fetch(:auto_delete, false), false, false, opts[:arguments]))
+      Bunny::Timer.timeout(1, ClientTimeout) do
+        @last_exchange_declare_ok = @continuations.pop
+      end
+
+      raise_if_continuation_resulted_in_a_channel_error!
+      @last_exchange_declare_ok
+    end
+
+    def exchange_delete(name, opts = {})
+      raise_if_no_longer_open!
+
+      @connection.send_frame(AMQ::Protocol::Exchange::Delete.encode(@id, name, opts[:if_unused], false))
+      Bunny::Timer.timeout(1, ClientTimeout) do
+        @last_exchange_delete_ok = @continuations.pop
+      end
+
+      raise_if_continuation_resulted_in_a_channel_error!
+      @last_exchange_delete_ok
+    end
+
+    def exchange_bind(source, destination, opts = {})
+      raise_if_no_longer_open!
+
+      source_name = if source.respond_to?(:name)
+                        source.name
+                      else
+                        source
+                      end
+
+      destination_name = if destination.respond_to?(:name)
+                        destination.name
+                      else
+                        destination
+                      end
+
+      @connection.send_frame(AMQ::Protocol::Exchange::Bind.encode(@id, destination_name, source_name, opts[:routing_key], false, opts[:arguments]))
+      Bunny::Timer.timeout(1, ClientTimeout) do
+        @last_exchange_bind_ok = @continuations.pop
+      end
+
+      raise_if_continuation_resulted_in_a_channel_error!
+      @last_exchange_bind_ok
+    end
+
+    def exchange_unbind(source, destination, opts = {})
+      raise_if_no_longer_open!
+
+      source_name = if source.respond_to?(:name)
+                        source.name
+                      else
+                        source
+                      end
+
+      destination_name = if destination.respond_to?(:name)
+                        destination.name
+                      else
+                        destination
+                      end
+
+      @connection.send_frame(AMQ::Protocol::Exchange::Unbind.encode(@id, destination_name, source_name, opts[:routing_key], false, opts[:arguments]))
+      Bunny::Timer.timeout(1, ClientTimeout) do
+        @last_exchange_unbind_ok = @continuations.pop
+      end
+
+      raise_if_continuation_resulted_in_a_channel_error!
+      @last_exchange_unbind_ok
+    end
+
+    # channel.*
+
+    def channel_flow(active)
+      raise_if_no_longer_open!
+
+      @connection.send_frame(AMQ::Protocol::Channel::Flow.encode(@id, active))
+      Bunny::Timer.timeout(1, ClientTimeout) do
+        @last_channel_flow_ok = @continuations.pop
+      end
+      raise_if_continuation_resulted_in_a_channel_error!
+
+      @last_channel_flow_ok
+    end
+
+    # tx.*
+
+    def tx_select
+      raise_if_no_longer_open!
+
+      @connection.send_frame(AMQ::Protocol::Tx::Select.encode(@id))
+      Bunny::Timer.timeout(1, ClientTimeout) do
+        @last_tx_select_ok = @continuations.pop
+      end
+      raise_if_continuation_resulted_in_a_channel_error!
+
+      @last_tx_select_ok
+    end
+
+    def tx_commit
+      raise_if_no_longer_open!
+
+      @connection.send_frame(AMQ::Protocol::Tx::Commit.encode(@id))
+      Bunny::Timer.timeout(1, ClientTimeout) do
+        @last_tx_commit_ok = @continuations.pop
+      end
+      raise_if_continuation_resulted_in_a_channel_error!
+
+      @last_tx_commit_ok
+    end
+
+    def tx_rollback
+      raise_if_no_longer_open!
+
+      @connection.send_frame(AMQ::Protocol::Tx::Rollback.encode(@id))
+      Bunny::Timer.timeout(1, ClientTimeout) do
+        @last_tx_rollback_ok = @continuations.pop
+      end
+      raise_if_continuation_resulted_in_a_channel_error!
+
+      @last_tx_rollback_ok
+    end
+
+    # confirm.*
+
+    def confirm_select
+      raise_if_no_longer_open!
+
+      @connection.send_frame(AMQ::Protocol::Confirm::Select.encode(@id, false))
+      Bunny::Timer.timeout(1, ClientTimeout) do
+        @last_confirm_select_ok = @continuations.pop
+      end
+      raise_if_continuation_resulted_in_a_channel_error!
+
+      @last_confirm_select_ok
+    end
+
+
+    #
+    # Implementation
+    #
+
+    def handle_method(method)
+      # puts "Channel#handle_frame on channel #{@id}: #{method.inspect}"
+      case method
+      when AMQ::Protocol::Queue::DeclareOk then
+        @continuations.push(method)
+      when AMQ::Protocol::Queue::DeleteOk then
+        @continuations.push(method)
+      when AMQ::Protocol::Queue::PurgeOk then
+        @continuations.push(method)
+      when AMQ::Protocol::Queue::BindOk then
+        @continuations.push(method)
+      when AMQ::Protocol::Queue::UnbindOk then
+        @continuations.push(method)
+      when AMQ::Protocol::Exchange::BindOk then
+        @continuations.push(method)
+      when AMQ::Protocol::Exchange::UnbindOk then
+        @continuations.push(method)
+      when AMQ::Protocol::Exchange::DeclareOk then
+        @continuations.push(method)
+      when AMQ::Protocol::Exchange::DeleteOk then
+        @continuations.push(method)
+      when AMQ::Protocol::Basic::QosOk then
+        @continuations.push(method)
+      when AMQ::Protocol::Basic::RecoverOk then
+        @continuations.push(method)
+      when AMQ::Protocol::Channel::FlowOk then
+        @continuations.push(method)
+      when AMQ::Protocol::Basic::ConsumeOk then
+        @continuations.push(method)
+      when AMQ::Protocol::Basic::CancelOk then
+        @continuations.push(method)
+        @consumers.delete(method.consumer_tag)
+      when AMQ::Protocol::Tx::SelectOk, AMQ::Protocol::Tx::CommitOk, AMQ::Protocol::Tx::RollbackOk then
+        @continuations.push(method)
+      when AMQ::Protocol::Tx::SelectOk then
+        @continuations.push(method)
+      when AMQ::Protocol::Confirm::SelectOk then
+        @continuations.push(method)
+      when AMQ::Protocol::Channel::Close then
+        # puts "Exception on channel #{@id}: #{method.reply_code} #{method.reply_text}"
+        closed!
+        @connection.send_frame(AMQ::Protocol::Channel::CloseOk.encode(@id))
+
+        @last_channel_error = instantiate_channel_level_exception(method)
+        @continuations.push(method)
+      when AMQ::Protocol::Channel::CloseOk then
+        @continuations.push(method)
+      else
+        raise "Do not know how to handle #{method.inspect} in Bunny::Channel#handle_method"
+      end
+    end
+
+    def handle_basic_get_ok(basic_get_ok, properties, content)
+      @continuations.push([basic_get_ok, properties, content])
+    end
+
+    def handle_basic_get_empty(basic_get_empty)
+      @continuations.push([nil, nil, nil])
+    end
+
+    def handle_frameset(basic_deliver, properties, content)
+      consumer = @consumers[basic_deliver.consumer_tag]
+      if consumer
+        @work_pool.submit do
+          consumer.call(MessageMetadata.new(basic_deliver, properties), content)
+        end
+      end
+    end
+
+    def handle_basic_return(basic_return, properties, content)
+      x = find_exchange(basic_return.exchange)
+
+      if x
+        x.handle_return(basic_return, properties, content)
+      else
+        # TODO: log a warning
+      end
+    end
+
+    # Starts consumer work pool. Lazily called by #basic_consume to avoid creating new threads
+    # that won't do any real work for channels that do not register consumers (e.g. only used for
+    # publishing). MK.
+    def maybe_start_consumer_work_pool!
+      @work_pool.start unless @work_pool.started?
+    end
+
+    def read_next_frame(options = {})
+      @connection.read_next_frame(options = {})
+    end
+
+    # Synchronizes given block using this channel's mutex.
+    # @api public
+    def synchronize(&block)
+      @mutex.synchronize(&block)
+    end
+
+    def register_queue(queue)
+      @queues[queue.name] = queue
+    end
+
+    def find_queue(name)
+      @queues[name]
+    end
+
+    def register_exchange(exchange)
+      @exchanges[exchange.name] = exchange
+    end
+
+    def find_exchange(name)
+      @exchanges[name]
+    end
+
+    protected
+
+    def closed!
+      @status = :closed
+      @work_pool.shutdown
+      @connection.release_channel_id(@id)
+    end
+
+    def instantiate_channel_level_exception(frame)
+      case frame
+      when AMQ::Protocol::Channel::Close then
+        klass = case frame.reply_code
+                when 403 then
+                  AccessRefused
+                when 404 then
+                  NotFound
+                when 405 then
+                  ResourceLocked
+                when 406 then
+                  PreconditionFailed
+                else
+                  ChannelLevelException
+                end
+
+        klass.new(frame.reply_text, self, frame)
+      end
+    end
+
+    def raise_if_continuation_resulted_in_a_channel_error!
+      raise @last_channel_error if @last_channel_error
+    end
+
+    def raise_if_no_longer_open!
+      raise ChannelAlreadyClosed.new("cannot use a channel that was already closed! Channel id: #{@id}", self) if closed?
+    end
+
+    # Unique string supposed to be used as a consumer tag.
+    #
+    # @return [String]  Unique string.
+    # @api plugin
+    def generate_consumer_tag(name = "bunny")
+      "#{name}-#{Time.now.to_i * 1000}-#{Kernel.rand(999_999_999_999)}"
+    end
   end
 end