bunny 0.9.0.pre10 → 0.9.0.pre11

data/lib/bunny/socket.rb

@@ -20,8 +20,15 @@ module Bunny
       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 @eof
+      return nil if @__bunny_socket_eof_flag__
 
       value = ''
       begin
@@ -30,8 +37,9 @@ module Bunny
           break if value.bytesize >= count
         end
       rescue EOFError
-        @eof = true
-      rescue Errno::EAGAIN, Errno::EWOULDBLOCK
+        # @eof will break Rubinius' TCPSocket implementation. MK.
+        @__bunny_socket_eof_flag__ = true
+      rescue Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitReadable
         if IO.select([self], nil, nil, timeout)
           retry
         else
@@ -39,6 +47,32 @@ module Bunny
         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/test_kit.rb

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+module Bunny
+  # Unit, integration and stress testing toolkit
+  class TestKit
+    class << self
+
+      # @return [Integer] Random integer in the range of [a, b]
+      # @api private
+      def random_in_range(a, b)
+        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
+      # @return [String] Message payload of length in the given range, with non-ASCII characters
+      def message_in_kb(a, b, i)
+        s = "Ю#{i}"
+        n = random_in_range(a, b) / s.bytesize
+
+        s * n * 1024
+      end
+
+    end
+  end
+end

data/lib/bunny/transport.rb

@@ -45,6 +45,8 @@ module Bunny
       @connect_timeout    = nil if @connect_timeout == 0
       @disconnect_timeout = @read_write_timeout || @connect_timeout
 
+      @writes_mutex       = Mutex.new
+
       initialize_socket
       connect
     end
@@ -84,13 +86,13 @@ module Bunny
         if @read_write_timeout
           Bunny::Timer.timeout(@read_write_timeout, Bunny::ClientTimeout) do
             if open?
-              @socket.write(data)
+              @writes_mutex.synchronize { @socket.write(data) }
               @socket.flush
             end
           end
         else
           if open?
-            @socket.write(data)
+            @writes_mutex.synchronize { @socket.write(data) }
             @socket.flush
           end
         end
@@ -104,12 +106,12 @@ module Bunny
         end
       end
     end
-    alias send_raw write
 
     # Writes data to the socket without timeout checks
     def write_without_timeout(data)
       begin
-        @socket.write(data)
+        @writes_mutex.synchronize { @socket.write(data) }
+        @socket.flush
       rescue SystemCallError, Bunny::ConnectionError, IOError => e
         close
 
@@ -121,6 +123,31 @@ module Bunny
       end
     end
 
+    # Sends frame to the peer.
+    #
+    # @raise [ConnectionClosedError]
+    # @private
+    def send_frame(frame)
+      if closed?
+        @session.handle_network_failure(ConnectionClosedError.new(frame))
+      else
+        write(frame.encode)
+      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
+        write_without_timeout(frame.encode)
+      end
+    end
+
+
     def close(reason = nil)
       @socket.close unless @socket.closed?
     end
@@ -151,6 +178,14 @@ module Bunny
     # @private
     def read_next_frame(opts = {})
       header    = @socket.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.
+      # type, channel, size = begin
+      #                         AMQ::Protocol::Frame.decode_header(header)
+      #                       rescue AMQ::Protocol::EmptyResponseError => e
+      #                         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)
@@ -166,35 +201,6 @@ module Bunny
     end
 
 
-    # Sends frame to the peer.
-    #
-    # @raise [ConnectionClosedError]
-    # @private
-    def send_frame(frame)
-      if closed?
-        @session.handle_network_failure(ConnectionClosedError.new(frame))
-      else
-        frame.encode_to_array.each do |component|
-          send_raw(component)
-        end
-      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
         s = Bunny::Socket.open(host, port,

data/lib/bunny/version.rb

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

data/profiling/basic_publish/with_4K_messages.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require "rubygems"
+require "bunny"
+require "ruby-prof"
+
+conn = Bunny.new
+conn.start
+
+puts
+puts "-" * 80
+puts "Benchmarking on #{RUBY_DESCRIPTION}"
+
+n  = 50_000
+ch = conn.create_channel
+x  = ch.default_exchange
+s  = "z" * 4096
+
+# warm up the JIT, etc
+puts "Doing a warmup run..."
+16000.times { x.publish(s, :routing_key => "anything") }
+
+# give OS, the server and so on some time to catch
+# up
+sleep 2.0
+
+result = RubyProf.profile do
+  n.times { x.publish(s, :routing_key => "anything") }
+end
+
+printer = RubyProf::FlatPrinter.new(result)
+printer.print(STDOUT, {})

data/spec/higher_level_api/integration/consistent_hash_exchange_spec.rb

@@ -2,7 +2,7 @@
 require "spec_helper"
 
 unless ENV["CI"]
-  describe "x-consistent-hash exchanges" do
+  describe "x-consistent-hash exchange" do
     let(:connection) do
       c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
       c.start
@@ -13,12 +13,11 @@ unless ENV["CI"]
       connection.close
     end
 
-    let(:list) { Range.new(0, 30).to_a.map(&:to_s) }
+    let(:list) { Range.new(0, 6).to_a.map(&:to_s) }
 
-    let(:n) { 20 }
-    let(:m) { 10_000 }
+    let(:m) { 1500 }
 
-    it "can be used" do
+    it "distributes messages between queues bound with the same routing key" do
       ch   = connection.create_channel
       body = "сообщение"
       # requires the consistent hash exchange plugin,
@@ -29,8 +28,8 @@ unless ENV["CI"]
 
       qs = []
 
-      q1 = ch.queue("", :exclusive => true).bind(x, :routing_key => "15")
-      q2 = ch.queue("", :exclusive => true).bind(x, :routing_key => "15")
+      q1 = ch.queue("", :exclusive => true).bind(x, :routing_key => "5")
+      q2 = ch.queue("", :exclusive => true).bind(x, :routing_key => "5")
 
       sleep 1.0
 
@@ -38,12 +37,12 @@ unless ENV["CI"]
         m.times do
           x.publish(body, :routing_key => list.sample)
         end
-        puts "Published #{(i + 1) * m} messages..."
+        puts "Published #{(i + 1) * m} tiny messages..."
       end
 
-      sleep 4.0
-      q1.message_count.should be > 1000
-      q2.message_count.should be > 1000
+      sleep 2.0
+      q1.message_count.should be > 100
+      q2.message_count.should be > 100
 
       ch.close
     end

data/spec/higher_level_api/integration/queue_declare_spec.rb

@@ -96,34 +96,76 @@ describe Bunny::Queue do
   end
 
 
-  context "when queue is declared with additional arguments (e.g. message TTL)" do
+
+  context "when queue is declared with a different set of attributes" do
+    it "raises an exception" do
+      ch   = connection.create_channel
+
+      q = ch.queue("bunny.tests.queues.auto-delete", :auto_delete => true, :durable => false)
+      expect {
+        # force re-declaration
+        ch.queue_declare("bunny.tests.queues.auto-delete", :auto_delete => false, :durable => true)
+      }.to raise_error(Bunny::PreconditionFailed)
+
+      ch.should be_closed
+    end
+  end
+
+
+  context "when queue is declared with message TTL" do
     let(:args) do
+      # in ms
       {"x-message-ttl" => 1000}
     end
 
-    it "declares it with all the arguments provided" do
+    it "causes all messages in it to have a TTL" do
       ch   = connection.create_channel
 
-      q = ch.queue("bunny.tests.queues.with-arguments", :arguments => args)
+      q = ch.queue("bunny.tests.queues.with-arguments.ttl", :arguments => args, :exclusive => true)
       q.arguments.should == args
-      q.delete
+
+      q.publish("xyzzy")
+      sleep 0.1
+
+      q.message_count.should == 1
+      sleep 1.5
+      q.message_count.should == 0
 
       ch.close
     end
   end
 
 
-  context "when queue is declared with a different set of attributes" do
-    it "raises an exception" do
-      ch   = connection.create_channel
+  unless ENV["CI"]
+    # requires RabbitMQ 3.1+
+    context "when queue is declared with bounded length" do
+      let(:n) { 10 }
+      let(:args) do
+        # in ms
+        {"x-max-length" => n}
+      end
 
-      q = ch.queue("bunny.tests.queues.auto-delete", :auto_delete => true, :durable => false)
-      expect {
-        # force re-declaration
-        ch.queue_declare("bunny.tests.queues.auto-delete", :auto_delete => false, :durable => true)
-      }.to raise_error(Bunny::PreconditionFailed)
+      # see http://www.rabbitmq.com/maxlength.html for more info
+      it "causes the queue to be bounded" do
+        ch   = connection.create_channel
 
-      ch.should be_closed
+        q = ch.queue("bunny.tests.queues.with-arguments.max-length", :arguments => args, :exclusive => true)
+        q.arguments.should == args
+
+        (n * 10).times do
+          q.publish("xyzzy")
+        end
+
+        q.message_count.should == n
+        (n * 5).times do
+          q.publish("xyzzy")
+        end
+
+        q.message_count.should == n
+        q.delete
+
+        ch.close
+      end
     end
   end
 end

data/spec/issues/issue100_spec.rb

@@ -1,40 +1,42 @@
 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
+unless ENV["CI"]
+  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
+    after :all do
+      connection.close if connection.open?
+    end
 
 
-  context "when publishing thousands of messages" do
-    let(:n) { 10_000 }
-    let(:m) { 10 }
+    context "when publishing thousands of messages" do
+      let(:n) { 2_000 }
+      let(:m) { 10 }
 
-    it "successfully publishers them all" do
-      ch = connection.create_channel
+      it "successfully publishers them all" do
+        ch = connection.create_channel
 
-      q  = ch.queue("", :exclusive => true)
-      x  = ch.default_exchange
+        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)
+        body = "x" * 1024
+        m.times do |i|
+          n.times do
+            x.publish(body, :routing_key => q.name)
+          end
+          puts "Published #{i * n} 1K messages..."
         end
-        puts "Published #{i * n} messages so far..."
-      end
 
-      q.purge
-      ch.close
+        q.purge
+        ch.close
+      end
     end
   end
 end