bunny 0.9.0.pre7 → 0.9.0.pre8

data/ChangeLog.md

@@ -1,3 +1,25 @@
+## Changes between Bunny 0.9.0.pre7 and 0.9.0.pre8
+
+### Automatic Connection Recovery Can Be Disabled
+
+Automatic connection recovery now can be disabled by passing
+the `:automatically_recover => false` option to `Bunny#initialize`).
+
+When the recovery is disabled, network I/O-related exceptions will
+cause an exception to be raised in thee thread the connection was
+started on.
+
+
+### No Timeout Control For Publishing
+
+`Bunny::Exchange#publish` and `Bunny::Channel#basic_publish` no
+longer perform timeout control (using the timeout module) which
+roughly increases throughput for flood publishing by 350%.
+
+Apps that need delivery guarantees should use publisher confirms.
+
+
+
 ## Changes between Bunny 0.9.0.pre6 and 0.9.0.pre7
 
 ### Bunny::Channel#on_error

data/Gemfile

@@ -1,6 +1,6 @@
 # encoding: utf-8
 
-source :rubygems
+source "https://rubygems.org"
 
 # Use local clones if possible.
 # If you want to use your local copy, just symlink it to vendor.
@@ -26,7 +26,7 @@ gem "effin_utf8"
 
 group :development do
   gem "yard"
-  gem "redcarpet"
+  gem "redcarpet", :platform => :mri
 end
 
 group :test do

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.pre6" # optionally: , :git => "git://github.com/ruby-amqp/bunny.git", :branch => "master"
+gem "bunny", ">= 0.9.0.pre7" # optionally: , :git => "git://github.com/ruby-amqp/bunny.git", :branch => "master"
 ```
 
 
@@ -95,7 +95,7 @@ Other documentation guides are available at [rubybunny.info](http://rubybunny.in
 
 ### Mailing List
 
-[Bunny a mailing list](groups.google.com/group/ruby-amqp). We encourage you
+[Bunny a mailing list](http://groups.google.com/group/ruby-amqp). We encourage you
 to also join the [rabbitmq-discuss](https://lists.rabbitmq.com/cgi-bin/mailman/listinfo/rabbitmq-discuss) mailing list. Feel free to ask any questions that you may have.
 
 

data/examples/connection/disabled_automatic_recovery.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require "bundler"
+Bundler.setup
+
+$:.unshift(File.expand_path("../../../lib", __FILE__))
+
+require 'bunny'
+
+conn = Bunny.new(:heartbeat_interval => 8, :automatically_recover => false)
+conn.start
+
+ch = conn.create_channel
+x  = ch.topic("bunny.examples.recovery.topic", :durable => false)
+q  = ch.queue("bunny.examples.recovery.client_named_queue2", :durable => true)
+q.purge
+
+q.bind(x, :routing_key => "abc").bind(x, :routing_key => "def")
+
+loop do
+  sleep 1.5
+  body = rand.to_s
+  puts "Published #{body}"
+  x.publish(body, :routing_key => ["abc", "def"].sample)
+
+  sleep 1.5
+  _, _, payload = q.pop
+  if payload
+    puts "Consumed #{payload}"
+  else
+    puts "Consumed nothing"
+  end
+end

data/lib/bunny.rb

@@ -9,6 +9,14 @@ require "bunny/framing"
 require "bunny/exceptions"
 require "bunny/socket"
 
+begin
+  require "openssl"
+
+  require "bunny/ssl_socket"
+rescue LoadError => e
+  # no-op
+end
+
 # Core entities: connection, channel, exchange, queue, consumer
 require "bunny/session"
 require "bunny/channel"

data/lib/bunny/channel.rb

@@ -342,6 +342,7 @@ module Bunny
     # @param [String] name Exchange name
     # @param [Hash] opts Exchange parameters
     #
+    # @option opts [String,Symbol] :type (:direct) Exchange type, e.g. :fanout or "x-consistent-hash"
     # @option opts [Boolean] :durable (false) Should the exchange be durable?
     # @option opts [Boolean] :auto_delete (false) Should the exchange be automatically deleted when no longer in use?
     # @option opts [Hash] :arguments ({}) Optional exchange arguments
@@ -509,14 +510,15 @@ module Bunny
         @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)
+      m = AMQ::Protocol::Basic::Publish.encode(@id,
+                                               payload,
+                                               meta,
+                                               exchange_name,
+                                               routing_key,
+                                               meta[:mandatory],
+                                               false,
+                                               @connection.frame_max)
+      @connection.send_frameset_without_timeout(m, self)
 
       self
     end
@@ -782,6 +784,12 @@ module Bunny
                      queue
                    end
 
+      # helps avoid race condition between basic.consume-ok and basic.deliver if there are messages
+      # in the queue already. MK.
+      if consumer_tag && consumer_tag.strip != AMQ::Protocol::EMPTY_STRING
+        add_consumer(queue_name, consumer_tag, no_ack, exclusive, arguments, &block)
+      end
+
       @connection.send_frame(AMQ::Protocol::Basic::Consume.encode(@id,
                                                                   queue_name,
                                                                   consumer_tag,
@@ -790,11 +798,6 @@ module Bunny
                                                                   exclusive,
                                                                   false,
                                                                   arguments))
-      # helps avoid race condition between basic.consume-ok and basic.deliver if there are messages
-      # in the queue already. MK.
-      if consumer_tag && consumer_tag.strip != AMQ::Protocol::EMPTY_STRING
-        add_consumer(queue_name, consumer_tag, no_ack, exclusive, arguments, &block)
-      end
 
       Bunny::Timer.timeout(read_write_timeout, ClientTimeout) do
         @last_basic_consume_ok = wait_on_continuations

data/lib/bunny/channel_id_allocator.rb

@@ -10,9 +10,8 @@ module Bunny
 
     # @param [Integer] max_channel Max allowed channel id
     def initialize(max_channel = ((1 << 16) - 1))
-      @int_allocator ||= AMQ::IntAllocator.new(1, max_channel)
-
-      @channel_id_mutex ||= Mutex.new
+      @allocator = AMQ::IntAllocator.new(1, max_channel)
+      @mutex     = Mutex.new
     end
 
 
@@ -23,8 +22,8 @@ module Bunny
     # @see ChannelManager#release_channel_id
     # @see ChannelManager#reset_channel_id_allocator
     def next_channel_id
-      @channel_id_mutex.synchronize do
-        @int_allocator.allocate
+      @mutex.synchronize do
+        @allocator.allocate
       end
     end
 
@@ -35,10 +34,10 @@ module Bunny
     # @see ChannelManager#next_channel_id
     # @see ChannelManager#reset_channel_id_allocator
     def release_channel_id(i)
-      @channel_id_mutex.synchronize do
-        @int_allocator.release(i)
+      @mutex.synchronize do
+        @allocator.release(i)
       end
-    end # self.release_channel_id(i)
+    end
 
 
     # Returns true if given channel id has been previously allocated and not yet released.
@@ -50,8 +49,8 @@ module Bunny
     # @see ChannelManager#next_channel_id
     # @see ChannelManager#release_channel_id
     def allocated_channel_id?(i)
-      @channel_id_mutex.synchronize do
-        @int_allocator.allocated?(i)
+      @mutex.synchronize do
+        @allocator.allocated?(i)
       end
     end
 
@@ -60,9 +59,13 @@ module Bunny
     # @see Channel.next_channel_id
     # @see Channel.release_channel_id
     def reset_channel_id_allocator
-      @channel_id_mutex.synchronize do
-        @int_allocator.reset
+      @mutex.synchronize do
+        @allocator.reset
       end
-    end # reset_channel_id_allocator
+    end
+
+    def synchronize(&block)
+      @mutex.synchronize(&block)
+    end
   end
 end

data/lib/bunny/exceptions.rb

@@ -1,5 +1,40 @@
 module Bunny
-  class TCPConnectionFailed < StandardError
+  class Exception < ::Exception
+  end
+
+  class NetworkFailure < Exception
+    attr_reader :cause
+
+    def initialize(message, cause)
+      super(message)
+      @cause = cause
+    end
+  end
+
+  class ChannelLevelException < Exception
+    attr_reader :channel, :channel_close
+
+    def initialize(message, ch, channel_close)
+      super(message)
+
+      @channel       = ch
+      @channel_close = channel_close
+    end
+  end
+
+  class ConnectionLevelException < Exception
+    attr_reader :connection, :connection_close
+
+    def initialize(message, connection, connection_close)
+      super(message)
+
+      @connection       = connection
+      @connection_close = connection_close
+    end
+  end
+
+
+  class TCPConnectionFailed < Exception
     attr_reader :hostname, :port
 
     def initialize(e, hostname, port)
@@ -13,7 +48,7 @@ module Bunny
     end
   end
 
-  class ConnectionClosedError < StandardError
+  class ConnectionClosedError < Exception
     def initialize(frame)
       if frame.respond_to?(:method_class)
         super("Trying to send frame through a closed connection. Frame is #{frame.inspect}, method class is #{frame.method_class}")
@@ -23,7 +58,7 @@ module Bunny
     end
   end
 
-  class PossibleAuthenticationFailureError < StandardError
+  class PossibleAuthenticationFailureError < Exception
 
     #
     # API
@@ -44,10 +79,10 @@ module Bunny
   ConnectionError = TCPConnectionFailed
   ServerDownError = TCPConnectionFailed
 
-  class ForcedChannelCloseError < StandardError; end
-  class ForcedConnectionCloseError < StandardError; end
-  class MessageError < StandardError; end
-  class ProtocolError < StandardError; end
+  class ForcedChannelCloseError < Exception; end
+  class ForcedConnectionCloseError < Exception; end
+  class MessageError < Exception; end
+  class ProtocolError < Exception; end
 
   # raised when read or write I/O operations time out (but only if
   # a connection is configured to use them)
@@ -57,7 +92,7 @@ module Bunny
 
 
   # Base exception class for data consistency and framing errors.
-  class InconsistentDataError < StandardError
+  class InconsistentDataError < Exception
   end
 
   # Raised by adapters when frame does not end with {final octet AMQ::Protocol::Frame::FINAL_OCTET}.
@@ -82,7 +117,7 @@ module Bunny
   end
 
 
-  class ChannelAlreadyClosed < StandardError
+  class ChannelAlreadyClosed < Exception
     attr_reader :channel
 
     def initialize(message, ch)
@@ -92,17 +127,6 @@ module Bunny
     end
   end
 
-  class ChannelLevelException < StandardError
-    attr_reader :channel, :channel_close
-
-    def initialize(message, ch, channel_close)
-      super(message)
-
-      @channel       = ch
-      @channel_close = channel_close
-    end
-  end
-
   class PreconditionFailed < ChannelLevelException
   end
 
@@ -116,18 +140,6 @@ module Bunny
   end
 
 
-
-  class ConnectionLevelException < StandardError
-    attr_reader :connection, :connection_close
-
-    def initialize(message, connection, connection_close)
-      super(message)
-
-      @connection       = connection
-      @connection_close = connection_close
-    end
-  end
-
   class ChannelError < ConnectionLevelException
   end
 
@@ -137,7 +149,7 @@ module Bunny
   class UnexpectedFrame < ConnectionLevelException
   end
 
-  class NetworkErrorWrapper < StandardError
+  class NetworkErrorWrapper < Exception
     attr_reader :other
 
     def initialize(other)

data/lib/bunny/main_loop.rb

@@ -8,9 +8,10 @@ module Bunny
   # This mimics the way RabbitMQ Java is designed quite closely.
   class MainLoop
 
-    def initialize(transport, session)
-      @transport = transport
-      @session   = session
+    def initialize(transport, session, session_thread)
+      @transport      = transport
+      @session        = session
+      @session_thread = session_thread
     end
 
 
@@ -29,19 +30,25 @@ module Bunny
         begin
           break if @stopping || @network_is_down
           run_once
-        rescue Timeout::Error => te
-          # given that the server may be pushing data to us, timeout detection/handling
-          # should happen per operation and not in this loop
         rescue Errno::EBADF => ebadf
           # ignored, happens when we loop after the transport has already been closed
-        rescue AMQ::Protocol::EmptyResponseError, IOError, Errno::EPIPE, Errno::EAGAIN => e
-          puts "Exception in the main loop: #{e.class.name}"
+        rescue AMQ::Protocol::EmptyResponseError, IOError, SystemCallError => e
+          puts "Exception in the main loop:"
+          log_exception(e)
+
           @network_is_down = true
-          @session.handle_network_failure(e)
+
+          if @session.automatically_recover?
+            @session.handle_network_failure(e)
+          else
+            @session_thread.raise(Bunny::NetworkFailure.new("detected a network failure: #{e.message}", e))
+          end
         rescue Exception => e
-          puts e.class.name
-          puts e.message
-          puts e.backtrace
+          puts "Unepxected exception in the main loop:"
+          log_exception(e)
+
+          @network_is_down = true
+          @session_thread.raise(Bunny::NetworkFailure.new("caught an unexpected exception in the network loop: #{e.message}", e))
         end
       end
     end
@@ -79,5 +86,13 @@ module Bunny
       @thread.kill
       @thread.join
     end
+
+    def log_exception(e)
+      puts e.class.name
+      puts e.message
+      e.backtrace.each do |line|
+        puts line
+      end
+    end
   end
 end

data/lib/bunny/queue.rb

@@ -208,7 +208,7 @@ module Bunny
 
     # @param [Hash] opts Options
     #
-    # @option opts [Boolean] block (false) Should the call block calling thread?
+    # @option opts [Boolean] :ack (false) Will the message be acknowledged manually?
     #
     # @return [Array] Triple of delivery info, message properties and message content.
     #                 If the queue is empty, all three will be nils.

data/lib/bunny/session.rb

@@ -101,6 +101,13 @@ module Bunny
       @logging         = opts[:logging] || false
       @threaded        = opts.fetch(:threaded, true)
 
+      # should automatic recovery from network failures be used?
+      @automatically_recover = if opts[:automatically_recover].nil? && opts[:automatic_recovery].nil?
+                                 true
+                               else
+                                 opts[:automatically_recover] || opts[:automatic_recovery]
+                               end
+
       @status             = :not_connected
 
       # these are negotiated with the broker during the connection tuning phase
@@ -112,7 +119,9 @@ module Bunny
       @mechanism           = opts.fetch(:auth_mechanism, "PLAIN")
       @credentials_encoder = credentials_encoder_for(@mechanism)
       @locale              = @opts.fetch(:locale, DEFAULT_LOCALE)
+      # mutex for the channel id => channel hash
       @channel_mutex       = Mutex.new
+      @network_mutex       = Mutex.new
       @channels            = Hash.new
 
       @continuations       = ::Queue.new
@@ -210,6 +219,10 @@ module Bunny
     end
     alias connected? open?
 
+    def automatically_recover?
+      @automatically_recover
+    end
+
     #
     # Backwards compatibility
     #
@@ -254,7 +267,9 @@ module Bunny
       n = ch.number
       self.register_channel(ch)
 
-      @transport.send_frame(AMQ::Protocol::Channel::Open.encode(n, AMQ::Protocol::EMPTY_STRING))
+      @channel_mutex.synchronize do
+        @transport.send_frame(AMQ::Protocol::Channel::Open.encode(n, AMQ::Protocol::EMPTY_STRING))
+      end
       @last_channel_open_ok = wait_on_continuations
       raise_if_continuation_resulted_in_a_connection_error!
 
@@ -317,8 +332,7 @@ module Bunny
           puts e.message
           puts e.backtrace
         ensure
-          @active_continuation.notify_all if @active_continuation
-          @active_continuation = false
+          @continuations.push(nil)
         end
       when AMQ::Protocol::Channel::Close then
         begin
@@ -420,8 +434,8 @@ module Bunny
     end
 
     # @private
-    def send_raw(*args)
-      @transport.write(*args)
+    def send_raw(data)
+      @transport.write(data)
     end
 
     # @private
@@ -513,7 +527,7 @@ module Bunny
 
     # @private
     def event_loop
-      @event_loop ||= MainLoop.new(@transport, self)
+      @event_loop ||= MainLoop.new(@transport, self, Thread.current)
     end
 
     # @private
@@ -531,7 +545,21 @@ module Bunny
       if closed?
         raise ConnectionClosedError.new(frame)
       else
-        @transport.send_raw(frame.encode)
+        @network_mutex.synchronize { @transport.write(frame.encode) }
+      end
+    end
+
+    # Sends frame to the peer, checking that connection is open.
+    # Uses transport implementation that does not perform
+    # timeout control. Exposed primarily for Bunny::Channel.
+    #
+    # @raise [ConnectionClosedError]
+    # @private
+    def send_frame_without_timeout(frame)
+      if closed?
+        raise ConnectionClosedError.new(frame)
+      else
+        @network_mutex.synchronize { @transport.write_without_timeout(frame.encode) }
       end
     end
 
@@ -546,11 +574,27 @@ module Bunny
       # If we synchronize on the channel, however, this is both thread safe and pretty fine-grained
       # locking. Note that "single frame" methods do not need this kind of synchronization. MK.
       channel.synchronize do
-        frames.each { |frame| @transport.send_frame(frame) }
+        frames.each { |frame| self.send_frame(frame) }
         @transport.flush
       end
     end # send_frameset(frames)
 
+    # Sends multiple frames, one by one. For thread safety this method takes a channel
+    # object and synchronizes on it. Uses transport implementation that does not perform
+    # timeout control.
+    #
+    # @api private
+    def send_frameset_without_timeout(frames, channel)
+      # some developers end up sharing channels between threads and when multiple
+      # threads publish on the same channel aggressively, at some point frames will be
+      # delivered out of order and broker will raise 505 UNEXPECTED_FRAME exception.
+      # If we synchronize on the channel, however, this is both thread safe and pretty fine-grained
+      # locking. Note that "single frame" methods do not need this kind of synchronization. MK.
+      channel.synchronize do
+        frames.each { |frame| self.send_frame_without_timeout(frame) }
+      end
+    end # send_frameset_without_timeout(frames)
+
     protected
 
     # @api private
@@ -576,7 +620,7 @@ module Bunny
                 @transport.read_next_frame
                 # frame timeout means the broker has closed the TCP connection, which it
                 # does per 0.9.1 spec.
-              rescue Errno::ECONNRESET, ClientTimeout, AMQ::Protocol::EmptyResponseError, EOFError => e
+              rescue Errno::ECONNRESET, ClientTimeout, AMQ::Protocol::EmptyResponseError, EOFError, IOError => e
                 nil
               end
       if frame.nil?
@@ -644,7 +688,7 @@ module Bunny
 
     # @api private
     def initialize_transport
-      @transport = Transport.new(self, @host, @port, @opts)
+      @transport = Transport.new(self, @host, @port, @opts.merge(:session_thread => Thread.current))
     end
 
     # Sends AMQ protocol header (also known as preamble).