bunny 1.5.1 → 1.6.0.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 53c74a39ad4bc726f41f1c2db1f6ad7e7ebdefb8
-  data.tar.gz: 4ede7c5896c820ab5895963f1da741dda42e9fe7
+  metadata.gz: de1627dd44089041db13ab6a5ea76ba2ead5086d
+  data.tar.gz: 41ae99e1499f57a77636392e2a5d870c6c698ef7
 SHA512:
-  metadata.gz: 14e4fbe2d2aca163498882cb49ee7d6ec90756a7c0c6e419b5c73e3afc31673451e4b75a4f47f1c49e5525dd91b5b792d074fa7edef18aa18957a542896bb02c
-  data.tar.gz: d750d4af8cf6fd512a60422865b4e8df3e0dcd6c6f72eb95ed671bd73ba053e3fca8dea7d853517502de59f0f43e0b3e7531f13f7a23d622050e98aaea2b552f
+  metadata.gz: 1e24bb89154db20fe6badb7427bab93de1d9a2e4c880b972340b5d76f4d465aa6410c75c55f5a51a091526deec93d30ced4cd815080d7dc0a7dbce06eb89d95b
+  data.tar.gz: 4d210c02531f031fdfc5ab021d02b32abdc2d4019440bf76650743e950f310cf2ec27e09193feee987cfc97f65c6d026a1cd0451a4367f35f84c8ce003fe7318

data/ChangeLog.md

@@ -1,3 +1,25 @@
+## Changes between Bunny 1.5.0 and 1.6.0
+
+### Socket Read and Write Timeout Improvements
+
+Bunny now sets a read timeout on the sockets it opens, and uses
+`IO.select` timeouts as the most reliable option available
+on Ruby 1.9 and later.
+
+GH issue: [#254](https://github.com/ruby-amqp/bunny/pull/254).
+
+Contributed by Andre Foeken (Nedap).
+
+### Inline TLS Certificates Support
+
+TLS certificate options now accept inline certificates as well as
+file paths.
+
+GH issues: [#255](https://github.com/ruby-amqp/bunny/pull/255), [#256](https://github.com/ruby-amqp/bunny/pull/256).
+
+Contributed by Will Barrett (Sqwiggle).
+
+
 ## Changes between Bunny 1.4.0 and 1.5.0
 
 ### Improved Uncaught Exception Handler

data/bunny.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |s|
   s.version = Bunny::VERSION.dup
   s.homepage = "http://rubybunny.info"
   s.summary = "Popular easy to use Ruby client for RabbitMQ"
-  s.description = "Easy to use, feature complete Ruby client for RabbitMQ 2.0 and later versions."
+  s.description = "Easy to use, feature complete Ruby client for RabbitMQ 3.3 and later versions."
   s.license = "MIT"
 
   # Sorted alphabetically.

data/lib/bunny/channel.rb

@@ -203,8 +203,8 @@ module Bunny
     attr_reader :recoveries_counter
 
     # @private
-    def read_write_timeout
-      @connection.read_write_timeout
+    def wait_on_continuations_timeout
+      @connection.transport_write_timeout
     end
 
     # Opens the channel and resets its internal state
@@ -629,7 +629,7 @@ module Bunny
 
       @connection.send_frame(AMQ::Protocol::Basic::Qos.encode(@id, 0, count, global))
 
-      Bunny::Timeout.timeout(read_write_timeout, ClientTimeout) do
+      Bunny::Timeout.timeout(wait_on_continuations_timeout, ClientTimeout) do
         @last_basic_qos_ok = wait_on_continuations
       end
       raise_if_continuation_resulted_in_a_channel_error!
@@ -648,7 +648,7 @@ module Bunny
       raise_if_no_longer_open!
 
       @connection.send_frame(AMQ::Protocol::Basic::Recover.encode(@id, requeue))
-      Bunny::Timeout.timeout(read_write_timeout, ClientTimeout) do
+      Bunny::Timeout.timeout(wait_on_continuations_timeout, ClientTimeout) do
         @last_basic_recover_ok = wait_on_continuations
       end
       raise_if_continuation_resulted_in_a_channel_error!
@@ -850,7 +850,7 @@ module Bunny
           arguments))
 
       begin
-        Bunny::Timeout.timeout(read_write_timeout, ClientTimeout) do
+        Bunny::Timeout.timeout(wait_on_continuations_timeout, ClientTimeout) do
           @last_basic_consume_ok = wait_on_continuations
         end
       rescue Exception => e
@@ -900,7 +900,7 @@ module Bunny
           consumer.arguments))
 
       begin
-        Bunny::Timeout.timeout(read_write_timeout, ClientTimeout) do
+        Bunny::Timeout.timeout(wait_on_continuations_timeout, ClientTimeout) do
           @last_basic_consume_ok = wait_on_continuations
         end
       rescue Exception => e
@@ -935,7 +935,7 @@ module Bunny
     def basic_cancel(consumer_tag)
       @connection.send_frame(AMQ::Protocol::Basic::Cancel.encode(@id, consumer_tag, false))
 
-      Bunny::Timeout.timeout(read_write_timeout, ClientTimeout) do
+      Bunny::Timeout.timeout(wait_on_continuations_timeout, ClientTimeout) do
         @last_basic_cancel_ok = wait_on_continuations
       end
 
@@ -1009,7 +1009,7 @@ module Bunny
           opts[:if_unused],
           opts[:if_empty],
           false))
-      Bunny::Timeout.timeout(read_write_timeout, ClientTimeout) do
+      Bunny::Timeout.timeout(wait_on_continuations_timeout, ClientTimeout) do
         @last_queue_delete_ok = wait_on_continuations
       end
       raise_if_continuation_resulted_in_a_channel_error!
@@ -1029,7 +1029,7 @@ module Bunny
 
       @connection.send_frame(AMQ::Protocol::Queue::Purge.encode(@id, name, false))
 
-      Bunny::Timeout.timeout(read_write_timeout, ClientTimeout) do
+      Bunny::Timeout.timeout(wait_on_continuations_timeout, ClientTimeout) do
         @last_queue_purge_ok = wait_on_continuations
       end
       raise_if_continuation_resulted_in_a_channel_error!
@@ -1065,7 +1065,7 @@ module Bunny
           (opts[:routing_key] || opts[:key]),
           false,
           opts[:arguments]))
-      Bunny::Timeout.timeout(read_write_timeout, ClientTimeout) do
+      Bunny::Timeout.timeout(wait_on_continuations_timeout, ClientTimeout) do
         @last_queue_bind_ok = wait_on_continuations
       end
 
@@ -1100,7 +1100,7 @@ module Bunny
           exchange_name,
           opts[:routing_key],
           opts[:arguments]))
-      Bunny::Timeout.timeout(read_write_timeout, ClientTimeout) do
+      Bunny::Timeout.timeout(wait_on_continuations_timeout, ClientTimeout) do
         @last_queue_unbind_ok = wait_on_continuations
       end
 
@@ -1139,7 +1139,7 @@ module Bunny
           opts.fetch(:internal, false),
           false, # nowait
           opts[:arguments]))
-      Bunny::Timeout.timeout(read_write_timeout, ClientTimeout) do
+      Bunny::Timeout.timeout(wait_on_continuations_timeout, ClientTimeout) do
         @last_exchange_declare_ok = wait_on_continuations
       end
 
@@ -1164,7 +1164,7 @@ module Bunny
           name,
           opts[:if_unused],
           false))
-      Bunny::Timeout.timeout(read_write_timeout, ClientTimeout) do
+      Bunny::Timeout.timeout(wait_on_continuations_timeout, ClientTimeout) do
         @last_exchange_delete_ok = wait_on_continuations
       end
 
@@ -1208,7 +1208,7 @@ module Bunny
           opts[:routing_key],
           false,
           opts[:arguments]))
-      Bunny::Timeout.timeout(read_write_timeout, ClientTimeout) do
+      Bunny::Timeout.timeout(wait_on_continuations_timeout, ClientTimeout) do
         @last_exchange_bind_ok = wait_on_continuations
       end
 
@@ -1252,7 +1252,7 @@ module Bunny
           opts[:routing_key],
           false,
           opts[:arguments]))
-      Bunny::Timeout.timeout(read_write_timeout, ClientTimeout) do
+      Bunny::Timeout.timeout(wait_on_continuations_timeout, ClientTimeout) do
         @last_exchange_unbind_ok = wait_on_continuations
       end
 
@@ -1280,7 +1280,7 @@ module Bunny
       raise_if_no_longer_open!
 
       @connection.send_frame(AMQ::Protocol::Channel::Flow.encode(@id, active))
-      Bunny::Timeout.timeout(read_write_timeout, ClientTimeout) do
+      Bunny::Timeout.timeout(wait_on_continuations_timeout, ClientTimeout) do
         @last_channel_flow_ok = wait_on_continuations
       end
       raise_if_continuation_resulted_in_a_channel_error!
@@ -1301,7 +1301,7 @@ module Bunny
       raise_if_no_longer_open!
 
       @connection.send_frame(AMQ::Protocol::Tx::Select.encode(@id))
-      Bunny::Timeout.timeout(read_write_timeout, ClientTimeout) do
+      Bunny::Timeout.timeout(wait_on_continuations_timeout, ClientTimeout) do
         @last_tx_select_ok = wait_on_continuations
       end
       raise_if_continuation_resulted_in_a_channel_error!
@@ -1317,7 +1317,7 @@ module Bunny
       raise_if_no_longer_open!
 
       @connection.send_frame(AMQ::Protocol::Tx::Commit.encode(@id))
-      Bunny::Timeout.timeout(read_write_timeout, ClientTimeout) do
+      Bunny::Timeout.timeout(wait_on_continuations_timeout, ClientTimeout) do
         @last_tx_commit_ok = wait_on_continuations
       end
       raise_if_continuation_resulted_in_a_channel_error!
@@ -1332,7 +1332,7 @@ module Bunny
       raise_if_no_longer_open!
 
       @connection.send_frame(AMQ::Protocol::Tx::Rollback.encode(@id))
-      Bunny::Timeout.timeout(read_write_timeout, ClientTimeout) do
+      Bunny::Timeout.timeout(wait_on_continuations_timeout, ClientTimeout) do
         @last_tx_rollback_ok = wait_on_continuations
       end
       raise_if_continuation_resulted_in_a_channel_error!
@@ -1379,7 +1379,7 @@ module Bunny
       @confirms_callback = callback
 
       @connection.send_frame(AMQ::Protocol::Confirm::Select.encode(@id, false))
-      Bunny::Timeout.timeout(read_write_timeout, ClientTimeout) do
+      Bunny::Timeout.timeout(wait_on_continuations_timeout, ClientTimeout) do
         @last_confirm_select_ok = wait_on_continuations
       end
       @confirm_mode = true

data/lib/bunny/cruby/socket.rb

@@ -13,8 +13,12 @@ module Bunny
     READ_RETRY_EXCEPTION_CLASSES = [Errno::EAGAIN, Errno::EWOULDBLOCK]
     READ_RETRY_EXCEPTION_CLASSES << IO::WaitReadable if IO.const_defined?(:WaitReadable)
 
+    # IO::WaitWritable is 1.9+ only
+    WRITE_RETRY_EXCEPTION_CLASSES = [Errno::EAGAIN, Errno::EWOULDBLOCK]
+    WRITE_RETRY_EXCEPTION_CLASSES << IO::WaitWritable if IO.const_defined?(:WaitWritable)
+
     def self.open(host, port, options = {})
-      Timeout.timeout(options[:socket_timeout], ClientTimeout) do
+      Timeout.timeout(options[:connect_timeout], ClientTimeout) 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)
@@ -62,22 +66,32 @@ module Bunny
     # if this is not appropriate in your case.
     #
     # @param [String] data Data to write
+    # @param [Integer] timeout Timeout
     #
     # @api public
-    def write_nonblock_fully(data)
+    def write_nonblock_fully(data, timeout = nil)
       return nil if @__bunny_socket_eof_flag__
 
-      begin
-        while !data.empty?
-          written = self.write_nonblock(data)
-          data.slice!(0, written)
+      length = data.bytesize
+      total_count = 0
+      count = 0
+      loop do
+        begin
+          count = self.write_nonblock(data)
+        rescue *WRITE_RETRY_EXCEPTION_CLASSES
+          if IO.select([], [self], nil, timeout)
+            retry
+          else
+            raise Timeout::Error, "IO timeout when writing to socket"
+          end
         end
-      rescue Errno::EWOULDBLOCK, Errno::EAGAIN
-        IO.select([], [self])
-        retry
+
+        total_count += count
+        return total_count if total_count >= length
+        data = data.byteslice(count..-1)
       end
 
-      data.bytesize
     end
+
   end
 end

data/lib/bunny/cruby/ssl_socket.rb

@@ -12,6 +12,9 @@ module Bunny
       READ_RETRY_EXCEPTION_CLASSES = [Errno::EAGAIN, Errno::EWOULDBLOCK]
       READ_RETRY_EXCEPTION_CLASSES << IO::WaitReadable if IO.const_defined?(:WaitReadable)
 
+      # IO::WaitWritable is 1.9+ only
+      WRITE_RETRY_EXCEPTION_CLASSES = [Errno::EAGAIN, Errno::EWOULDBLOCK]
+      WRITE_RETRY_EXCEPTION_CLASSES << IO::WaitWritable if IO.const_defined?(:WaitWritable)
 
       # Reads given number of bytes with an optional timeout
       #
@@ -50,6 +53,51 @@ module Bunny
         end
         value
       end
+
+      # Writes provided data using IO#write_nonblock, taking care of handling
+      # of exceptions it raises when writing would fail (e.g. due to socket buffer
+      # being full).
+      #
+      # IMPORTANT: this method will mutate (slice) the argument. Pass in duplicates
+      # if this is not appropriate in your case.
+      #
+      # @param [String] data Data to write
+      # @param [Integer] timeout Timeout
+      #
+      # @api public
+      def write_nonblock_fully(data, timeout = nil)
+        return nil if @__bunny_socket_eof_flag__
+
+        length = data.bytesize
+        total_count = 0
+        count = 0
+        loop do
+          begin
+            count = self.write_nonblock(data)
+          rescue OpenSSL::SSL::SSLError => e
+            if e.message == "write would block"
+              if IO.select([], [self], nil, timeout)
+                retry
+              else
+                raise Timeout::Error, "IO timeout when writing to socket"
+              end
+            end
+            raise e
+          rescue *WRITE_RETRY_EXCEPTION_CLASSES
+            if IO.select([], [self], nil, timeout)
+              retry
+            else
+              raise Timeout::Error, "IO timeout when writing to socket"
+            end
+          end
+
+          total_count += count
+          return total_count if total_count >= length
+          data = data.byteslice(count..-1)
+        end
+
+      end
+
     end
   rescue LoadError => le
     puts "Could not load OpenSSL"

data/lib/bunny/session.rb

@@ -154,7 +154,7 @@ module Bunny
       @network_recovery_interval = opts.fetch(:network_recovery_interval, DEFAULT_NETWORK_RECOVERY_INTERVAL)
       @recover_from_connection_close = opts.fetch(:recover_from_connection_close, false)
       # in ms
-      @continuation_timeout      = opts.fetch(:continuation_timeout, DEFAULT_CONTINUATION_TIMEOUT)
+      @continuation_timeout   = opts.fetch(:continuation_timeout, DEFAULT_CONTINUATION_TIMEOUT)
 
       @status             = :not_connected
       @blocked            = false
@@ -279,9 +279,11 @@ module Bunny
           self.start_reader_loop if threaded?
 
         rescue TCPConnectionFailed => e
-          self.initialize_transport
 
           @logger.warn e.message
+
+          self.initialize_transport
+
           @logger.warn "Retrying connection on next host in line: #{@transport.host}:#{@transport.port}"
 
           return self.start
@@ -299,11 +301,11 @@ module Bunny
       self
     end
 
-    # Socket operation timeout used by this connection
+    # Socket operation write timeout used by this connection
     # @return [Integer]
     # @private
-    def read_write_timeout
-      @transport.read_write_timeout
+    def transport_write_timeout
+      @transport.write_timeout
     end
 
     # Opens a new channel and returns it. This method will block the calling
@@ -645,8 +647,9 @@ module Bunny
         sleep @network_recovery_interval
         @logger.debug "About to start connection recovery..."
 
-        self.reset_host_index # since we are starting a fresh try.
         self.initialize_transport
+
+        @logger.warn "Retrying connection on next host in line: #{@transport.host}:#{@transport.port}"
         self.start
 
         if open?
@@ -654,6 +657,9 @@ module Bunny
 
           recover_channels
         end
+      rescue HostListDepleted
+        reset_host_index
+        retry
       rescue TCPConnectionFailedForAllHosts, TCPConnectionFailed, AMQ::Protocol::EmptyResponseError => e
         @logger.warn "TCP connection failed, reconnecting in #{@network_recovery_interval} seconds"
         sleep @network_recovery_interval
@@ -990,6 +996,10 @@ module Bunny
       @logger.debug "Heartbeat interval negotiation: client = #{@client_heartbeat}, server = #{connection_tune.heartbeat}, result = #{@heartbeat}"
       @logger.info "Heartbeat interval used (in seconds): #{@heartbeat}"
 
+      # We set the read_write_timeout to twice the heartbeat value
+      # This allows us to miss a single heartbeat before we time out the socket.
+      @transport.read_timeout = @heartbeat * 2
+
       # if there are existing channels we've just recovered from
       # a network failure and need to fix the allocated set. See issue 205. MK.
       if @channels.empty?
@@ -1079,7 +1089,13 @@ module Bunny
     def initialize_transport
       if host = @hosts[ @host_index ]
         @host_index_mutex.synchronize { @host_index += 1 }
+        @transport.close rescue nil # Let's make sure the previous transport socket is closed
         @transport = Transport.new(self, host, @port, @opts.merge(:session_thread => @origin_thread))
+
+        # Reset the cached progname for the logger
+        @logger.progname = to_s if @logger.respond_to?(:progname)
+
+        @transport
       else
         raise HostListDepleted
       end

data/lib/bunny/transport.rb

@@ -21,12 +21,19 @@ module Bunny
 
     # Default TCP connection timeout
     DEFAULT_CONNECTION_TIMEOUT = 5.0
+
     DEFAULT_READ_TIMEOUT  = 5.0
     DEFAULT_WRITE_TIMEOUT = 5.0
 
-    attr_reader :session, :host, :port, :socket, :connect_timeout, :read_write_timeout, :disconnect_timeout
+    # Default TLS protocol version to use.
+    # Currently SSLv3, same as in RabbitMQ Java client
+    DEFAULT_TLS_PROTOCOL       = "SSLv3"
+
+    attr_reader :session, :host, :port, :socket, :connect_timeout, :read_timeout, :write_timeout, :disconnect_timeout
     attr_reader :tls_context
 
+    attr_writer :read_timeout
+
     def initialize(session, host, port, opts)
       @session        = session
       @session_thread = opts[:session_thread]
@@ -37,11 +44,17 @@ module Bunny
       @logger                = session.logger
       @tls_enabled           = tls_enabled?(opts)
 
-      @read_write_timeout = opts[:socket_timeout] || 3
-      @read_write_timeout = nil if @read_write_timeout == 0
+      @read_timeout = opts[:read_timeout] || DEFAULT_READ_TIMEOUT
+      @read_timeout = nil if @read_timeout == 0
+
+      @write_timeout = opts[:socket_timeout] # Backwards compatability
+
+      @write_timeout ||= opts[:write_timeout] || DEFAULT_WRITE_TIMEOUT
+      @write_timeout = nil if @write_timeout == 0
+
       @connect_timeout    = self.timeout_from(opts)
       @connect_timeout    = nil if @connect_timeout == 0
-      @disconnect_timeout = @read_write_timeout || @connect_timeout
+      @disconnect_timeout = @write_timeout || @read_timeout || @connect_timeout
 
       @writes_mutex       = @session.mutex_impl.new
 
@@ -92,26 +105,20 @@ module Bunny
       block.call(@tls_context) if @tls_context
     end
 
-    # Writes data to the socket. If read/write timeout was specified, Bunny::ClientTimeout will be raised
-    # if the operation times out.
+    # Writes data to the socket. If read/write timeout was specified the operation will return after that
+    # amount of time has elapsed waiting for the socket.
     #
     # @raise [ClientTimeout]
     def write(data)
+      return write_without_timeout(data) unless @write_timeout
+
       begin
-        if @read_write_timeout
-          Bunny::Timeout.timeout(@read_write_timeout, Bunny::ClientTimeout) do
-            if open?
-              @writes_mutex.synchronize { @socket.write(data) }
-              @socket.flush
-            end
-          end
-        else
-          if open?
-            @writes_mutex.synchronize { @socket.write(data) }
-            @socket.flush
+        if open?
+          @writes_mutex.synchronize do
+            @socket.write_nonblock_fully(data, @write_timeout)
           end
         end
-      rescue SystemCallError, Bunny::ClientTimeout, Bunny::ConnectionError, IOError => e
+      rescue SystemCallError, Timeout::Error, Bunny::ConnectionError, IOError => e
         @logger.error "Got an exception when sending data: #{e.message} (#{e.class.name})"
         close
         @status = :not_connected
@@ -181,8 +188,20 @@ module Bunny
       @socket.flush if @socket
     end
 
-    def read_fully(*args)
-      @socket.read_fully(*args)
+    def read_fully(count)
+      begin
+        @socket.read_fully(count, @read_timeout)
+      rescue SystemCallError, Timeout::Error, Bunny::ConnectionError, IOError => e
+        @logger.error "Got an exception when receiving data: #{e.message} (#{e.class.name})"
+        close
+        @status = :not_connected
+
+        if @session.automatically_recover?
+          @session.handle_network_failure(e)
+        else
+          @session_thread.raise(Bunny::NetworkFailure.new("detected a network failure: #{e.message}", e))
+        end
+      end
     end
 
     def read_ready?(timeout = nil)
@@ -190,11 +209,10 @@ module Bunny
       io && io[0].include?(@socket)
     end
 
-
     # Exposed primarily for Bunny::Channel
     # @private
     def read_next_frame(opts = {})
-      header    = @socket.read_fully(7)
+      header    = read_fully(7)
       # TODO: network issues here will sometimes cause
       #       the socket method return an empty string. We need to log
       #       and handle this better.
@@ -204,8 +222,8 @@ module Bunny
       #                         puts "Got AMQ::Protocol::EmptyResponseError, header is #{header.inspect}"
       #                       end
       type, channel, size = AMQ::Protocol::Frame.decode_header(header)
-      payload   = @socket.read_fully(size)
-      frame_end = @socket.read_fully(1)
+      payload   = read_fully(size)
+      frame_end = read_fully(1)
 
       # 1) the size is miscalculated
       if payload.bytesize != size
@@ -221,7 +239,7 @@ module Bunny
     def self.reacheable?(host, port, timeout)
       begin
         s = Bunny::SocketImpl.open(host, port,
-          :socket_timeout => timeout)
+          :connect_timeout => timeout)
 
         true
       rescue SocketError, Timeout::Error => e
@@ -239,7 +257,7 @@ module Bunny
       begin
         @socket = Bunny::SocketImpl.open(@host, @port,
           :keepalive      => @opts[:keepalive],
-          :socket_timeout => @connect_timeout)
+          :connect_timeout => @connect_timeout)
       rescue StandardError, ClientTimeout => e
         @status = :not_connected
         raise Bunny::TCPConnectionFailed.new(e, self.hostname, self.port)
@@ -294,7 +312,7 @@ module Bunny
 
 
     def inline_client_certificate_from(opts)
-      opts[:tls_certificate] || opts[:ssl_cert_string]
+      opts[:tls_certificate] || opts[:ssl_cert_string] || opts[:tls_cert]
     end
 
     def inline_client_key_from(opts)
@@ -313,7 +331,7 @@ module Bunny
       @tls_ca_certificates   = opts.fetch(:tls_ca_certificates, default_tls_certificates)
       @verify_peer           = opts[:verify_ssl] || opts[:verify_peer]
 
-      @tls_context = initialize_tls_context(OpenSSL::SSL::SSLContext.new, opts)
+      @tls_context = initialize_tls_context(OpenSSL::SSL::SSLContext.new)
     end
 
     def wrap_in_tls_socket(socket)
@@ -347,7 +365,7 @@ module Bunny
       end
     end
 
-    def initialize_tls_context(ctx, opts={})
+    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_store = if @tls_certificate_store
@@ -366,15 +384,17 @@ module Bunny
         @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))
+
       verify_mode = if @verify_peer
         OpenSSL::SSL::VERIFY_PEER|OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT
       else
         OpenSSL::SSL::VERIFY_NONE
       end
-      ctx.verify_mode = verify_mode
 
-      ssl_version = opts[:tls_protocol] || opts[:ssl_version]
-      ctx.ssl_version = ssl_version if ssl_version
+      ctx.set_params(:verify_mode => verify_mode)
 
       ctx
     end
@@ -397,13 +417,23 @@ module Bunny
     end
 
     def initialize_tls_certificate_store(certs)
-      certs = certs.select { |path| File.readable? path }
-      @logger.debug "Using CA certificates at #{certs.join(', ')}"
+      cert_files = []
+      cert_inlines = []
+      certs.each do |cert|
+        if File.readable? cert
+          cert_files.push(cert)
+        else
+          cert_inlines.push(cert)
+        end
+      end
+      @logger.debug "Using CA certificates at #{cert_files.join(', ')}"
+      @logger.debug "Using #{cert_inlines.count} inline ca_certificates"
       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) }
+        cert_files.each { |path| store.add_file(path) }
+        cert_inlines.each { |cert| store.add_cert(OpenSSL::X509::Certificate.new(cert)) }
       end
     end
 

data/lib/bunny/version.rb

@@ -2,5 +2,5 @@
 
 module Bunny
   # @return [String] Version of the library
-  VERSION = "1.5.1"
+  VERSION = "1.6.0.pre1"
 end

data/spec/higher_level_api/integration/tls_connection_spec.rb

@@ -124,51 +124,4 @@ unless ENV["CI"]
 
     include_examples "successful TLS connection"
   end
-
-
-  describe "TLS connection to RabbitMQ with ssl_version SSLv3 specified" do
-    let(:connection) do
-      c = Bunny.new(:user     => "bunny_gem",
-        :password => "bunny_password",
-        :vhost    => "bunny_testbed",
-        :tls                   => true,
-        :ssl_version           => :SSLv3,
-        :tls_ca_certificates   => ["./spec/tls/cacert.pem"])
-      c.start
-      c
-    end
-
-    after :each do
-      connection.close
-    end
-
-    include_examples "successful TLS connection"
-
-    it "connects using SSLv3" do
-      connection.transport.socket.ssl_version.should == "SSLv3"
-    end
-  end
-
-  describe "TLS connection to RabbitMQ with tls_version TLSv1 specified" do
-    let(:connection) do
-      c = Bunny.new(:user     => "bunny_gem",
-        :password => "bunny_password",
-        :vhost    => "bunny_testbed",
-        :tls                   => true,
-        :tls_protocol           => :TLSv1,
-        :tls_ca_certificates   => ["./spec/tls/cacert.pem"])
-      c.start
-      c
-    end
-
-    after :each do
-      connection.close
-    end
-
-    include_examples "successful TLS connection"
-
-    it "connects using TLSv1" do
-      connection.transport.socket.ssl_version.should == "TLSv1"
-    end
-  end
 end

data/spec/issues/issue100_spec.rb

@@ -6,7 +6,8 @@ unless ENV["CI"]
       c = Bunny.new(:user     => "bunny_gem",
                     :password => "bunny_password",
                     :vhost    => "bunny_testbed",
-                    :socket_timeout => 0)
+                    :write_timeout => 0,
+                    :read_timeout => 0)
       c.start
       c
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bunny
 version: !ruby/object:Gem::Version
-  version: 1.5.1
+  version: 1.6.0.pre1
 platform: ruby
 authors:
 - Chris Duncan
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-22 00:00:00.000000000 Z
+date: 2014-10-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: amq-protocol
@@ -28,7 +28,7 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: 1.9.2
-description: Easy to use, feature complete Ruby client for RabbitMQ 2.0 and later
+description: Easy to use, feature complete Ruby client for RabbitMQ 3.3 and later
   versions.
 email:
 - celldee@gmail.com
@@ -225,9 +225,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.2.2