bunny 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1fc5878c28d1164882b924bba6452f035780026c
-  data.tar.gz: ba690c50d70f94994cc5ae29a5668a9d956cc89a
+  metadata.gz: 0836f4aa9086b7ac58dcfc0f2aa21e65580fca67
+  data.tar.gz: e15d6b9d8a1cb73e1bf686eb0fd2dd0c59741452
 SHA512:
-  metadata.gz: 43a7f6f137bde88a7b7af3e5ec240ba1e8eafafd819eba044b634570fe15d2ba1f88dcb8c0119df493f5a681ca0e7a4e006809164bd1f20044a8654765015cad
-  data.tar.gz: a784125f41292894f6003ab1f06b23dbec5077e66e916b027aafc89f169ba8b0f109a5dec2cb555f0effbdd5d124aa0d6b1bf923935087b3eb74eaeb6c293202
+  metadata.gz: f63f5f0e9646746806cb21a5a1dc57e11f85bb23f5655937dd30136054996dd518cb91c296262569b6b92be83c5a32b503c6b0ff88f8788a3481d4f1f722891c
+  data.tar.gz: 41d514a852463368e4c37a63bda65d8d98308d42fa62f4d4eb925e65554d8e552d29aa8e2b4c1d4386127a34c2f512ee9810a99aeea2793188b5189a586e71c4

data/ChangeLog.md

@@ -1,3 +1,22 @@
+## Changes between Bunny 1.0.0 and 1.0.1
+
+### Default CA's Paths Are Disabled on JRuby
+
+Bunny uses OpenSSL provided CA certificate paths. This
+caused problems on some platforms on JRuby (see [jruby/jruby#155](https://github.com/jruby/jruby/issues/1055)).
+
+To avoid these issues, Bunny no longer uses default CA certificate paths on JRuby
+(there are no changes for other Rubies), so it's necessary to provide
+CA certificate explicitly.
+
+### Fixes CPU Burn on JRuby
+
+Bunny now uses slightly different ways of continuously reading from the socket
+on CRuby and JRuby, to prevent abnormally high CPU usage on JRuby after a
+certain period of time (the frequency of `EWOULDBLOCK` being raised spiked
+sharply).
+
+
 ## Changes between Bunny 1.0.0.rc2 and 1.0.0.rc3
 
 ### [Authentication Failure Notification](http://www.rabbitmq.com/auth-notification.html) Support

data/lib/bunny.rb

@@ -8,7 +8,9 @@ require "amq/protocol/extensions"
 
 require "bunny/framing"
 require "bunny/exceptions"
+
 require "bunny/socket"
+
 require "bunny/timeout"
 
 begin

data/lib/bunny/cruby/socket.rb

@@ -0,0 +1,83 @@
+require "socket"
+
+module Bunny
+  # TCP socket extension that uses TCP_NODELAY and supports reading
+  # fully.
+  #
+  # Heavily inspired by Dalli by Mike Perham.
+  # @private
+  class Socket < TCPSocket
+    attr_accessor :options
+
+    # IO::WaitReadable is 1.9+ only
+    READ_RETRY_EXCEPTION_CLASSES = [Errno::EAGAIN, Errno::EWOULDBLOCK]
+    READ_RETRY_EXCEPTION_CLASSES << IO::WaitReadable if IO.const_defined?(:WaitReadable)
+
+    def self.open(host, port, options = {})
+      Timeout.timeout(options[:socket_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)
+        end
+        sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_KEEPALIVE, true) if options.fetch(:keepalive, true)
+        sock.options = {:host => host, :port => port}.merge(options)
+        sock
+      end
+    end
+
+    # Reads given number of bytes with an optional timeout
+    #
+    # @param [Integer] count How many bytes to read
+    # @param [Integer] timeout Timeout
+    #
+    # @return [String] Data read from the socket
+    # @api public
+    def read_fully(count, timeout = nil)
+      return nil if @__bunny_socket_eof_flag__
+
+      value = ''
+      begin
+        loop do
+          value << read_nonblock(count - value.bytesize)
+          break if value.bytesize >= count
+        end
+      rescue EOFError
+        # @eof will break Rubinius' TCPSocket implementation. MK.
+        @__bunny_socket_eof_flag__ = true
+      rescue *READ_RETRY_EXCEPTION_CLASSES
+        if IO.select([self], nil, nil, timeout)
+          retry
+        else
+          raise Timeout::Error, "IO timeout when reading #{count} bytes"
+        end
+      end
+      value
+    end # read_fully
+
+    # 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
+    #
+    # @api public
+    def write_nonblock_fully(data)
+      return nil if @__bunny_socket_eof_flag__
+
+      begin
+        while !data.empty?
+          written = self.write_nonblock(data)
+          data.slice!(0, written)
+        end
+      rescue Errno::EWOULDBLOCK, Errno::EAGAIN
+        IO.select([], [self])
+        retry
+      end
+
+      data.bytesize
+    end
+  end
+end

data/lib/bunny/cruby/ssl_socket.rb

@@ -0,0 +1,57 @@
+require "socket"
+
+module Bunny
+  begin
+    require "openssl"
+
+    # TLS-enabled TCP socket that implements convenience
+    # methods found in Bunny::Socket.
+    class SSLSocket < OpenSSL::SSL::SSLSocket
+
+      # IO::WaitReadable is 1.9+ only
+      READ_RETRY_EXCEPTION_CLASSES = [Errno::EAGAIN, Errno::EWOULDBLOCK]
+      READ_RETRY_EXCEPTION_CLASSES << IO::WaitReadable if IO.const_defined?(:WaitReadable)
+
+
+      # Reads given number of bytes with an optional timeout
+      #
+      # @param [Integer] count How many bytes to read
+      # @param [Integer] timeout Timeout
+      #
+      # @return [String] Data read from the socket
+      # @api public
+      def read_fully(count, timeout = nil)
+        return nil if @__bunny_socket_eof_flag__
+
+        value = ''
+        begin
+          loop do
+            value << read_nonblock(count - value.bytesize)
+            break if value.bytesize >= count
+          end
+        rescue EOFError => e
+          @__bunny_socket_eof_flag__ = true
+        rescue OpenSSL::SSL::SSLError => e
+          if e.message == "read would block"
+            if IO.select([self], nil, nil, timeout)
+              retry
+            else
+              raise Timeout::Error, "IO timeout when reading #{count} bytes"
+            end
+          else
+            raise e
+          end
+        rescue *READ_RETRY_EXCEPTION_CLASSES => e
+          if IO.select([self], nil, nil, timeout)
+            retry
+          else
+            raise Timeout::Error, "IO timeout when reading #{count} bytes"
+          end
+        end
+        value
+      end
+    end
+  rescue LoadError => le
+    puts "Could not load OpenSSL"
+  end
+end

data/lib/bunny/jruby/socket.rb

@@ -0,0 +1,40 @@
+require "bunny/cruby/socket"
+
+module Bunny
+  module JRuby
+    # TCP socket extension that uses Socket#readpartial to avoid excessive CPU
+    # burn after some time. See issue #165.
+    # @private
+    class Socket < Bunny::Socket
+
+      # Reads given number of bytes with an optional timeout
+      #
+      # @param [Integer] count How many bytes to read
+      # @param [Integer] timeout Timeout
+      #
+      # @return [String] Data read from the socket
+      # @api public
+      def read_fully(count, timeout = nil)
+        return nil if @__bunny_socket_eof_flag__
+
+        value = ''
+        begin
+          loop do
+            value << readpartial(count - value.bytesize)
+            break if value.bytesize >= count
+          end
+        rescue EOFError
+          # @eof will break Rubinius' TCPSocket implementation. MK.
+          @__bunny_socket_eof_flag__ = true
+        rescue *READ_RETRY_EXCEPTION_CLASSES
+          if IO.select([self], nil, nil, timeout)
+            retry
+          else
+            raise Timeout::Error, "IO timeout when reading #{count} bytes"
+          end
+        end
+        value
+      end # read_fully
+    end
+  end
+end

data/lib/bunny/jruby/ssl_socket.rb

@@ -0,0 +1,53 @@
+module Bunny
+  module JRuby
+    begin
+      require "bunny/cruby/ssl_socket"
+      require "openssl"
+
+      # TLS-enabled TCP socket that implements convenience
+      # methods found in Bunny::Socket.
+      class SSLSocket < Bunny::SSLSocket
+
+        # Reads given number of bytes with an optional timeout
+        #
+        # @param [Integer] count How many bytes to read
+        # @param [Integer] timeout Timeout
+        #
+        # @return [String] Data read from the socket
+        # @api public
+        def read_fully(count, timeout = nil)
+          return nil if @__bunny_socket_eof_flag__
+
+          value = ''
+          begin
+            loop do
+              value << read_nonblock(count - value.bytesize)
+              break if value.bytesize >= count
+            end
+          rescue EOFError => e
+            @__bunny_socket_eof_flag__ = true
+          rescue OpenSSL::SSL::SSLError => e
+            if e.message == "read would block"
+              if IO.select([self], nil, nil, timeout)
+                retry
+              else
+                raise Timeout::Error, "IO timeout when reading #{count} bytes"
+              end
+            else
+              raise e
+            end
+          rescue *READ_RETRY_EXCEPTION_CLASSES => e
+            if IO.select([self], nil, nil, timeout)
+              retry
+            else
+              raise Timeout::Error, "IO timeout when reading #{count} bytes"
+            end
+          end
+          value
+        end
+      end
+    rescue LoadError => le
+      puts "Could not load OpenSSL"
+    end
+  end
+end

data/lib/bunny/socket.rb

@@ -1,83 +1,14 @@
-require "socket"
+# See #165. MK.
+if defined?(JRUBY_VERSION)
+  require "bunny/jruby/socket"
 
-module Bunny
-  # TCP socket extension that uses TCP_NODELAY and supports reading
-  # fully.
-  #
-  # Heavily inspired by Dalli by Mike Perham.
-  # @private
-  class Socket < TCPSocket
-    attr_accessor :options
-
-    # IO::WaitReadable is 1.9+ only
-    READ_RETRY_EXCEPTION_CLASSES = [Errno::EAGAIN, Errno::EWOULDBLOCK]
-    READ_RETRY_EXCEPTION_CLASSES << IO::WaitReadable if IO.const_defined?(:WaitReadable)
-
-    def self.open(host, port, options = {})
-      Timeout.timeout(options[:socket_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)
-        end
-        sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_KEEPALIVE, true) if options.fetch(:keepalive, true)
-        sock.options = {:host => host, :port => port}.merge(options)
-        sock
-      end
-    end
-
-    # Reads given number of bytes with an optional timeout
-    #
-    # @param [Integer] count How many bytes to read
-    # @param [Integer] timeout Timeout
-    #
-    # @return [String] Data read from the socket
-    # @api public
-    def read_fully(count, timeout = nil)
-      return nil if @__bunny_socket_eof_flag__
-
-      value = ''
-      begin
-        loop do
-          value << read_nonblock(count - value.bytesize)
-          break if value.bytesize >= count
-        end
-      rescue EOFError
-        # @eof will break Rubinius' TCPSocket implementation. MK.
-        @__bunny_socket_eof_flag__ = true
-      rescue *READ_RETRY_EXCEPTION_CLASSES
-        if IO.select([self], nil, nil, timeout)
-          retry
-        else
-          raise Timeout::Error, "IO timeout when reading #{count} bytes"
-        end
-      end
-      value
-    end # read_fully
-
-    # 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
-    #
-    # @api public
-    def write_nonblock_fully(data)
-      return nil if @__bunny_socket_eof_flag__
-
-      begin
-        while !data.empty?
-          written = self.write_nonblock(data)
-          data.slice!(0, written)
-        end
-      rescue Errno::EWOULDBLOCK, Errno::EAGAIN
-        IO.select([], [self])
-        retry
-      end
+  module Bunny
+    SocketImpl = Socket #JRuby::Socket
+  end
+else
+  require "bunny/cruby/socket"
 
-      data.bytesize
-    end
+  module Bunny
+    SocketImpl = Socket
   end
 end

data/lib/bunny/ssl_socket.rb

@@ -1,57 +1,14 @@
-require "socket"
+# See #165. MK.
+if defined?(JRUBY_VERSION)
+  require "bunny/jruby/ssl_socket"
 
-module Bunny
-  begin
-    require "openssl"
-
-    # TLS-enabled TCP socket that implements convenience
-    # methods found in Bunny::Socket.
-    class SSLSocket < OpenSSL::SSL::SSLSocket
-
-      # IO::WaitReadable is 1.9+ only
-      READ_RETRY_EXCEPTION_CLASSES = [Errno::EAGAIN, Errno::EWOULDBLOCK]
-      READ_RETRY_EXCEPTION_CLASSES << IO::WaitReadable if IO.const_defined?(:WaitReadable)
-
-
-      # Reads given number of bytes with an optional timeout
-      #
-      # @param [Integer] count How many bytes to read
-      # @param [Integer] timeout Timeout
-      #
-      # @return [String] Data read from the socket
-      # @api public
-      def read_fully(count, timeout = nil)
-        return nil if @__bunny_socket_eof_flag__
+  module Bunny
+    SSLSocketImpl = JRuby::SSLSocket
+  end
+else
+  require "bunny/cruby/ssl_socket"
 
-        value = ''
-        begin
-          loop do
-            value << read_nonblock(count - value.bytesize)
-            break if value.bytesize >= count
-          end
-        rescue EOFError => e
-          @__bunny_socket_eof_flag__ = true
-        rescue OpenSSL::SSL::SSLError => e
-          if e.message == "read would block"
-            if IO.select([self], nil, nil, timeout)
-              retry
-            else
-              raise Timeout::Error, "IO timeout when reading #{count} bytes"
-            end
-          else
-            raise e
-          end
-        rescue *READ_RETRY_EXCEPTION_CLASSES => e
-          if IO.select([self], nil, nil, timeout)
-            retry
-          else
-            raise Timeout::Error, "IO timeout when reading #{count} bytes"
-          end
-        end
-        value
-      end
-    end
-  rescue LoadError => le
-    puts "Could not load OpenSSL"
+  module Bunny
+    SSLSocketImpl = SSLSocket
   end
 end

data/lib/bunny/transport.rb

@@ -219,7 +219,7 @@ module Bunny
 
     def self.reacheable?(host, port, timeout)
       begin
-        s = Bunny::Socket.open(host, port,
+        s = Bunny::SocketImpl.open(host, port,
           :socket_timeout => timeout)
 
         true
@@ -237,7 +237,7 @@ module Bunny
     def initialize_socket
       begin
         @socket = Bunny::Timeout.timeout(@connect_timeout, ClientTimeout) do
-          Bunny::Socket.open(@host, @port,
+          Bunny::SocketImpl.open(@host, @port,
             :keepalive      => @opts[:keepalive],
             :socket_timeout => @connect_timeout)
         end
@@ -309,14 +309,7 @@ module Bunny
       @tls_key               = tls_key_from(opts)
       @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, default_tls_certificates)
       @verify_peer           = opts[:verify_ssl] || opts[:verify_peer]
 
       @tls_context = initialize_tls_context(OpenSSL::SSL::SSLContext.new)
@@ -326,7 +319,7 @@ module Bunny
       raise ArgumentError, "cannot wrap nil into TLS socket, @tls_context is nil. This is a Bunny bug." unless socket
       raise "cannot wrap a socket into TLS socket, @tls_context is nil. This is a Bunny bug." unless @tls_context
 
-      s = Bunny::SSLSocket.new(socket, @tls_context)
+      s = Bunny::SSLSocketImpl.new(socket, @tls_context)
       s.sync_close = true
       s
     end
@@ -380,12 +373,30 @@ module Bunny
       ctx
     end
 
+    def default_tls_certificates
+      if defined?(JRUBY_VERSION)
+        # see https://github.com/jruby/jruby/issues/1055. MK.
+        []
+      else
+        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
+
+        [
+          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
+          ].uniq
+      end
+    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
+      puts certs.inspect
       OpenSSL::X509::Store.new.tap do |store|
         certs.each { |path| store.add_file(path) }
       end

data/lib/bunny/version.rb

@@ -2,5 +2,5 @@
 
 module Bunny
   # @return [String] Version of the library
-  VERSION = "1.0.0"
+  VERSION = "1.0.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bunny
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Chris Duncan
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-29 00:00:00.000000000 Z
+date: 2013-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: amq-protocol
@@ -110,11 +110,15 @@ files:
 - lib/bunny/consumer.rb
 - lib/bunny/consumer_tag_generator.rb
 - lib/bunny/consumer_work_pool.rb
+- lib/bunny/cruby/socket.rb
+- lib/bunny/cruby/ssl_socket.rb
 - lib/bunny/delivery_info.rb
 - lib/bunny/exceptions.rb
 - lib/bunny/exchange.rb
 - lib/bunny/framing.rb
 - lib/bunny/heartbeat_sender.rb
+- lib/bunny/jruby/socket.rb
+- lib/bunny/jruby/ssl_socket.rb
 - lib/bunny/message_properties.rb
 - lib/bunny/queue.rb
 - lib/bunny/reader_loop.rb