bunny 0.10.8 → 1.0.0.pre1

data/lib/bunny/channel_id_allocator.rb

@@ -1,5 +1,4 @@
 require "thread"
-require "monitor"
 require "amq/int_allocator"
 
 module Bunny
@@ -19,7 +18,7 @@ module Bunny
     # @param [Integer] max_channel Max allowed channel id
     def initialize(max_channel = ((1 << 16) - 1))
       @allocator = AMQ::IntAllocator.new(1, max_channel)
-      @mutex     = Monitor.new
+      @mutex     = Mutex.new
     end
 
 

data/lib/bunny/concurrent/condition.rb

@@ -1,5 +1,4 @@
 require "thread"
-require "monitor"
 
 module Bunny
   # @private
@@ -15,7 +14,7 @@ module Bunny
 
 
       def initialize(description = nil)
-        @mutex           = Monitor.new
+        @mutex           = Mutex.new
         @waiting_threads = []
         @description     = description
       end

data/lib/bunny/concurrent/continuation_queue.rb

@@ -21,7 +21,7 @@ module Bunny
 
       def poll(timeout_in_ms = nil)
         if timeout_in_ms
-          Bunny::Timeout.timeout(timeout_in_ms / 1000, ::Timeout::Error) do
+          Bunny::Timer.timeout(timeout_in_ms / 1000, Timeout::Error) do
             @q.pop
           end
         else

data/lib/bunny/consumer.rb

@@ -37,7 +37,6 @@ module Bunny
       @consumer_tag  = consumer_tag
       @exclusive     = exclusive
       @arguments     = arguments
-      # no_ack set to true = no manual ack = automatic ack. MK.
       @no_ack        = no_ack
     end
 
@@ -90,18 +89,6 @@ module Bunny
       "#<#{self.class.name}:#{object_id} @channel_id=#{@channel.number} @queue=#{self.queue_name}> @consumer_tag=#{@consumer_tag}>"
     end
 
-    # @return [Boolean] true if this consumer uses automatic acknowledgement mode
-    # @api public
-    def automatic_acknowledgement?
-      @no_ack == false
-    end
-
-    # @return [Boolean] true if this consumer uses manual (explicit) acknowledgement mode
-    # @api public
-    def manual_acknowledgement?
-      @no_ack == true
-    end
-
     #
     # Recovery
     #

data/lib/bunny/consumer_work_pool.rb

@@ -4,8 +4,6 @@ module Bunny
   # Thread pool that dispatches consumer deliveries. Not supposed to be shared between channels
   # or threads.
   #
-  # Every channel its own consumer pool.
-  #
   # @private
   class ConsumerWorkPool
 
@@ -13,7 +11,6 @@ module Bunny
     # API
     #
 
-    attr_reader :threads
     attr_reader :size
 
     def initialize(size = 1)
@@ -51,8 +48,8 @@ module Bunny
       end
     end
 
-    def join(timeout = nil)
-      @threads.each { |t| t.join(timeout) }
+    def join
+      @threads.each { |t| t.join }
     end
 
     def pause

data/lib/bunny/delivery_info.rb

@@ -1,5 +1,3 @@
-require "bunny/versioned_delivery_tag"
-
 module Bunny
   # Wraps {AMQ::Protocol::Basic::Deliver} to
   # provide access to the delivery properties as immutable hash as
@@ -26,7 +24,7 @@ module Bunny
       @basic_deliver = basic_deliver
       @hash          = {
         :consumer_tag => basic_deliver.consumer_tag,
-        :delivery_tag => VersionedDeliveryTag.new(basic_deliver.delivery_tag, channel.recoveries_counter),
+        :delivery_tag => basic_deliver.delivery_tag,
         :redelivered  => basic_deliver.redelivered,
         :exchange     => basic_deliver.exchange,
         :routing_key  => basic_deliver.routing_key,

data/lib/bunny/exceptions.rb

@@ -55,7 +55,7 @@ module Bunny
           when Exception then
             e.message
           end
-      super("Could not establish TCP connection to #{hostname}:#{port}: #{m}")
+      super("Could not estabilish TCP connection to #{hostname}:#{port}: #{m}")
     end
   end
 
@@ -70,9 +70,6 @@ module Bunny
     end
   end
 
-  class ShutdownSignal < Exception
-  end
-
   # Raised when RabbitMQ closes TCP connection before finishing connection
   # sequence properly. This typically indicates an authentication issue.
   class PossibleAuthenticationFailureError < Exception

data/lib/bunny/heartbeat_sender.rb

@@ -15,7 +15,7 @@ module Bunny
     def initialize(transport, logger)
       @transport = transport
       @logger    = logger
-      @mutex     = Monitor.new
+      @mutex     = Mutex.new
 
       @last_activity_time = Time.now
     end

data/lib/bunny/reader_loop.rb

@@ -19,6 +19,7 @@ module Bunny
 
     def start
       @thread    = Thread.new(&method(:run_loop))
+      @thread.abort_on_exception = true
     end
 
     def resume
@@ -32,10 +33,8 @@ module Bunny
           break if @stopping || @network_is_down
           run_once
         rescue Errno::EBADF => ebadf
-          break if @stopping
           # ignored, happens when we loop after the transport has already been closed
         rescue AMQ::Protocol::EmptyResponseError, IOError, SystemCallError => e
-          break if @stopping
           log_exception(e)
 
           @network_is_down = true
@@ -45,18 +44,13 @@ module Bunny
           else
             @session_thread.raise(Bunny::NetworkFailure.new("detected a network failure: #{e.message}", e))
           end
-        rescue ShutdownSignal => _
-          break
         rescue Exception => e
-          break if @stopping
           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
-
-      @stopped = true
     end
 
     def run_once
@@ -86,23 +80,9 @@ module Bunny
       @stopping = true
     end
 
-    def stopped?
-      @stopped
-    end
-
-    def raise(e)
-      @thread.raise(e) if @thread
-    end
-
-    def join
-      @thread.join if @thread
-    end
-
     def kill
-      if @thread
-        @thread.kill
-        @thread.join
-      end
+      @thread.kill
+      @thread.join
     end
 
     def log_exception(e)

data/lib/bunny/session.rb

@@ -1,6 +1,5 @@
 require "socket"
 require "thread"
-require "monitor"
 
 require "bunny/transport"
 require "bunny/channel_id_allocator"
@@ -97,23 +96,18 @@ module Bunny
     # @option connection_string_or_opts [String] :password ("guest") Password
     # @option connection_string_or_opts [String] :vhost ("/") Virtual host to use
     # @option connection_string_or_opts [Integer] :heartbeat (600) Heartbeat interval. 0 means no heartbeat.
-    # @option connection_string_or_opts [Boolean] :tls (false) Should TLS/SSL be used?
-    # @option connection_string_or_opts [String] :tls_cert (nil) Path to client TLS/SSL certificate file (.pem)
-    # @option connection_string_or_opts [String] :tls_key (nil) Path to client TLS/SSL private key file (.pem)
-    # @option connection_string_or_opts [Array<String>] :tls_ca_certificates Array of paths to TLS/SSL CA files (.pem), by default detected from OpenSSL configuration
     #
     # @option optz [String] :auth_mechanism ("PLAIN") Authentication mechanism, PLAIN or EXTERNAL
     # @option optz [String] :locale ("PLAIN") Locale RabbitMQ should use
     #
     # @see http://rubybunny.info/articles/connecting.html Connecting to RabbitMQ guide
-    # @see http://rubybunny.info/articles/tls.html TLS/SSL guide
     # @api public
     def initialize(connection_string_or_opts = Hash.new, optz = Hash.new)
       opts = case (ENV["RABBITMQ_URL"] || connection_string_or_opts)
              when nil then
                Hash.new
              when String then
-               self.class.parse_uri(ENV["RABBITMQ_URL"] || connection_string_or_opts)
+               AMQ::Settings.parse_amqp_url(connection_string_or_opts)
              when Hash then
                connection_string_or_opts
              end.merge(optz)
@@ -150,14 +144,11 @@ module Bunny
       @mechanism           = opts.fetch(:auth_mechanism, "PLAIN")
       @credentials_encoder = credentials_encoder_for(@mechanism)
       @locale              = @opts.fetch(:locale, DEFAULT_LOCALE)
-
-      @mutex_impl          = @opts.fetch(:mutex_impl, Monitor)
-
       # mutex for the channel id => channel hash
-      @channel_mutex       = @mutex_impl.new
+      @channel_mutex       = Mutex.new
       # transport operations/continuations mutex. A workaround for
       # the non-reentrant Ruby mutexes. MK.
-      @transport_mutex     = @mutex_impl.new
+      @transport_mutex     = Mutex.new
       @channels            = Hash.new
 
       @origin_thread       = Thread.current
@@ -195,11 +186,6 @@ module Bunny
       @threaded
     end
 
-    # @private
-    attr_reader :mutex_impl
-
-    # Provides a way to fine tune the socket used by connection.
-    # Accepts a block that the socket will be yielded to.
     def configure_socket(&block)
       raise ArgumentError, "No block provided!" if block.nil?
 
@@ -233,7 +219,7 @@ module Bunny
         self.open_connection
 
         @reader_loop = nil
-        self.start_reader_loop if threaded?
+        self.start_reader_loop if @threaded
 
         @default_channel = self.create_channel
       rescue Exception => e
@@ -272,14 +258,9 @@ module Bunny
       if @transport.open?
         close_all_channels
 
-        Bunny::Timeout.timeout(@transport.disconnect_timeout, ClientTimeout) do
-          self.close_connection(true)
+        Bunny::Timer.timeout(@transport.disconnect_timeout, ClientTimeout) do
+          self.close_connection(false)
         end
-
-        maybe_shutdown_reader_loop
-        close_transport
-
-        @status = :closed
       end
     end
     alias stop close
@@ -349,41 +330,6 @@ module Bunny
       @default_channel.exchange(*args)
     end
 
-    # Defines a callback that will be executed when RabbitMQ blocks the connection
-    # because it is running low on memory or disk space (as configured via config file
-    # and/or rabbitmqctl).
-    #
-    # @yield [AMQ::Protocol::Connection::Blocked] connection.blocked method which provides a reason for blocking
-    #
-    # @api public
-    def on_blocked(&block)
-      @block_callback = block
-    end
-
-    # Defines a callback that will be executed when RabbitMQ unblocks the connection
-    # that was previously blocked, e.g. because the memory or disk space alarm has cleared.
-    #
-    # @see #on_blocked
-    # @api public
-    def on_unblocked(&block)
-      @unblock_callback = block
-    end
-
-    # @return [Boolean] true if the connection is currently blocked by RabbitMQ because it's running low on
-    #                   RAM, disk space, or other resource; false otherwise
-    # @see #on_blocked
-    # @see #on_unblocked
-    def blocked?
-      @blocked
-    end
-
-    # Parses an amqp[s] URI into a hash that {Bunny::Session#initialize} accepts.
-    #
-    # @param [String] uri amqp or amqps URI to parse
-    # @return [Hash] Parsed URI as a hash
-    def self.parse_uri(uri)
-      AMQ::Settings.parse_amqp_url(uri)
-    end
 
     #
     # Implementation
@@ -418,21 +364,19 @@ module Bunny
     # @private
     def close_all_channels
       @channels.reject {|n, ch| n == 0 || !ch.open? }.each do |_, ch|
-        Bunny::Timeout.timeout(@transport.disconnect_timeout, ClientTimeout) { ch.close }
+        Bunny::Timer.timeout(@transport.disconnect_timeout, ClientTimeout) { ch.close }
       end
     end
 
     # @private
     def close_connection(sync = true)
-      if @transport.open?
-        @transport.send_frame(AMQ::Protocol::Connection::Close.encode(200, "Goodbye", 0, 0))
+      @transport.send_frame(AMQ::Protocol::Connection::Close.encode(200, "Goodbye", 0, 0))
 
-        maybe_shutdown_heartbeat_sender
-        @status   = :not_connected
+      maybe_shutdown_heartbeat_sender
+      @status   = :not_connected
 
-        if sync
-          @last_connection_close_ok = wait_on_continuations
-        end
+      if sync
+        @last_connection_close_ok = wait_on_continuations
       end
     end
 
@@ -448,11 +392,16 @@ module Bunny
         @last_connection_error = instantiate_connection_level_exception(method)
         @continuations.push(method)
 
-        @origin_thread.raise(@last_connection_error)
+        raise @last_connection_error
       when AMQ::Protocol::Connection::CloseOk then
         @last_connection_close_ok = method
         begin
           @continuations.clear
+
+          reader_loop.stop
+          @reader_loop = nil
+
+          @transport.close
         rescue StandardError => e
           @logger.error e.class.name
           @logger.error e.message
@@ -666,40 +615,7 @@ module Bunny
 
     # @private
     def maybe_shutdown_reader_loop
-      if @reader_loop
-        @reader_loop.stop
-        if threaded?
-          # this is the easiest way to wait until the loop
-          # is guaranteed to have terminated
-          @reader_loop.raise(ShutdownSignal)
-          # joining the thread here may take forever
-          # on JRuby because sun.nio.ch.KQueueArrayWrapper#kevent0 is
-          # a native method that cannot be (easily) interrupted.
-          # So we use this ugly hack or else our test suite takes forever
-          # to run on JRuby (a new connection is opened/closed per example). MK.
-          if defined?(JRUBY_VERSION)
-            sleep 0.075
-          else
-            @reader_loop.join
-          end
-        else
-          # single threaded mode, nothing to do. MK.
-        end
-      end
-
-      @reader_loop = nil
-    end
-
-    # @private
-    def close_transport
-      begin
-        @transport.close
-      rescue StandardError => e
-        @logger.error "Exception when closing transport:"
-        @logger.error e.class.name
-        @logger.error e.message
-        @logger.error e.backtrace
-      end
+      @reader_loop.stop if @reader_loop
     end
 
     # @private

data/lib/bunny/socket.rb

@@ -14,7 +14,7 @@ module Bunny
     READ_RETRY_EXCEPTION_CLASSES << IO::WaitReadable if IO.const_defined?(:WaitReadable)
 
     def self.open(host, port, options = {})
-      Timeout.timeout(options[:socket_timeout], ClientTimeout) do
+      Timeout.timeout(options[:socket_timeout]) do
         sock = new(host, port)
         if Socket.constants.include?('TCP_NODELAY') || Socket.constants.include?(:TCP_NODELAY)
           sock.setsockopt(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, true)

data/lib/bunny/transport.rb

@@ -1,6 +1,5 @@
 require "socket"
 require "thread"
-require "monitor"
 
 begin
   require "openssl"
@@ -41,15 +40,7 @@ module Bunny
       @tls_certificate       = opts[:tls_certificate] || opts[:ssl_cert_string]
       @tls_key               = opts[:tls_key]         || opts[:ssl_key_string]
       @tls_certificate_store = opts[:tls_certificate_store]
-
-      default_ca_file = ENV[OpenSSL::X509::DEFAULT_CERT_FILE_ENV] || OpenSSL::X509::DEFAULT_CERT_FILE
-      default_ca_path = ENV[OpenSSL::X509::DEFAULT_CERT_DIR_ENV] || OpenSSL::X509::DEFAULT_CERT_DIR
-      @tls_ca_certificates   = opts.fetch(:tls_ca_certificates, [
-        default_ca_file,
-        File.join(default_ca_path, 'ca-certificates.crt'), # Ubuntu/Debian
-        File.join(default_ca_path, 'ca-bundle.crt'), # Amazon Linux & Fedora/RHEL
-        File.join(default_ca_path, 'ca-bundle.pem') # OpenSUSE
-      ])
+      @tls_ca_certificates   = opts.fetch(:tls_ca_certificates, [])
       @verify_peer           = opts[:verify_ssl] || opts[:verify_peer]
 
       @read_write_timeout = opts[:socket_timeout] || 3
@@ -58,7 +49,7 @@ module Bunny
       @connect_timeout    = nil if @connect_timeout == 0
       @disconnect_timeout = @read_write_timeout || @connect_timeout
 
-      @writes_mutex       = @session.mutex_impl.new
+      @writes_mutex       = Mutex.new
 
       maybe_initialize_socket
       prepare_tls_context if @tls_enabled
@@ -112,7 +103,7 @@ module Bunny
     def write(data)
       begin
         if @read_write_timeout
-          Bunny::Timeout.timeout(@read_write_timeout, Bunny::ClientTimeout) do
+          Bunny::Timer.timeout(@read_write_timeout, Bunny::ClientTimeout) do
             if open?
               @writes_mutex.synchronize { @socket.write(data) }
               @socket.flush
@@ -250,12 +241,12 @@ module Bunny
 
     def initialize_socket
       begin
-        @socket = Bunny::Timeout.timeout(@connect_timeout, ClientTimeout) do
+        @socket = Bunny::Timer.timeout(@connect_timeout, ConnectionTimeout) do
           Bunny::Socket.open(@host, @port,
                              :keepalive      => @opts[:keepalive],
                              :socket_timeout => @connect_timeout)
         end
-      rescue StandardError, ClientTimeout => e
+      rescue StandardError, ConnectionTimeout => e
         @status = :not_connected
         raise Bunny::TCPConnectionFailed.new(e, self.hostname, self.port)
       end
@@ -320,24 +311,14 @@ module Bunny
     end
 
     def initialize_tls_context(ctx)
-      ctx.cert       = OpenSSL::X509::Certificate.new(@tls_certificate) if @tls_certificate
-      ctx.key        = OpenSSL::PKey::RSA.new(@tls_key) if @tls_key
+      ctx.cert       = OpenSSL::X509::Certificate.new(@tls_certificate)
+      ctx.key        = OpenSSL::PKey::RSA.new(@tls_key)
       ctx.cert_store = if @tls_certificate_store
                          @tls_certificate_store
                        else
                          initialize_tls_certificate_store(@tls_ca_certificates)
                        end
 
-      if !@tls_certificate
-        @logger.warn <<-MSG
-        Using TLS but no client certificate is provided! If RabbitMQ is configured to verify peer
-        certificate, connection upgrade will fail!
-        MSG
-      end
-      if @tls_certificate && !@tls_key
-        @logger.warn "Using TLS but no client private key is provided!"
-      end
-
       # setting TLS/SSL version only works correctly when done
       # vis set_params. MK.
       ctx.set_params(:ssl_version => @opts.fetch(:tls_protocol, DEFAULT_TLS_PROTOCOL))
@@ -347,11 +328,6 @@ module Bunny
     end
 
     def initialize_tls_certificate_store(certs)
-      certs = certs.select { |path| File.readable? path }
-      @logger.debug "Using CA certificates at #{certs.join(', ')}"
-      if certs.empty?
-        @logger.error "No CA certificates found, add one with :tls_ca_certificates"
-      end
       OpenSSL::X509::Store.new.tap do |store|
         certs.each { |path| store.add_file(path) }
       end