bunny 0.9.0.pre8 → 0.9.0.pre9

data/ChangeLog.md

@@ -1,5 +1,36 @@
+## Changes between Bunny 0.9.0.pre8 and 0.9.0.pre9
+
+### More Reliable Heartbeat Sender
+
+Heartbeat sender no longer slips into an infinite loop if it encounters an exception.
+Instead, it will just stop (and presumably re-started when the network error recovery
+kicks in or the app reconnects manually).
+
+
+### Network Recovery After Delay
+
+Network reconnection now kicks in after a delay to avoid aggressive
+reconnections in situations when we don't want to endlessly reconnect
+(e.g. when the connection was closed via the Management UI).
+
+The `:network_recovery_interval` option passed to `Bunny::Session#initialize` and `Bunny.new`
+controls the interval. Default is 5 seconds.
+
+
+### Default Heartbeat Value Is Now Server-Defined
+
+Bunny will now use heartbeat value provided by RabbitMQ by default.
+
+
+
 ## Changes between Bunny 0.9.0.pre7 and 0.9.0.pre8
 
+### Stability Improvements
+
+Several stability improvements in the network
+layer, connection error handling, and concurrency hazards.
+
+
 ### Automatic Connection Recovery Can Be Disabled
 
 Automatic connection recovery now can be disabled by passing

data/README.md

@@ -36,7 +36,7 @@ gem install bunny --pre
 To use Bunny 0.9.x in a project managed with Bundler:
 
 ``` ruby
-gem "bunny", ">= 0.9.0.pre7" # optionally: , :git => "git://github.com/ruby-amqp/bunny.git", :branch => "master"
+gem "bunny", ">= 0.9.0.pre8" # optionally: , :git => "git://github.com/ruby-amqp/bunny.git", :branch => "master"
 ```
 
 

data/examples/guides/extensions/dead_letter_exchange.rb

@@ -23,7 +23,7 @@ sleep 0.2
 delivery_info, _, _ = q.pop(:ack => true)
 puts "#{dlq.message_count} messages dead lettered so far"
 puts "Rejecting a message"
-ch.nack(delivery_info.delivery_tag, false)
+ch.nack(delivery_info.delivery_tag)
 sleep 0.2
 puts "#{dlq.message_count} messages dead lettered so far"
 

data/lib/bunny/channel.rb

@@ -447,13 +447,13 @@ module Bunny
     # supports rejecting multiple messages at once, and is usually preferred.
     #
     # @param [Integer] delivery_tag Delivery tag to reject
-    # @param [Boolean] requeue      Should this message be requeued instead of dropping it?
     # @param [Boolean] multiple (false) Should all unacknowledged messages up to this be rejected as well?
+    # @param [Boolean] requeue  (false) Should this message be requeued instead of dropping it?
     # @see Bunny::Channel#ack
     # @see http://rubybunny.info/articles/queues.html Queues and Consumers guide
     # @api public
-    def nack(delivery_tag, requeue, multiple = false)
-      basic_nack(delivery_tag, requeue, multiple)
+    def nack(delivery_tag, multiple = false, requeue = false)
+      basic_nack(delivery_tag, multiple, requeue)
     end
 
     # @endgroup
@@ -713,7 +713,7 @@ module Bunny
     #   ch    = conn.create_channel
     #   q.subscribe do |delivery_info, properties, payload|
     #     # requeue the message
-    #     ch.basic_nack(delivery_info.delivery_tag, true)
+    #     ch.basic_nack(delivery_info.delivery_tag, false, true)
     #   end
     #
     # @example Reject a message
@@ -723,7 +723,7 @@ module Bunny
     #   ch    = conn.create_channel
     #   q.subscribe do |delivery_info, properties, payload|
     #     # requeue the message
-    #     ch.basic_nack(delivery_info.delivery_tag, false)
+    #     ch.basic_nack(delivery_info.delivery_tag)
     #   end
     #
     # @example Requeue a message fetched via basic.get
@@ -733,7 +733,7 @@ module Bunny
     #   ch    = conn.create_channel
     #   # we assume the queue exists and has messages
     #   delivery_info, properties, payload = ch.basic_get("bunny.examples.queue3", :ack => true)
-    #   ch.basic_nack(delivery_info.delivery_tag, true)
+    #   ch.basic_nack(delivery_info.delivery_tag, false, true)
     #
     #
     # @example Requeue multiple messages fetched via basic.get
@@ -751,12 +751,12 @@ module Bunny
     # @see http://rubybunny.info/articles/queues.html Queues and Consumers guide
     # @see http://rubybunny.info/articles/extensions.html RabbitMQ Extensions guide
     # @api public
-    def basic_nack(delivery_tag, requeue, multiple = false)
+    def basic_nack(delivery_tag, multiple = false, requeue = false)
       raise_if_no_longer_open!
       @connection.send_frame(AMQ::Protocol::Basic::Nack.encode(@id,
                                                                delivery_tag,
-                                                               requeue,
-                                                               multiple))
+                                                               multiple,
+                                                               requeue))
 
       nil
     end

data/lib/bunny/concurrent/continuation_queue.rb

@@ -0,0 +1,28 @@
+require "thread"
+
+module Bunny
+  module Concurrent
+    class ContinuationQueue
+      def initialize(*args, &block)
+        @q = ::Queue.new(*args)
+      end
+
+      def push(*args)
+        @q.push(*args)
+      end
+      alias << push
+
+      def pop
+        @q.pop
+      end
+
+      def clear
+        @q.clear
+      end
+
+      def method_missing(selector, *args, &block)
+        @q.__send__(selector, *args, &block)
+      end
+    end
+  end
+end

data/lib/bunny/concurrent/linked_continuation_queue.rb

@@ -0,0 +1,56 @@
+if !defined?(JRUBY_VERSION)
+  raise "Bunny::Concurrent::LinkedContinuationQueue can only be used on JRuby!"
+end
+
+require "java"
+
+java_import java.util.concurrent.LinkedBlockingQueue
+java_import java.util.concurrent.TimeUnit
+
+module Bunny
+  module Concurrent
+    # On JRuby, we'd rather use reliable and heavily battle tested j.u.c.
+    # primitives with well described semantics than informally specified, clumsy
+    # and limited Ruby standard library parts.
+    #
+    # This is an implementation of the continuation queue on top of the linked blocking
+    # queue in j.u.c.
+    #
+    # Compared to the Ruby standard library Queue, there is one limitation: you cannot
+    # push a nil on the queue, it will fail with a null pointer exception.
+    class LinkedContinuationQueue
+      def initialize(*args, &block)
+        @q = LinkedBlockingQueue.new
+      end
+
+      def push(el, timeout_in_ms = nil)
+        if timeout_in_ms
+          @q.offer(el, timeout_in_ms, TimeUnit.MILLISECONDS)
+        else
+          @q.offer(el)
+        end
+      end
+      alias << push
+
+      def pop
+        @q.take
+      end
+
+      def poll(timeout_in_ms = nil)
+        if timeout_in_ms
+          @q.poll(timeout_in_ms, TimeUnit.MILLISECONDS)
+        else
+          @q.poll
+        end
+      end
+
+      def clear
+        @q.clear
+      end
+
+      def method_missing(selector, *args, &block)
+        @q.__send__(selector, *args, &block)
+      end
+    end
+  end
+end

data/lib/bunny/exceptions.rb

@@ -157,4 +157,8 @@ module Bunny
       @other = other
     end
   end
+
+  class ConnectionForced < ConnectionLevelException
+  end
+
 end

data/lib/bunny/heartbeat_sender.rb

@@ -46,9 +46,11 @@ module Bunny
           sleep @interval
         end
       rescue IOError => ioe
-        # ignored
+        puts ioe.message
+        stop
       rescue Exception => e
         puts e.message
+        stop
       end
     end
 

data/lib/bunny/session.rb

@@ -9,7 +9,11 @@ require "bunny/authentication/credentials_encoder"
 require "bunny/authentication/plain_mechanism_encoder"
 require "bunny/authentication/external_mechanism_encoder"
 
-require "bunny/concurrent/condition"
+if defined?(JRUBY_VERSION)
+  require "bunny/concurrent/linked_continuation_queue"
+else
+  require "bunny/concurrent/continuation_queue"
+end
 
 require "amq/protocol/client"
 require "amq/settings"
@@ -28,7 +32,7 @@ module Bunny
     # Default password used for connection
     DEFAULT_PASSWORD  = "guest"
     # Default heartbeat interval, the same value as RabbitMQ 3.0 uses.
-    DEFAULT_HEARTBEAT = 600
+    DEFAULT_HEARTBEAT = :server
     # @private
     DEFAULT_FRAME_MAX = 131072
 
@@ -52,6 +56,8 @@ module Bunny
 
     DEFAULT_LOCALE = "en_GB"
 
+    DEFAULT_NETWORK_RECOVERY_INTERVAL = 5.0
+
 
     #
     # API
@@ -107,6 +113,7 @@ module Bunny
                                else
                                  opts[:automatically_recover] || opts[:automatic_recovery]
                                end
+      @network_recovery_interval = opts.fetch(:network_recovery_interval, DEFAULT_NETWORK_RECOVERY_INTERVAL)
 
       @status             = :not_connected
 
@@ -124,7 +131,7 @@ module Bunny
       @network_mutex       = Mutex.new
       @channels            = Hash.new
 
-      @continuations       = ::Queue.new
+      self.reset_continuations
     end
 
     # @return [String] RabbitMQ hostname (or IP address) used
@@ -136,6 +143,9 @@ module Bunny
     # @return [String] Virtual host used
     def virtual_host; self.vhost; end
 
+    # @return [Integer] Heartbeat interval used
+    def heartbeat_interval; self.heartbeat; end
+
     # @return [Boolean] true if this connection uses TLS (SSL)
     def uses_tls?
       @transport.uses_tls?
@@ -148,11 +158,18 @@ module Bunny
     end
     alias ssl? uses_ssl?
 
+    # @return [Boolean] true if this connection uses a separate thread for I/O activity
+    def threaded?
+      @threaded
+    end
+
     # Starts connection process
     # @api public
     def start
-      @continuations = ::Queue.new
+      return self if connected?
+
       @status        = :connecting
+      self.reset_continuations
 
       self.initialize_transport
 
@@ -163,6 +180,8 @@ module Bunny
       self.start_main_loop if @threaded
 
       @default_channel = self.create_channel
+
+      self
     end
 
     def read_write_timeout
@@ -197,6 +216,10 @@ module Bunny
     end
     alias stop close
 
+    # Creates a temporary channel, yields it to the block given to this
+    # method and closes it.
+    #
+    # @return [Bunny::Session] self
     def with_channel(n = nil)
       ch = create_channel(n)
       yield ch
@@ -205,7 +228,7 @@ module Bunny
       self
     end
 
-
+    # @return [Boolean] true if this connection is still not fully open
     def connecting?
       status == :connecting
     end
@@ -215,10 +238,11 @@ module Bunny
     end
 
     def open?
-      (status == :open || status == :connected) && @transport.open?
+      (status == :open || status == :connected || status == :connecting) && @transport.open?
     end
     alias connected? open?
 
+    # @return [Boolean] true if this connection has automatic recovery from network failure enabled
     def automatically_recover?
       @automatically_recover
     end
@@ -318,6 +342,8 @@ module Bunny
       when AMQ::Protocol::Connection::Close then
         @last_connection_error = instantiate_connection_level_exception(method)
         @continuations.push(method)
+
+        raise @last_connection_error
       when AMQ::Protocol::Connection::CloseOk then
         @last_connection_close_ok = method
         begin
@@ -332,7 +358,7 @@ module Bunny
           puts e.message
           puts e.backtrace
         ensure
-          @continuations.push(nil)
+          @continuations.push(:__unblock__)
         end
       when AMQ::Protocol::Channel::Close then
         begin
@@ -376,6 +402,8 @@ module Bunny
     def handle_network_failure(exception)
       raise NetworkErrorWrapper.new(exception) unless @threaded
 
+      @status = :disconnected
+
       if !recovering_from_network_failure?
         @recovering_from_network_failure = true
         if recoverable_network_failure?(exception)
@@ -406,6 +434,7 @@ module Bunny
     # @private
     def recover_from_network_failure
       begin
+        sleep @network_recovery_interval
         # puts "About to start recovery..."
         start
 
@@ -416,7 +445,7 @@ module Bunny
         end
       rescue TCPConnectionFailed, AMQ::Protocol::EmptyResponseError => e
         # puts "TCP connection failed, reconnecting in 5 seconds"
-        sleep 5.0
+        sleep @network_recovery_interval
         retry if recoverable_network_failure?(e)
       end
     end
@@ -443,11 +472,13 @@ module Bunny
       case frame
       when AMQ::Protocol::Connection::Close then
         klass = case frame.reply_code
+                when 320 then
+                  ConnectionForced
                 when 503 then
                   InvalidCommand
                 when 504 then
                   ChannelError
-                when 504 then
+                when 505 then
                   UnexpectedFrame
                 else
                   raise "Unknown reply code: #{frame.reply_code}, text: #{frame.reply_text}"
@@ -530,6 +561,11 @@ module Bunny
       @event_loop ||= MainLoop.new(@transport, self, Thread.current)
     end
 
+    # @private
+    def maybe_shutdown_main_loop
+      @event_loop.stop if @event_loop
+    end
+
     # @private
     def signal_activity!
       @heartbeat_sender.signal_activity! if @heartbeat_sender
@@ -633,7 +669,7 @@ module Bunny
       @frame_max            = negotiate_value(@client_frame_max, connection_tune.frame_max)
       @channel_max          = negotiate_value(@client_channel_max, connection_tune.channel_max)
       # this allows for disabled heartbeats. MK.
-      @heartbeat            = if 0 == @client_heartbeat || @client_heartbeat.nil?
+      @heartbeat            = if heartbeat_disabled?(@client_heartbeat)
                                 0
                               else
                                 negotiate_value(@client_heartbeat, connection_tune.heartbeat)
@@ -665,8 +701,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 heartbeat_disabled?(val)
+      0 == val || val.nil?
+    end
+
     # @api private
     def negotiate_value(client_value, server_value)
+      return server_value if client_value == :server
+
       if client_value == 0 || server_value == 0
         [client_value, server_value].max
       else
@@ -708,6 +750,15 @@ module Bunny
       Authentication::CredentialsEncoder.for_session(self)
     end
 
+    # @api private
+    def reset_continuations
+      @continuations = if defined?(JRUBY_VERSION)
+                         Concurrent::LinkedContinuationQueue.new
+                       else
+                         Concurrent::ContinuationQueue.new
+                       end
+    end
+
     # @api private
     def wait_on_continuations
       unless @threaded

data/lib/bunny/socket.rb

@@ -14,7 +14,7 @@ module Bunny
         if Socket.constants.include?('TCP_NODELAY') || Socket.constants.include?(:TCP_NODELAY)
           sock.setsockopt(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, true)
         end
-        sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_KEEPALIVE, true) if options[:keepalive]
+        sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_KEEPALIVE, true) if options.fetch(:keepalive, true)
         sock.options = {:host => host, :port => port}.merge(options)
         sock
       end

data/lib/bunny/version.rb

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

data/spec/higher_level_api/integration/basic_nack_spec.rb

@@ -51,7 +51,7 @@ describe Bunny::Channel, "#nack" do
       subject.on_error do |ch, channel_close|
         @channel_close = channel_close
       end
-      subject.nack(82, true)
+      subject.nack(82, false, true)
 
       sleep 0.5
 

data/spec/higher_level_api/integration/basic_publish_spec.rb

@@ -14,6 +14,7 @@ describe "Publishing a message to the default exchange" do
 
   context "with all default delivery and message properties" do
     it "routes messages to a queue with the same name as the routing key" do
+      connection.should be_threaded
       ch = connection.create_channel
 
       q  = ch.queue("", :exclusive => true)
@@ -34,6 +35,7 @@ describe "Publishing a message to the default exchange" do
 
   context "with all default delivery and message properties" do
     it "routes the messages and preserves all the metadata" do
+      connection.should be_threaded
       ch = connection.create_channel
 
       q  = ch.queue("", :exclusive => true)
@@ -55,4 +57,31 @@ describe "Publishing a message to the default exchange" do
       ch.close
     end
   end
+
+
+  context "with all default delivery and message properties on a single-threaded connection" do
+    let(:connection) do
+      c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed", :threaded => false)
+      c.start
+      c
+    end
+
+    it "routes messages to a queue with the same name as the routing key" do
+      connection.should_not be_threaded
+      ch = connection.create_channel
+
+      q  = ch.queue("", :exclusive => true)
+      x  = ch.default_exchange
+
+      x.publish("xyzzy", :routing_key => q.name).
+        publish("xyzzy", :routing_key => q.name).
+        publish("xyzzy", :routing_key => q.name).
+        publish("xyzzy", :routing_key => q.name)
+
+      sleep(1)
+      q.message_count.should == 4
+
+      ch.close
+    end
+  end
 end

data/spec/higher_level_api/integration/connection_spec.rb

@@ -189,7 +189,7 @@ describe Bunny::Session do
     end
 
     it "successfully connects" do
-      subject.start
+      5.times { subject.start }
       subject.should be_connected
 
       subject.server_properties.should_not be_nil

data/spec/higher_level_api/integration/dead_lettering_spec.rb

@@ -24,7 +24,7 @@ describe "A message" do
 
     delivery_info, _, _ = q.pop(:ack => true)
     dlq.message_count.should be_zero
-    ch.nack(delivery_info.delivery_tag, false)
+    ch.nack(delivery_info.delivery_tag)
 
     sleep 0.2
     q.message_count.should be_zero

data/spec/higher_level_api/integration/heartbeat_spec.rb

@@ -0,0 +1,31 @@
+require "spec_helper"
+
+describe "Client-defined heartbeat interval" do
+  let(:connection) do
+    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed", :heartbeat_interval => 4)
+    c.start
+    c
+  end
+
+  it "can be enabled explicitly" do
+    sleep 5.0
+
+    connection.close
+  end
+end
+
+
+describe "Server-defined heartbeat interval" do
+  let(:connection) do
+    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed", :heartbeat_interval => :server)
+    c.start
+    c
+  end
+
+  it "can be enabled explicitly" do
+    puts "Sleeping for 5 seconds with heartbeat interval of 4"
+    sleep 5.0
+
+    connection.close
+  end
+end

data/spec/stress/channel_open_stress_with_single_threaded_connection_spec.rb

@@ -0,0 +1,49 @@
+require "spec_helper"
+
+describe "Rapidly opening and closing lots of channels on a non-threaded connection" do
+  let(:connection) do
+    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed", :automatic_recovery => false, :threaded => false)
+    c.start
+    c
+  end
+
+  after :all do
+    connection.close
+  end
+
+  context "in a single-threaded scenario" do
+    let(:n) { 500 }
+
+    it "works correctly" do
+      xs = Array.new(n) { connection.create_channel }
+      puts "Opened #{n} channels"
+
+      xs.size.should == n
+      xs.each do |ch|
+        ch.close
+      end
+    end
+  end
+
+  context "in a multi-threaded scenario" do
+    # actually, on MRI values greater than ~100 will eventually cause write
+    # operations to fail with a timeout (1 second is not enough)
+    # which will cause recovery to re-acquire @channel_mutex in Session.
+    # Because Ruby's mutexes are not re-entrant, it will raise a ThreadError.
+    #
+    # But this already demonstrates that within these platform constraints,
+    # Bunny is safe to use in such scenarios.
+    let(:n) { 50 }
+
+    it "works correctly" do
+      n.times do
+        t = Thread.new do
+          ch = connection.create_channel
+
+          ch.close
+        end
+        t.abort_on_exception = true
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bunny
 version: !ruby/object:Gem::Version
-  version: 0.9.0.pre8
+  version: 0.9.0.pre9
   prerelease: 6
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-03-12 00:00:00.000000000 Z
+date: 2013-04-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: amq-protocol
@@ -93,6 +93,8 @@ files:
 - lib/bunny/channel_id_allocator.rb
 - lib/bunny/compatibility.rb
 - lib/bunny/concurrent/condition.rb
+- lib/bunny/concurrent/continuation_queue.rb
+- lib/bunny/concurrent/linked_continuation_queue.rb
 - lib/bunny/consumer.rb
 - lib/bunny/consumer_tag_generator.rb
 - lib/bunny/consumer_work_pool.rb
@@ -134,6 +136,7 @@ files:
 - 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/heartbeat_spec.rb
 - spec/higher_level_api/integration/message_properties_access_spec.rb
 - spec/higher_level_api/integration/predeclared_exchanges_spec.rb
 - spec/higher_level_api/integration/publisher_confirms_spec.rb
@@ -155,6 +158,7 @@ files:
 - spec/lower_level_api/integration/basic_consume_spec.rb
 - spec/spec_helper.rb
 - spec/stress/channel_open_stress_spec.rb
+- spec/stress/channel_open_stress_with_single_threaded_connection_spec.rb
 - spec/stress/concurrent_consumers_stress_spec.rb
 - spec/stress/concurrent_publishers_stress_spec.rb
 - spec/unit/bunny_spec.rb
@@ -211,6 +215,7 @@ test_files:
 - 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/heartbeat_spec.rb
 - spec/higher_level_api/integration/message_properties_access_spec.rb
 - spec/higher_level_api/integration/predeclared_exchanges_spec.rb
 - spec/higher_level_api/integration/publisher_confirms_spec.rb
@@ -232,6 +237,7 @@ test_files:
 - spec/lower_level_api/integration/basic_consume_spec.rb
 - spec/spec_helper.rb
 - spec/stress/channel_open_stress_spec.rb
+- spec/stress/channel_open_stress_with_single_threaded_connection_spec.rb
 - spec/stress/concurrent_consumers_stress_spec.rb
 - spec/stress/concurrent_publishers_stress_spec.rb
 - spec/unit/bunny_spec.rb