bunny 0.9.0.pre13 → 0.9.0.rc1

data/lib/bunny/socket.rb

@@ -5,6 +5,7 @@ module Bunny
   # fully.
   #
   # Heavily inspired by Dalli by Mike Perham.
+  # @private
   class Socket < TCPSocket
     attr_accessor :options
 

data/lib/bunny/ssl_socket.rb

@@ -4,9 +4,24 @@ 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 @eof
+        return nil if @__bunny_socket_eof_flag__
 
         value = ''
         begin
@@ -14,10 +29,19 @@ module Bunny
             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
+        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

data/lib/bunny/system_timer.rb

@@ -5,6 +5,8 @@ require "system_timer"
 module Bunny
   # Used for Ruby before 1.9
   class SystemTimer
+    # Executes a block of code, raising if the execution does not finish
+    # in the alloted period of time, in seconds.
     def self.timeout(seconds, exception)
       if seconds
         ::SystemTimer.timeout_after(seconds, exception) do

data/lib/bunny/test_kit.rb

@@ -10,10 +10,11 @@ module Bunny
         Range.new(a, b).to_a.sample
       end
 
-      # @param  [Integer] Lower bound of message size, in KB
-      # @param  [Integer] Upper bound of message size, in KB
-      # @param  [Integer] Random number to use in message generation
+      # @param  [Integer] a Lower bound of message size, in KB
+      # @param  [Integer] b Upper bound of message size, in KB
+      # @param  [Integer] i Random number to use in message generation
       # @return [String] Message payload of length in the given range, with non-ASCII characters
+      # @api public
       def message_in_kb(a, b, i)
         s = "Ю#{i}"
         n = random_in_range(a, b) / s.bytesize

data/lib/bunny/transport.rb

@@ -11,6 +11,7 @@ require "bunny/exceptions"
 require "bunny/socket"
 
 module Bunny
+  # @private
   class Transport
 
     #
@@ -23,6 +24,7 @@ module Bunny
 
 
     attr_reader :session, :host, :port, :socket, :connect_timeout, :read_write_timeout, :disconnect_timeout
+    attr_reader :tls_context
 
     def initialize(session, host, port, opts)
       @session        = session
@@ -37,6 +39,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]
+      @tls_ca_certificates   = opts.fetch(:tls_ca_certificates, [])
       @verify_peer           = opts[:verify_ssl] || opts[:verify_peer]
 
       @read_write_timeout = opts[:socket_timeout] || 3
@@ -46,9 +49,6 @@ module Bunny
       @disconnect_timeout = @read_write_timeout || @connect_timeout
 
       @writes_mutex       = Mutex.new
-
-      initialize_socket
-      connect
     end
 
 
@@ -76,6 +76,10 @@ module Bunny
       end
     end
 
+    def configure_socket(&block)
+      block.call(@socket)
+    end
+
 
     # Writes data to the socket. If read/write timeout was specified, Bunny::ClientTimeout will be raised
     # if the operation times out.
@@ -149,7 +153,7 @@ module Bunny
 
 
     def close(reason = nil)
-      @socket.close unless @socket.closed?
+      @socket.close if @socket && !@socket.closed?
     end
 
     def open?
@@ -218,21 +222,6 @@ module Bunny
       raise ConnectionTimeout.new("#{host}:#{port} is unreachable") if !reacheable?(host, port, timeout)
     end
 
-
-    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
         s = Bunny::Timer.timeout(@connect_timeout, ConnectionTimeout) do
@@ -254,12 +243,26 @@ module Bunny
       @socket
     end
 
+    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 wrap_in_tls_socket(socket)
       read_tls_keys!
 
-      ctx = initialize_tls_context(OpenSSL::SSL::SSLContext.new(@opts.fetch(:tls_protocol, DEFAULT_TLS_PROTOCOL)))
+      @tls_context = initialize_tls_context(OpenSSL::SSL::SSLContext.new)
 
-      s = Bunny::SSLSocket.new(socket, ctx)
+      s = Bunny::SSLSocket.new(socket, @tls_context)
       s.sync_close = true
       s
     end
@@ -280,15 +283,28 @@ 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_store = @tls_certificate_store if @tls_certificate_store
-
+      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
+
+      # 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))
       ctx.set_params(:verify_mode => OpenSSL::SSL::VERIFY_PEER|OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT) if @verify_peer
 
       ctx
     end
 
+    def initialize_tls_certificate_store(certs)
+      OpenSSL::X509::Store.new.tap do |store|
+        certs.each { |path| store.add_file(path) }
+      end
+    end
+
     def timeout_from(options)
       options[:connect_timeout] || options[:connection_timeout] || options[:timeout] || DEFAULT_CONNECTION_TIMEOUT
     end

data/lib/bunny/version.rb

@@ -1,5 +1,6 @@
 # encoding: utf-8
 
 module Bunny
-  VERSION = "0.9.0.pre13"
+  # @return [String] Version of the library
+  VERSION = "0.9.0.rc1"
 end

data/spec/compatibility/queue_declare_spec.rb

@@ -7,6 +7,10 @@ describe Bunny::Queue, "backwards compatibility API" do
     c
   end
 
+  after :all do
+    connection.close if connection.open?
+  end
+
   context "when queue name is specified" do
     let(:name) { "a queue declared at #{Time.now.to_i}" }
 

data/spec/compatibility/queue_declare_with_default_channel_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+
+describe Bunny::Session do
+  let(:connection) do
+    c = Bunny.new
+    c.start
+    c
+  end
+
+  after :all do
+    connection.close if connection.open?
+  end
+
+  it "proxies #queue to the pre-opened channel for backwards compatibility" do
+    q = connection.queue("", :exclusive => true)
+    q.name.should =~ /^amq.gen/
+  end
+
+  it "proxies #fanout to the pre-opened channel for backwards compatibility" do
+    x = connection.fanout("amq.fanout")
+    x.name.should == "amq.fanout"
+  end
+
+  it "proxies #topic to the pre-opened channel for backwards compatibility" do
+    x = connection.topic("amq.topic")
+    x.name.should == "amq.topic"
+  end
+
+  it "proxies #direct to the pre-opened channel for backwards compatibility" do
+    x = connection.topic("amq.direct")
+    x.name.should == "amq.direct"
+  end
+end

data/spec/higher_level_api/integration/basic_get_spec.rb

@@ -30,6 +30,25 @@ describe Bunny::Queue, "#pop" do
   end
 
 
+  context "with all defaults and a timeout that is never hit" do
+    it "fetches a messages which is automatically acknowledged" do
+      ch = connection.create_channel
+
+      q  = ch.queue("", :exclusive => true)
+      x  = ch.default_exchange
+
+      x.publish("xyzzy", :routing_key => q.name)
+
+      sleep(0.5)
+      delivery_info, properties, content = q.pop_waiting(:timeout => 1.0)
+      content.should == "xyzzy"
+      q.message_count.should == 0
+
+      ch.close
+    end
+  end
+
+
   context "with an empty queue" do
     it "returns an empty response" do
       ch = connection.create_channel
@@ -44,4 +63,20 @@ describe Bunny::Queue, "#pop" do
       ch.close
     end
   end
+
+
+  context "with an empty queue and a timeout" do
+    it "raises an exception" do
+      ch = connection.create_channel
+
+      q  = ch.queue("", :exclusive => true)
+      q.purge
+
+      lambda {
+        _, _, content = q.pop_waiting(:timeout => 0.5)
+      }.should raise_error(Timeout::Error)
+
+      ch.close
+    end
+  end
 end

data/spec/higher_level_api/integration/basic_nack_spec.rb

@@ -34,7 +34,25 @@ describe Bunny::Channel, "#nack" do
   end
 
   context "with multiple = true" do
-    it "rejects multiple messages"
+    it "rejects multiple messages" do
+q = subject.queue("bunny.basic.nack.with-requeue-true-multi-true", :exclusive => true)
+      x = subject.default_exchange
+
+      3.times do
+        x.publish("bunneth", :routing_key => q.name)
+      end
+      sleep(0.5)
+      q.message_count.should == 3
+      _, _, _ = q.pop(:ack => true)
+      _, _, _ = q.pop(:ack => true)
+      delivery_info, _, content = q.pop(:ack => true)
+
+      subject.nack(delivery_info.delivery_tag, true, true)
+      sleep(0.5)
+      q.message_count.should == 3
+
+      subject.close
+    end
   end
 
 

data/spec/higher_level_api/integration/connection_spec.rb

@@ -62,6 +62,11 @@ describe Bunny::Session do
       Bunny.new
     end
 
+    it "provides a way to fine tune socket options" do
+      subject.start
+      subject.transport.socket.should respond_to(:setsockopt)
+    end
+
     it "successfully negotiates the connection" do
       subject.start
       subject.should be_connected

data/spec/higher_level_api/integration/queue_unbind_spec.rb

@@ -12,7 +12,20 @@ describe Bunny::Queue, "bound to an exchange" do
   end
 
 
-  it "can be unbound from an exchange it was bound to"
+  it "can be unbound from an exchange it was bound to" do
+    ch = connection.create_channel
+    x  = ch.fanout("amq.fanout")
+    q  = ch.queue("", :exclusive => true).bind(x)
+
+    x.publish("")
+    sleep 0.3
+    q.message_count.should == 1
+
+    q.unbind(x)
+
+    x.publish("")
+    q.message_count.should == 1
+  end
 end
 
 
@@ -29,5 +42,13 @@ describe Bunny::Queue, "NOT bound to an exchange" do
   end
 
 
-  it "cannot be unbound (raises a channel error)"
+  it "cannot be unbound (raises a channel error)" do
+    ch = connection.create_channel
+    x  = ch.fanout("amq.fanout")
+    q  = ch.queue("", :exclusive => true)
+
+    lambda {
+      q.unbind(x)
+    }.should raise_error(Bunny::NotFound, /no binding/)
+  end
 end

data/spec/higher_level_api/integration/tls_connection_spec.rb

@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+require "spec_helper"
+
+unless ENV["CI"]
+  describe "TLS connection to RabbitMQ" do
+    let(:connection) do
+      c = Bunny.new(:user     => "bunny_gem",
+                    :password => "bunny_password",
+                    :vhost    => "bunny_testbed",
+                    :tls                   => true,
+                    :tls_cert              => "spec/tls/client_cert.pem",
+                    :tls_key               => "spec/tls/client_key.pem",
+                    :tls_ca_certificates   => ["./spec/tls/cacert.pem"])
+      c.start
+      c
+    end
+
+    after :all do
+      connection.close
+    end
+
+    it "provides the same API as a regular connection" do
+      ch = connection.create_channel
+
+      q  = ch.queue("", :exclusive => true)
+      x  = ch.default_exchange
+
+      x.publish("xyzzy", :routing_key => q.name).
+        publish("xyzzy", :routing_key => q.name).
+        publish("xyzzy", :routing_key => q.name).
+        publish("xyzzy", :routing_key => q.name)
+
+      sleep 0.5
+      q.message_count.should == 4
+
+      i = 0
+      q.subscribe do |delivery_info, _, payload|
+        i += 1
+      end
+      sleep 1.0
+      i.should == 4
+      q.message_count.should == 0
+
+      ch.close
+    end
+  end
+end

data/spec/lower_level_api/integration/basic_cancel_spec.rb

@@ -57,6 +57,13 @@ describe Bunny::Channel, "#basic_cancel" do
   end
 
   context "when the given consumer tag is invalid (was never registered)" do
-    it "causes a channel error"
+    it "DOES NOT cause a channel error" do
+      ch = connection.create_channel
+
+      # RabbitMQ 3.1 does not raise an exception w/ unknown consumer tag. MK.
+      ch.basic_cancel("878798s7df89#{rand}#{Time.now.to_i}")
+
+      ch.close
+    end
   end
 end