bunny 0.9.0.pre2 → 0.9.0.pre3

data/.yardopts

@@ -1,9 +1,8 @@
 --no-private
 --protected
---markup="textile" lib/**/*.rb
---main README.textile
---asset examples:examples
+--markup="markdown" lib/**/*.rb
+--main README.md
 --hide-tag todo
 -
 LICENSE
-CHANGELOG
+ChangeLog.md

data/ChangeLog.md

@@ -1,3 +1,97 @@
+## Changes between Bunny 0.9.0.pre3 and 0.9.0.pre4
+
+No changes yet.
+
+
+## Changes between Bunny 0.9.0.pre2 and 0.9.0.pre3
+
+### Client Capabilities
+
+Bunny now correctly lists RabbitMQ extensions it currently supports in client capabilities:
+
+ * `basic.nack`
+ * exchange-to-exchange bindings
+ * consumer cancellation notifications
+ * publisher confirms
+
+### Publisher Confirms Support
+
+[Lightweight Publisher Confirms](http://www.rabbitmq.com/blog/2011/02/10/introducing-publisher-confirms/) is a
+RabbitMQ feature that lets publishers keep track of message routing without adding
+noticeable throughput degradation as it is the case with AMQP 0.9.1 transactions.
+
+Bunny `0.9.0.pre3` supports publisher confirms. Publisher confirms are enabled per channel,
+using the `Bunny::Channel#confirm_select` method. `Bunny::Channel#wait_for_confirms` is a method
+that blocks current thread until the client gets confirmations for all unconfirmed published
+messages:
+
+``` ruby
+ch = connection.create_channel
+ch.confirm_select
+
+ch.using_publisher_confirmations? # => true
+
+q  = ch.queue("", :exclusive => true)
+x  = ch.default_exchange
+
+5000.times do
+  x.publish("xyzzy", :routing_key => q.name)
+end
+
+ch.next_publish_seq_no.should == 5001
+ch.wait_for_confirms # waits until all 5000 published messages are acknowledged by RabbitMQ
+```
+
+
+### Consumers as Objects
+
+It is now possible to register a consumer as an object instead
+of a block. Consumers that are class instances support cancellation
+notifications (e.g. when a queue they're registered with is deleted).
+
+To support this, Bunny introduces two new methods: `Bunny::Channel#basic_consume_with`
+and `Bunny::Queue#subscribe_with`, that operate on consumer objects. Objects are
+supposed to respond to three selectors:
+
+ * `:handle_delivery` with 3 arguments
+ * `:handle_cancellation` with 1 argument
+ * `:consumer_tag=` with 1 argument
+
+An example:
+
+``` ruby
+class ExampleConsumer < Bunny::Consumer
+  def cancelled?
+    @cancelled
+  end
+
+  def handle_cancellation(_)
+    @cancelled = true
+  end
+end
+
+# "high-level" API
+ch1 = connection.create_channel
+q1  = ch1.queue("", :auto_delete => true)
+
+consumer = ExampleConsumer.new(ch1, q)
+q1.subscribe_with(consumer)
+
+# "low-level" API
+ch2 = connection.create_channel
+q1  = ch2.queue("", :auto_delete => true)
+
+consumer = ExampleConsumer.new(ch2, q)
+ch2.basic_consume_with.(consumer)
+```
+
+### RABBITMQ_URL ENV variable support
+
+If `RABBITMQ_URL` environment variable is set, Bunny will assume
+it contains a valid amqp URI string and will use it. This is convenient
+with some PaaS technologies such as Heroku.
+
+
 ## Changes between Bunny 0.9.0.pre1 and 0.9.0.pre2
 
 ### Change Bunny::Queue#pop default for :ack to false

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009 – 2011 Chris Duncan, Jakub Stastny aka botanicus,
+Copyright (c) 2009 – 2013 Chris Duncan, Jakub Stastny aka botanicus,
 Michael S. Klishin, Eric Lindvall, Stefan Kaes and contributors.
 
 Permission is hereby granted, free of charge, to any person obtaining

data/bunny.gemspec

@@ -10,6 +10,7 @@ Gem::Specification.new do |s|
   s.homepage = "http://github.com/ruby-amqp/bunny"
   s.summary = "Easy to use synchronous Ruby client for RabbitMQ"
   s.description = "Easy to use synchronous Ruby client for RabbitMQ"
+  s.license = "MIT"
 
   # Sorted alphabetically.
   s.authors = [

data/examples/connection/unknown_host.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require "bundler"
+Bundler.setup
+
+$:.unshift(File.expand_path("../../../lib", __FILE__))
+
+require 'bunny'
+
+b = Bunny.new("amqp://guest:guest@aksjhdkajshdkj.example82737.com")
+b.start
+

data/lib/bunny/channel.rb

@@ -1,5 +1,5 @@
 require "thread"
-require "amq/int_allocator"
+require "set"
 
 require "bunny/consumer_work_pool"
 
@@ -18,6 +18,7 @@ module Bunny
     #
 
     attr_accessor :id, :connection, :status, :work_pool
+    attr_reader :next_publish_seq_no
 
 
     def initialize(connection = nil, id = nil, work_pool = ConsumerWorkPool.new(1))
@@ -33,12 +34,16 @@ module Bunny
       @work_pool  = work_pool
 
       # synchronizes frameset delivery. MK.
-      @mutex          = Mutex.new
-      @consumer_mutex = Mutex.new
+      @publishing_mutex = Mutex.new
+      @consumer_mutex   = Mutex.new
 
-      @continuations = ::Queue.new
-    end
+      @unconfirmed_set_mutex = Mutex.new
+
+      @continuations          = ::Queue.new
+      @confirms_continuations = ::Queue.new
 
+      @next_publish_seq_no = 0
+    end
 
     def open
       @connection.open_channel(self)
@@ -146,6 +151,9 @@ module Bunny
       @default_error_handler = block
     end
 
+    def using_publisher_confirmations?
+      @next_publish_seq_no > 0
+    end
 
     #
     # Lower-level API, exposes protocol operations as they are defined in the protocol,
@@ -165,7 +173,20 @@ module Bunny
 
       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, @connection.frame_max), self)
+
+      if @next_publish_seq_no > 0
+        @unconfirmed_set.add(@next_publish_seq_no)
+        @next_publish_seq_no += 1
+      end
+
+      @connection.send_frameset(AMQ::Protocol::Basic::Publish.encode(@id,
+                                                                     payload,
+                                                                     meta,
+                                                                     exchange_name,
+                                                                     routing_key,
+                                                                     meta[:mandatory],
+                                                                     false,
+                                                                     @connection.frame_max), self)
 
       self
     end
@@ -222,7 +243,10 @@ module Bunny
 
     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))
+      @connection.send_frame(AMQ::Protocol::Basic::Nack.encode(@id,
+                                                               delivery_tag,
+                                                               requeue,
+                                                               multiple))
 
       nil
     end
@@ -237,21 +261,54 @@ module Bunny
                      queue
                    end
 
-      @connection.send_frame(AMQ::Protocol::Basic::Consume.encode(@id, queue_name, consumer_tag, false, no_ack, exclusive, false, arguments))
+      @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)
+        # make sure to use consumer tag from basic.consume-ok in case it was
+        # server-generated
+        c = Consumer.new(self, queue, @last_basic_consume_ok.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_consume_with(consumer)
+      raise_if_no_longer_open!
+      maybe_start_consumer_work_pool!
+
+      @connection.send_frame(AMQ::Protocol::Basic::Consume.encode(@id,
+                                                                  consumer.queue_name,
+                                                                  consumer.consumer_tag,
+                                                                  false,
+                                                                  consumer.no_ack,
+                                                                  consumer.exclusive,
+                                                                  false,
+                                                                  consumer.arguments))
+      Bunny::Timer.timeout(1, ClientTimeout) do
+        @last_basic_consume_ok = @continuations.pop
+      end
+
+      @consumer_mutex.synchronize do
+        # update the tag in case it was server-generated
+        consumer.consumer_tag = @last_basic_consume_ok.consumer_tag
+        @consumers[@last_basic_consume_ok.consumer_tag] = consumer
+      end
+
+      @last_basic_consume_ok
+    end
+
     def basic_cancel(consumer_tag)
       @connection.send_frame(AMQ::Protocol::Basic::Cancel.encode(@id, consumer_tag, false))
 
@@ -268,7 +325,14 @@ module Bunny
     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]))
+      @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!
@@ -279,7 +343,11 @@ module Bunny
     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))
+      @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
@@ -310,7 +378,12 @@ module Bunny
                         exchange
                       end
 
-      @connection.send_frame(AMQ::Protocol::Queue::Bind.encode(@id, name, exchange_name, opts[:routing_key], false, opts[:arguments]))
+      @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
@@ -328,7 +401,11 @@ module Bunny
                         exchange
                       end
 
-      @connection.send_frame(AMQ::Protocol::Queue::Unbind.encode(@id, name, exchange_name, opts[:routing_key], opts[:arguments]))
+      @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
@@ -343,7 +420,15 @@ module Bunny
     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]))
+      @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
@@ -355,7 +440,10 @@ module Bunny
     def exchange_delete(name, opts = {})
       raise_if_no_longer_open!
 
-      @connection.send_frame(AMQ::Protocol::Exchange::Delete.encode(@id, name, opts[:if_unused], false))
+      @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
@@ -368,18 +456,23 @@ module Bunny
       raise_if_no_longer_open!
 
       source_name = if source.respond_to?(:name)
-                        source.name
-                      else
-                        source
-                      end
+                      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]))
+                           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
@@ -392,18 +485,23 @@ module Bunny
       raise_if_no_longer_open!
 
       source_name = if source.respond_to?(:name)
-                        source.name
-                      else
-                        source
-                      end
+                      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]))
+                           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
@@ -469,15 +567,26 @@ module Bunny
     def confirm_select
       raise_if_no_longer_open!
 
+      if @next_publish_seq_no == 0
+        @confirms_continuations = []
+        @unconfirmed_set        = Set.new
+        @next_publish_seq_no    = 1
+      end
+
       @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
 
+    def wait_for_confirms
+      @only_acks_received = true
+      @confirms_continuations.pop
+
+      @only_acks_received
+    end
 
     #
     # Implementation
@@ -512,6 +621,12 @@ module Bunny
         @continuations.push(method)
       when AMQ::Protocol::Basic::ConsumeOk then
         @continuations.push(method)
+      when AMQ::Protocol::Basic::Cancel then
+        if consumer = @consumers[method.consumer_tag]
+          consumer.handle_cancellation(method)
+        end
+
+        @consumers.delete(method.consumer_tag)
       when AMQ::Protocol::Basic::CancelOk then
         @continuations.push(method)
         @consumers.delete(method.consumer_tag)
@@ -521,6 +636,12 @@ module Bunny
         @continuations.push(method)
       when AMQ::Protocol::Confirm::SelectOk then
         @continuations.push(method)
+      when AMQ::Protocol::Basic::Ack then
+        # TODO: implement confirm listeners
+        handle_ack_or_nack(method.delivery_tag, method.multiple, false)
+      when AMQ::Protocol::Basic::Nack then
+        # TODO: implement confirm listeners
+        handle_ack_or_nack(method.delivery_tag, method.multiple, true)
       when AMQ::Protocol::Channel::Close then
         # puts "Exception on channel #{@id}: #{method.reply_code} #{method.reply_text}"
         closed!
@@ -562,6 +683,20 @@ module Bunny
       end
     end
 
+    def handle_ack_or_nack(delivery_tag, multiple, nack)
+      if multiple
+        @unconfirmed_set.delete_if { |i| i < delivery_tag }
+      else
+        @unconfirmed_set.delete(delivery_tag)
+      end
+
+      @unconfirmed_set_mutex.synchronize do
+        @only_acks_received = (@only_acks_received && !nack)
+
+        @confirms_continuations.push(true) if @unconfirmed_set.empty?
+      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.
@@ -576,7 +711,7 @@ module Bunny
     # Synchronizes given block using this channel's mutex.
     # @api public
     def synchronize(&block)
-      @mutex.synchronize(&block)
+      @publishing_mutex.synchronize(&block)
     end
 
     def register_queue(queue)

data/lib/bunny/channel_id_allocator.rb

@@ -1,4 +1,5 @@
 require "thread"
+require "amq/int_allocator"
 
 module Bunny
   class ChannelIdAllocator
@@ -7,8 +8,7 @@ module Bunny
     # API
     #
 
-    def initialize
-      max_channel     =  (1 << 16) - 1
+    def initialize(max_channel = ((1 << 16) - 1))
       @int_allocator ||= AMQ::IntAllocator.new(1, max_channel)
 
       @channel_id_mutex ||= Mutex.new
@@ -43,7 +43,7 @@ module Bunny
     def allocated_channel_id?(i)
       @channel_id_mutex.synchronize do
         @int_allocator.allocated?(i)
-      end      
+      end
     end
 
     # Resets channel allocator. This method is thread safe.

data/lib/bunny/consumer.rb

@@ -5,16 +5,19 @@ module Bunny
     # API
     #
 
-    attr_reader :channel
-    attr_reader :queue
-    attr_reader :consumer_tag
-    attr_reader :arguments
+    attr_reader   :channel
+    attr_reader   :queue
+    attr_accessor :consumer_tag
+    attr_reader   :arguments
+    attr_reader   :no_ack
+    attr_reader   :exclusive
 
 
-    def initialize(channel, queue, consumer_tag, no_ack = false, exclusive = false, arguments = {})
+
+    def initialize(channel, queue, consumer_tag = "", no_ack = false, exclusive = false, arguments = {})
       @channel       = channel || raise(ArgumentError, "channel is nil")
-      @queue         = queue || raise(ArgumentError, "queue is nil")
-      @consumer_tag  = consumer_tag || raise(ArgumentError, "consumer tag is nil")
+      @queue         = queue   || raise(ArgumentError, "queue is nil")
+      @consumer_tag  = consumer_tag
       @exclusive     = exclusive
       @arguments     = arguments
       @no_ack        = no_ack
@@ -31,11 +34,15 @@ module Bunny
     end
     alias handle_delivery call
 
-    def handle_cancel(&block)
+    def on_cancellation(&block)
       @on_cancellation = block
       self
     end
 
+    def handle_cancellation(basic_cancel)
+      @on_cancellation.call(basic_cancel) if @on_cancellation
+    end
+
     def queue_name
       if @queue.respond_to?(:name)
         @queue.name

data/lib/bunny/queue.rb

@@ -74,16 +74,38 @@ module Bunny
       self
     end
 
-    def subscribe(opts = {:consumer_tag => "", :ack => false, :exclusive => false, :block => false}, &block)
-      @channel.basic_consume(@name, opts.fetch(:consumer_tag, ""), !opts[:ack], opts[:exclusive], opts[:arguments], &block)
-
-      if options[:block]
+    def subscribe(opts = {
+                    :consumer_tag    => "",
+                    :ack             => false,
+                    :exclusive       => false,
+                    :block           => false,
+                    :on_cancellation => nil
+                  }, &block)
+
+      ctag       = opts.fetch(:consumer_tag, "")
+      consumer   = Consumer.new(@channel,
+                                @name,
+                                ctag,
+                                opts[:no_ack],
+                                opts[:exclusive],
+                                opts[:arguments])
+      consumer.on_delivery(&block)
+      consumer.on_cancellation(&opts[:on_cancellation]) if opts[:on_cancellation]
+
+      @channel.basic_consume_with(consumer)
+      if opts[:block]
         # joins current thread with the consumers pool, will block
         # the current thread for as long as the consumer pool is active
         @channel.work_pool.join
       end
     end
 
+    def subscribe_with(consumer, opts = {:block => false})
+      @channel.basic_consume_with(consumer)
+
+      @channel.work_pool.join if opts[:block]
+    end
+
     def pop(opts = {:ack => false}, &block)
       delivery_info, properties, content = @channel.basic_get(@name, opts)
 

data/lib/bunny/session.rb

@@ -30,11 +30,16 @@ module Bunny
 
     DEFAULT_CLIENT_PROPERTIES = {
       # once we support AMQP 0.9.1 extensions, this needs to be updated. MK.
-      :capabilities => {},
+      :capabilities => {
+        # :publisher_confirms         => true,
+        :consumer_cancel_notify     => true,
+        :exchange_exchange_bindings => true,
+        :"basic.nack"               => true
+      },
       :product      => "Bunny",
       :platform     => ::RUBY_DESCRIPTION,
       :version      => Bunny::VERSION,
-      :information  => "http://github.com/ruby-amqp/bunny"
+      :information  => "http://github.com/ruby-amqp/bunny",
     }
 
     DEFAULT_LOCALE = "en_GB"
@@ -50,7 +55,9 @@ module Bunny
     attr_reader :channel_id_allocator
 
     def initialize(connection_string_or_opts = Hash.new, optz = Hash.new)
-      opts = case connection_string_or_opts
+      opts = case (ENV["RABBITMQ_URL"] || connection_string_or_opts)
+             when nil then
+               Hash.new
              when String then
                AMQ::Settings.parse_amqp_url(connection_string_or_opts)
              when Hash then
@@ -66,22 +73,18 @@ module Bunny
       @logfile         = opts[:logfile]
       @logging         = opts[:logging] || false
 
-      @status          = :not_connected
-      @frame_max       = opts[:frame_max] || DEFAULT_FRAME_MAX
-      # currently ignored
-      @channel_max     = opts[:channel_max] || 0
-      @heartbeat       = self.heartbeat_from(opts)
+      @status             = :not_connected
+
+      # these are negotiated with the broker during the connection tuning phase
+      @client_frame_max   = opts.fetch(:frame_max, DEFAULT_FRAME_MAX)
+      @client_channel_max = opts.fetch(:channel_max, 65536)
+      @client_heartbeat   = self.heartbeat_from(opts)
 
       @client_properties  = opts[:properties] || DEFAULT_CLIENT_PROPERTIES
       @mechanism          = "PLAIN"
       @locale             = @opts.fetch(:locale, DEFAULT_LOCALE)
-
-      @channel_id_allocator = ChannelIdAllocator.new
-      @channel_mutex        = Mutex.new
-      @channels             = Hash.new
-
-      # Create channel 0
-      @channel0           = Bunny::Channel.new(self, 0)
+      @channel_mutex      = Mutex.new
+      @channels           = Hash.new
 
       @continuations      = ::Queue.new
     end
@@ -101,10 +104,6 @@ module Bunny
     end
     alias ssl? uses_ssl?
 
-    def channel0
-      @channel0
-    end
-
     def start
       @status = :connecting
 
@@ -442,9 +441,13 @@ module Bunny
         raise Bunny::PossibleAuthenticationFailureError.new(self.user, self.vhost, self.password.size)
       end
 
-      connection_tune = frame.decode_payload
-      @frame_max      = connection_tune.frame_max.freeze
-      @heartbeat      ||= connection_tune.heartbeat
+      connection_tune       = frame.decode_payload
+
+      @frame_max            = negotiate_value(@client_frame_max, connection_tune.frame_max)
+      @channel_max          = negotiate_value(@client_channel_max, connection_tune.channel_max)
+      @heartbeat            = negotiate_value(@client_heartbeat, connection_tune.heartbeat)
+
+      @channel_id_allocator = ChannelIdAllocator.new(@channel_max)
 
       @transport.send_frame(AMQ::Protocol::Connection::TuneOk.encode(@channel_max, @frame_max, @heartbeat))
       @transport.send_frame(AMQ::Protocol::Connection::Open.encode(self.vhost))
@@ -470,6 +473,14 @@ module Bunny
       raise "could not open connection: server did not respond with connection.open-ok" unless connection_open_ok.is_a?(AMQ::Protocol::Connection::OpenOk)
     end
 
+    def negotiate_value(client_value, server_value)
+      if client_value == 0 || server_value == 0
+        [client_value, server_value].max
+      else
+        [client_value, server_value].min
+      end
+    end
+
     def initialize_heartbeat_sender
       @heartbeat_sender = HeartbeatSender.new(@transport)
       @heartbeat_sender.start(@heartbeat)

data/lib/bunny/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module Bunny
-  VERSION = "0.9.0.pre2"
+  VERSION = "0.9.0.pre3"
 end

data/spec/higher_level_api/integration/connection_spec.rb

@@ -303,9 +303,15 @@ describe Bunny::Session do
       props["product"].should_not be_nil
       props["platform"].should_not be_nil
       props["version"].should_not be_nil
+      props["capabilities"].should_not be_nil
     end
 
     it "uses provided heartbeat interval" do
+      subject.start
+      subject.should be_connected
+
+      # this is negotiated with RabbitMQ, so we need to
+      # establish the connection first
       subject.heartbeat.should == interval
     end
   end

data/spec/higher_level_api/integration/consumer_cancellation_notification_spec.rb

@@ -0,0 +1,83 @@
+require "spec_helper"
+
+describe Bunny::Channel do
+  let(:connection) do
+    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
+    c.start
+    c
+  end
+
+  after :all do
+    connection.close if connection.open?
+  end
+
+  context "with implicit consumer construction" do
+    let(:queue_name) { "basic.consume#{rand}" }
+
+    it "supports consumer cancellation notifications" do
+      cancelled = false
+
+      ch = connection.create_channel
+      t  = Thread.new do
+        ch2 = connection.create_channel
+        q   = ch2.queue(queue_name, :auto_delete => true)
+
+        q.subscribe(:on_cancellation => Proc.new { cancelled = true })
+      end
+      t.abort_on_exception = true
+
+      sleep 0.5
+      x = ch.default_exchange
+      x.publish("abc", :routing_key => queue_name)
+
+      sleep 0.5
+      ch.queue(queue_name, :auto_delete => true).delete
+
+      sleep 0.5
+      cancelled.should be_true
+
+      ch.close
+    end
+  end
+
+
+  context "with explicit consumer construction" do
+    class ExampleConsumer < Bunny::Consumer
+      def cancelled?
+        @cancelled
+      end
+
+      def handle_cancellation(_)
+        @cancelled = true
+      end
+    end
+
+    let(:queue_name) { "basic.consume#{rand}" }
+
+    it "supports consumer cancellation notifications" do
+      consumer = nil
+
+      ch = connection.create_channel
+      t  = Thread.new do
+        ch2 = connection.create_channel
+        q   = ch2.queue(queue_name, :auto_delete => true)
+
+        consumer = ExampleConsumer.new(ch2, q)
+        q.subscribe_with(consumer)
+      end
+      t.abort_on_exception = true
+
+      sleep 0.5
+      x = ch.default_exchange
+      x.publish("abc", :routing_key => queue_name)
+
+      sleep 0.5
+      ch.queue(queue_name, :auto_delete => true).delete
+
+      sleep 0.5
+      consumer.should be_cancelled
+
+      ch.close
+    end
+  end
+end

data/spec/higher_level_api/integration/publisher_confirms_spec.rb

@@ -0,0 +1,39 @@
+require "spec_helper"
+
+describe Bunny::Channel do
+  let(:connection) do
+    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
+    c.start
+    c
+  end
+
+  after :all do
+    connection.close if connection.open?
+  end
+
+
+  context "when publishing with confirms enabled" do
+    it "increments delivery index" do
+      ch = connection.create_channel
+      ch.should_not be_using_publisher_confirmations
+
+      ch.confirm_select
+      ch.should be_using_publisher_confirmations
+
+      q  = ch.queue("", :exclusive => true)
+      x  = ch.default_exchange
+
+      5000.times do
+        x.publish("xyzzy", :routing_key => q.name)
+      end
+
+      ch.next_publish_seq_no.should == 5001
+      ch.wait_for_confirms
+
+      q.message_count.should == 5000
+      q.purge
+
+      ch.close
+    end
+  end
+end

metadata

@@ -2,7 +2,7 @@
 name: bunny
 version: !ruby/object:Gem::Version 
   prerelease: 6
-  version: 0.9.0.pre2
+  version: 0.9.0.pre3
 platform: ruby
 authors: 
   - Chris Duncan
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-11-30 00:00:00 Z
+date: 2012-12-01 00:00:00 Z
 dependencies: 
   - !ruby/object:Gem::Dependency 
     name: amq-protocol
@@ -52,6 +52,7 @@ files:
   - bin/ci/before_build.sh
   - bunny.gemspec
   - examples/connection/heartbeat.rb
+  - examples/connection/unknown_host.rb
   - examples/guides/getting_started/blabbr.rb
   - examples/guides/getting_started/hello_world.rb
   - examples/guides/getting_started/weathr.rb
@@ -93,10 +94,12 @@ files:
   - spec/higher_level_api/integration/channel_open_stress_spec.rb
   - spec/higher_level_api/integration/confirm_select_spec.rb
   - spec/higher_level_api/integration/connection_spec.rb
+  - spec/higher_level_api/integration/consumer_cancellation_notification_spec.rb
   - spec/higher_level_api/integration/exchange_bind_spec.rb
   - spec/higher_level_api/integration/exchange_declare_spec.rb
   - spec/higher_level_api/integration/exchange_delete_spec.rb
   - spec/higher_level_api/integration/exchange_unbind_spec.rb
+  - spec/higher_level_api/integration/publisher_confirms_spec.rb
   - spec/higher_level_api/integration/queue_bind_spec.rb
   - spec/higher_level_api/integration/queue_declare_spec.rb
   - spec/higher_level_api/integration/queue_delete_spec.rb
@@ -110,8 +113,8 @@ files:
   - spec/unit/bunny_spec.rb
   - spec/unit/concurrent/condition_spec.rb
 homepage: http://github.com/ruby-amqp/bunny
-licenses: []
-
+licenses: 
+  - MIT
 post_install_message: 
 rdoc_options: []
 
@@ -153,10 +156,12 @@ test_files:
   - spec/higher_level_api/integration/channel_open_stress_spec.rb
   - spec/higher_level_api/integration/confirm_select_spec.rb
   - spec/higher_level_api/integration/connection_spec.rb
+  - spec/higher_level_api/integration/consumer_cancellation_notification_spec.rb
   - spec/higher_level_api/integration/exchange_bind_spec.rb
   - spec/higher_level_api/integration/exchange_declare_spec.rb
   - spec/higher_level_api/integration/exchange_delete_spec.rb
   - spec/higher_level_api/integration/exchange_unbind_spec.rb
+  - spec/higher_level_api/integration/publisher_confirms_spec.rb
   - spec/higher_level_api/integration/queue_bind_spec.rb
   - spec/higher_level_api/integration/queue_declare_spec.rb
   - spec/higher_level_api/integration/queue_delete_spec.rb