bunny 0.9.0.pre7 → 0.9.0.pre8

data/lib/bunny/socket.rb

@@ -4,7 +4,7 @@ module Bunny
   # TCP socket extension that uses TCP_NODELAY and supports reading
   # fully.
   #
-  # Heavily inspired by Dalli::Server::KSocket from Dalli by Mike Perham.
+  # Heavily inspired by Dalli by Mike Perham.
   class Socket < TCPSocket
     attr_accessor :options
 
@@ -32,7 +32,7 @@ module Bunny
       rescue EOFError
         @eof = true
       rescue Errno::EAGAIN, Errno::EWOULDBLOCK
-        if IO.select([self], nil, nil, options.fetch(:socket_timeout, timeout))
+        if IO.select([self], nil, nil, timeout)
           retry
         else
           raise Timeout::Error, "IO timeout when reading #{count} bytes"

data/lib/bunny/ssl_socket.rb

@@ -0,0 +1,33 @@
+require "socket"
+
+module Bunny
+  begin
+    require "openssl"
+
+    class SSLSocket < OpenSSL::SSL::SSLSocket
+      def read_fully(count, timeout = nil)
+        return nil if @eof
+
+        value = ''
+        begin
+          loop do
+            value << read_nonblock(count - value.bytesize)
+            break if value.bytesize >= count
+          end
+        rescue EOFError
+          @eof = true
+        rescue Errno::EAGAIN, Errno::EWOULDBLOCK, OpenSSL::SSL::SSLError => e
+          puts e.inspect
+          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/transport.rb

@@ -1,6 +1,12 @@
 require "socket"
 require "thread"
 
+begin
+  require "openssl"
+rescue LoadError => le
+  puts "Could not load OpenSSL"
+end
+
 require "bunny/exceptions"
 require "bunny/socket"
 
@@ -12,32 +18,35 @@ module Bunny
     #
 
     DEFAULT_CONNECTION_TIMEOUT = 5.0
+    # same as in RabbitMQ Java client
+    DEFAULT_TLS_PROTOCOL       = "SSLv3"
 
 
     attr_reader :session, :host, :port, :socket, :connect_timeout, :read_write_timeout, :disconnect_timeout
 
     def initialize(session, host, port, opts)
-      @session = session
+      @session        = session
+      @session_thread = opts[:session_thread]
       @host    = host
       @port    = port
       @opts    = opts
 
-      @ssl             = opts[:ssl] || false
-      @ssl_cert        = opts[:ssl_cert]
-      @ssl_key         = opts[:ssl_key]
-      @ssl_cert_string = opts[:ssl_cert_string]
-      @ssl_key_string  = opts[:ssl_key_string]
-      @verify_ssl      = opts[:verify_ssl].nil? || opts[:verify_ssl]
+      @tls_enabled           = tls_enabled?(opts)
+      @tls_certificate_path  = tls_certificate_path_from(opts)
+      @tls_key_path          = tls_key_path_from(opts)
+      @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]
+      @verify_peer           = opts[:verify_ssl] || opts[:verify_peer]
 
-      @read_write_timeout = opts[:socket_timeout] || 1
+      @read_write_timeout = opts[:socket_timeout] || 3
       @read_write_timeout = nil if @read_write_timeout == 0
       @connect_timeout    = self.timeout_from(opts)
       @connect_timeout    = nil if @connect_timeout == 0
       @disconnect_timeout = @read_write_timeout || @connect_timeout
 
-      @frames             = Hash.new { Array.new }
-
       initialize_socket
+      connect
     end
 
 
@@ -46,46 +55,78 @@ module Bunny
     end
 
     def uses_tls?
-      @ssl
+      @tls_enabled
     end
     alias tls? uses_tls?
 
     def uses_ssl?
-      @ssl
+      @tls_enabled
     end
     alias ssl? uses_ssl?
 
 
+    def connect
+      if uses_ssl?
+        @socket.connect
+        @socket.post_connection_check(host) if uses_tls? && @verify_peer
+      else
+        # no-op
+      end
+    end
+
 
     # Writes data to the socket. If read/write timeout was specified, Bunny::ClientTimeout will be raised
     # if the operation times out.
     #
     # @raise [ClientTimeout]
-    def write(*args)
+    def write(data)
       begin
-        raise Bunny::ConnectionError.new("No connection: socket is nil. ", @host, @port) if !@socket
         if @read_write_timeout
           Bunny::Timer.timeout(@read_write_timeout, Bunny::ClientTimeout) do
-            @socket.write(*args) if open?
+            if open?
+              @socket.write(data)
+              @socket.flush
+            end
           end
         else
-          @socket.write(*args) if open?
+          if open?
+            @socket.write(data)
+            @socket.flush
+          end
         end
-      rescue Errno::EPIPE, Errno::EAGAIN, Bunny::ClientTimeout, Bunny::ConnectionError, IOError => e
+      rescue SystemCallError, Bunny::ClientTimeout, Bunny::ConnectionError, IOError => e
         close
 
-        @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
       end
     end
     alias send_raw write
 
+    # Writes data to the socket without timeout checks
+    def write_without_timeout(data)
+      begin
+        @socket.write(data)
+      rescue SystemCallError, Bunny::ConnectionError, IOError => e
+        close
+
+        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 close(reason = nil)
-      @socket.close if @socket and not @socket.closed?
-      @socket   = nil
+      @socket.close unless @socket.closed?
     end
 
     def open?
-      !@socket.nil? && !@socket.closed?
+      !@socket.closed?
     end
 
     def closed?
@@ -139,6 +180,20 @@ module Bunny
       end
     end
 
+    # Sends frame to the peer without timeout control.
+    #
+    # @raise [ConnectionClosedError]
+    # @private
+    def send_frame_without_timeout(frame)
+      if closed?
+        @session.handle_network_failure(ConnectionClosedError.new(frame))
+      else
+        frame.encode_to_array.each do |component|
+          write_without_timeout(component)
+        end
+      end
+    end
+
 
     def self.reacheable?(host, port, timeout)
       begin
@@ -160,24 +215,31 @@ module Bunny
 
     protected
 
+    def tls_enabled?(opts)
+      opts[:tls] || opts[:ssl] || (opts[:port] == AMQ::Protocol::TLS_PORT) || false
+    end
+
+    def tls_certificate_path_from(opts)
+      opts[:tls_cert] || opts[:ssl_cert] || opts[:tls_cert_path] || opts[:ssl_cert_path] || opts[:tls_certificate_path] || opts[:ssl_certificate_path]
+    end
+
+    def tls_key_path_from(opts)
+      opts[:tls_key] || opts[:ssl_key] || opts[:tls_key_path] || opts[:ssl_key_path]
+    end
+
     def initialize_socket
       begin
-        @socket = Bunny::Timer.timeout(@connect_timeout, ConnectionTimeout) do
+        s = Bunny::Timer.timeout(@connect_timeout, ConnectionTimeout) do
           Bunny::Socket.open(@host, @port,
                              :keepalive      => @opts[:keepalive],
                              :socket_timeout => @connect_timeout)
         end
 
-        if @ssl
-          require 'openssl' unless defined? OpenSSL::SSL
-          sslctx = OpenSSL::SSL::SSLContext.new
-          initialize_client_pair(sslctx)
-          @socket = OpenSSL::SSL::SSLSocket.new(@socket, sslctx)
-          @socket.sync_close = true
-          @socket.connect
-          @socket.post_connection_check(host) if @verify_ssl
-          @socket
-        end
+        @socket =  if uses_tls?
+                     wrap_in_tls_socket(s)
+                   else
+                     s
+                   end
       rescue StandardError, ConnectionTimeout => e
         @status = :not_connected
         raise Bunny::TCPConnectionFailed.new(e, self.hostname, self.port)
@@ -186,17 +248,39 @@ module Bunny
       @socket
     end
 
-    def initialize_client_pair(sslctx)
-      if @ssl_cert
-        @ssl_cert_string = File.read(@ssl_cert)
+    def wrap_in_tls_socket(socket)
+      read_tls_keys!
+
+      ctx = initialize_tls_context(OpenSSL::SSL::SSLContext.new(@opts.fetch(:tls_protocol, DEFAULT_TLS_PROTOCOL)))
+
+      s = Bunny::SSLSocket.new(socket, ctx)
+      s.sync_close = true
+      s
+    end
+
+    def check_local_path!(s)
+      raise ArgumentError, "cannot read TLS certificate or key from #{s}" unless File.file?(s) && File.readable?(s)
+    end
+
+    def read_tls_keys!
+      if @tls_certificate_path
+        check_local_path!(@tls_certificate_path)
+        @tls_certificate = File.read(@tls_certificate_path)
       end
-      if @ssl_key
-        @ssl_key_string = File.read(@ssl_key)
+      if @tls_key_path
+        check_local_path!(@tls_key_path)
+        @tls_key         = File.read(@tls_key_path)
       end
+    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_store = @tls_certificate_store if @tls_certificate_store
+
+      ctx.set_params(:verify_mode => OpenSSL::SSL::VERIFY_PEER|OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT) if @verify_peer
 
-      sslctx.cert = OpenSSL::X509::Certificate.new(@ssl_cert_string) if @ssl_cert_string
-      sslctx.key = OpenSSL::PKey::RSA.new(@ssl_key_string) if @ssl_key_string
-      sslctx
+      ctx
     end
 
     def timeout_from(options)

data/lib/bunny/version.rb

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

data/spec/higher_level_api/integration/basic_consume_spec.rb

@@ -76,4 +76,43 @@ describe Bunny::Queue, "#subscribe" do
       ch.close
     end
   end
+
+  20.times do |i|
+    context "with a queue that already has messages (take #{i})" do
+      let(:queue_name) { "bunny.basic_consume#{rand}" }
+
+      it "registers the consumer" do
+        delivered_keys = []
+        delivered_data = []
+
+        ch = connection.create_channel
+        q  = ch.queue(queue_name, :auto_delete => true, :durable => false)
+        x  = ch.default_exchange
+        100.times do
+          x.publish("hello", :routing_key => queue_name)
+        end
+
+        sleep 0.7
+        q.message_count.should be > 50
+
+        t = Thread.new do
+          ch = connection.create_channel
+          q = ch.queue(queue_name, :auto_delete => true, :durable => false)
+          q.subscribe(:exclusive => false, :manual_ack => false) do |delivery_info, properties, payload|
+            delivered_keys << delivery_info.routing_key
+            delivered_data << payload
+          end
+        end
+        t.abort_on_exception = true
+        sleep 0.5
+
+        delivered_keys.should include(queue_name)
+        delivered_data.should include("hello")
+
+        ch.queue(queue_name, :auto_delete => true, :durable => false).message_count.should == 0
+
+        ch.close
+      end
+    end
+  end
 end

data/spec/higher_level_api/integration/consistent_hash_exchange_spec.rb

@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+require "spec_helper"
+
+unless ENV["CI"]
+  describe "x-consistent-hash exchanges" do
+    let(:connection) do
+      c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
+      c.start
+      c
+    end
+
+    after :all do
+      connection.close
+    end
+
+    let(:list) { Range.new(0, 30).to_a.map(&:to_s) }
+
+    let(:n) { 20 }
+    let(:m) { 10_000 }
+
+    it "can be used" do
+      ch   = connection.create_channel
+      body = "сообщение"
+      # requires the consistent hash exchange plugin,
+      # enable it with
+      #
+      # $ [sudo] rabbitmq-plugins enable rabbitmq_consistent_hash_exchange
+      x    = ch.exchange("bunny.stress.concurrent.consumers", :type => "x-consistent-hash", :durable => true)
+
+      qs = []
+
+      q1 = ch.queue("", :exclusive => true).bind(x, :routing_key => "15")
+      q2 = ch.queue("", :exclusive => true).bind(x, :routing_key => "15")
+
+      sleep 1.0
+
+      5.times do |i|
+        m.times do
+          x.publish(body, :routing_key => list.sample)
+        end
+        puts "Published #{(i + 1) * m} messages..."
+      end
+
+      sleep 4.0
+      q1.message_count.should be > 1000
+      q2.message_count.should be > 1000
+
+      ch.close
+    end
+  end
+end

data/spec/higher_level_api/integration/publishing_edge_cases_spec.rb

@@ -44,9 +44,9 @@ describe "Message framing implementation" do
       q  = ch.queue("", :exclusive => true)
       x  = ch.default_exchange
 
-      x.publish("", :routing_key => q.name, :persistent => true)
+      x.publish("", :routing_key => q.name, :persistent => false, :mandatory => true)
 
-      sleep(1)
+      sleep(0.5)
       q.message_count.should == 1
 
       envelope, headers, payload = q.pop
@@ -54,7 +54,7 @@ describe "Message framing implementation" do
       payload.should == ""
 
       headers[:content_type].should == "application/octet-stream"
-      headers[:delivery_mode].should == 2
+      headers[:delivery_mode].should == 1
       headers[:priority].should == 0
 
       ch.close

data/spec/issues/issue100_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+
+describe Bunny::Channel, "#basic_publish" do
+  let(:connection) do
+    c = Bunny.new(:user     => "bunny_gem",
+                  :password => "bunny_password",
+                  :vhost    => "bunny_testbed",
+                  :socket_timeout => 0)
+    c.start
+    c
+  end
+
+  after :all do
+    connection.close if connection.open?
+  end
+
+
+  context "when publishing thousands of messages" do
+    let(:n) { 10_000 }
+    let(:m) { 10 }
+
+    it "successfully publishers them all" do
+      ch = connection.create_channel
+
+      q  = ch.queue("", :exclusive => true)
+      x  = ch.default_exchange
+
+      body = "x" * 1024
+      m.times do |i|
+        n.times do
+          x.publish(body, :routing_key => q.name)
+        end
+        puts "Published #{i * n} messages so far..."
+      end
+
+      q.purge
+      ch.close
+    end
+  end
+end