bunny 2.0.0.rc1 → 2.0.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7035cf94d8295c49d7e57deb2143be7ed1b6a465
-  data.tar.gz: 0387323f9a4029809fbe05c5160731c2a9839ccc
+  metadata.gz: e0c99fb0a3faf8edcc73da84f74ce724e77b71a1
+  data.tar.gz: 4c50a4aa3b4b6bb70ae4f9f8d4305914c24e9f1b
 SHA512:
-  metadata.gz: 0a4ab1f554f8445a4d7a283ba182a2c6b8244c5371295cd81478c24da0daaf00a71eeb477dfc1bd14dcb22f9b5ef28de938672edc8907a17fae3d0ac07c18b1c
-  data.tar.gz: 68cc7911d99ee0161f3c09383d06f88ba482c4a0ab3e04f21049cdd94bbdac46e108598dde44ebff97a3671994a54679602a44727001363f2770ca8935e922be
+  metadata.gz: 717ee6c9d892e4d930464b2122ffbd2059420553c4b3f3ec670d6b66331d9885feeac96eb0edf7f2da1fcf11ef77bc05e3b2beacfbb7f96a19a7e780b2fb3ea5
+  data.tar.gz: 3b24edbe00fbbb46a20592bb5cc28bc5f00fa6fb05180a5b91405f2534c9c4a8d8e3b0b9ab12e1f6213a501f3cc2cab374e00a3bc3a31ba79281efa7e9e0a8d1

data/.travis.yml

@@ -3,13 +3,11 @@ bundler_args: --without development
 before_script: "./bin/ci/before_build"
 script: "bundle exec rspec -cf documentation spec"
 rvm:
-  - "2.1.0"
+  - "2.2"
+  - "2.1"
   - "2.0"
-  - "1.9.3"
   - "jruby"
-  - "1.9.2"
   - "rbx"
-  - "1.8.7"
 notifications:
   email: michael@rabbitmq.com
 services:
@@ -21,6 +19,4 @@ branches:
 matrix:
   allow_failures:
     - rvm: rbx
-    - rvm: "1.9.2"
-    - rvm: "1.8.7"
     - rvm: jruby

data/ChangeLog.md

@@ -1,4 +1,21 @@
-## Changes between Bunny 1.7.0 and 1.8.0
+## Changes between Bunny 1.7.0 and 2.0.0
+
+Bunny `2.0` doesn't have any breaking API changes
+but drops Ruby 1.8 and 1.9 (both EOL'ed) support,
+hence the version.
+
+### Minimum Required Ruby Version is 2.0
+
+Bunny `2.0` requires Ruby 2.0 or later.
+
+## Non-Blocking Writes
+
+Bunny now uses non-blocking socket writes, uses a reduced
+number of writes for message publishing (frames are batched
+into a single write), and handles TCP back pressure from
+RabbitMQ better.
+
+Contributed by Irina Bednova and Michael Klishin.
 
 ### Reduced Timeout Use
 
@@ -6,7 +23,23 @@
 numerous issues, including starting a new "interruptor" thread per operation,
 which is far from efficient.
 
-Contributed by Joe Eli McIlvain.
+Contributed by Joe Eli McIlvain and Carl Hörberg.
+
+### Capped Number of Connection Recovery Attempts
+
+`:recovery_attempts` is a new option that limits the number of
+connection recovery attempts performed by Bunny. `nil` means
+"no limit".
+
+Contributed by Irina Bednova.
+
+### Bunny::Channel#basic_ack and Related Methods Improvements
+
+`Bunny::Channel#basic_ack`, `Bunny::Channel#basic_nack`, and `Bunny::Channel#basic_reject`
+now adjust delivery tags between connection recoveries, as well as have a default value for
+the second argument.
+
+Contributed by Wayne Conrad.
 
 ### Logger Output Remains Consistent
 

data/Gemfile

@@ -19,8 +19,6 @@ extend Module.new {
   end
 }
 
-gem "SystemTimer", "~> 1.2.3", :platform => :ruby_18
-
 gem "rake", ">= 10.0.4"
 gem "effin_utf8"
 

data/README.md

@@ -48,13 +48,15 @@ Specific examples:
 
 Modern Bunny versions support
 
- * CRuby 2.2, 2.1, 2.0, 1.9.3, and 1.8.7
+ * CRuby 2.2, 2.1, 2.0
  * Rubinius 2.0+
 
 Bunny works sufficiently well on JRuby but there are known
 JRuby bugs that cause high CPU burn. JRuby users should
 use [March Hare](http://rubymarchhare.info).
 
+Bunny `1.7.x` was the last version to support CRuby 1.9.3 and 1.8.7
+
 
 ## Supported RabbitMQ Versions
 

data/lib/bunny/channel.rb

@@ -468,9 +468,7 @@ module Bunny
     # @see http://rubybunny.info/articles/queues.html Queues and Consumers guide
     # @api public
     def reject(delivery_tag, requeue = false)
-      guarding_against_stale_delivery_tags(delivery_tag) do
-        basic_reject(delivery_tag.to_i, requeue)
-      end
+      basic_reject(delivery_tag.to_i, requeue)
     end
 
     # Acknowledges a message. Acknowledged messages are completely removed from the queue.
@@ -481,9 +479,7 @@ module Bunny
     # @see http://rubybunny.info/articles/queues.html Queues and Consumers guide
     # @api public
     def ack(delivery_tag, multiple = false)
-      guarding_against_stale_delivery_tags(delivery_tag) do
-        basic_ack(delivery_tag.to_i, multiple)
-      end
+      basic_ack(delivery_tag.to_i, multiple)
     end
     alias acknowledge ack
 
@@ -498,9 +494,7 @@ module Bunny
     # @see http://rubybunny.info/articles/queues.html Queues and Consumers guide
     # @api public
     def nack(delivery_tag, multiple = false, requeue = false)
-      guarding_against_stale_delivery_tags(delivery_tag) do
-        basic_nack(delivery_tag.to_i, multiple, requeue)
-      end
+      basic_nack(delivery_tag.to_i, multiple, requeue)
     end
 
     # @endgroup
@@ -570,7 +564,7 @@ module Bunny
         opts[:mandatory],
         false,
         @connection.frame_max)
-      @connection.send_frameset_without_timeout(frames, self)
+      @connection.send_frameset(frames, self)
 
       self
     end
@@ -707,11 +701,13 @@ module Bunny
     # @see Bunny::Channel#basic_nack
     # @see http://rubybunny.info/articles/queues.html Queues and Consumers guide
     # @api public
-    def basic_reject(delivery_tag, requeue)
-      raise_if_no_longer_open!
-      @connection.send_frame(AMQ::Protocol::Basic::Reject.encode(@id, delivery_tag, requeue))
+    def basic_reject(delivery_tag, requeue = false)
+      guarding_against_stale_delivery_tags(delivery_tag) do
+        raise_if_no_longer_open!
+        @connection.send_frame(AMQ::Protocol::Basic::Reject.encode(@id, delivery_tag, requeue))
 
-      nil
+        nil
+      end
     end
 
     # Acknowledges a delivery (message).
@@ -727,7 +723,7 @@ module Bunny
     #   ch    = conn.create_channel
     #   q.subscribe do |delivery_info, properties, payload|
     #     # requeue the message
-    #     ch.basic_ack(delivery_info.delivery_tag)
+    #     ch.basic_ack(delivery_info.delivery_tag.to_i)
     #   end
     #
     # @example Ack a message fetched via basic.get
@@ -737,7 +733,7 @@ module Bunny
     #   ch    = conn.create_channel
     #   # we assume the queue exists and has messages
     #   delivery_info, properties, payload = ch.basic_get("bunny.examples.queue3", :manual_ack => true)
-    #   ch.basic_ack(delivery_info.delivery_tag)
+    #   ch.basic_ack(delivery_info.delivery_tag.to_i)
     #
     # @example Ack multiple messages fetched via basic.get
     #   conn  = Bunny.new
@@ -749,16 +745,17 @@ module Bunny
     #   _, _, payload2 = ch.basic_get("bunny.examples.queue3", :manual_ack => true)
     #   delivery_info, properties, payload3 = ch.basic_get("bunny.examples.queue3", :manual_ack => true)
     #   # ack all fetched messages up to payload3
-    #   ch.basic_ack(delivery_info.delivery_tag, true)
+    #   ch.basic_ack(delivery_info.delivery_tag.to_i, true)
     #
     # @see http://rubybunny.info/articles/queues.html Queues and Consumers guide
-    # @see #basic_ack_known_delivery_tag
     # @api public
-    def basic_ack(delivery_tag, multiple)
-      raise_if_no_longer_open!
-      @connection.send_frame(AMQ::Protocol::Basic::Ack.encode(@id, delivery_tag, multiple))
+    def basic_ack(delivery_tag, multiple = false)
+      guarding_against_stale_delivery_tags(delivery_tag) do
+        raise_if_no_longer_open!
+        @connection.send_frame(AMQ::Protocol::Basic::Ack.encode(@id, delivery_tag, multiple))
 
-      nil
+        nil
+      end
     end
 
     # Rejects or requeues messages just like {Bunny::Channel#basic_reject} but can do so
@@ -815,13 +812,15 @@ module Bunny
     # @see http://rubybunny.info/articles/extensions.html RabbitMQ Extensions guide
     # @api public
     def basic_nack(delivery_tag, multiple = false, requeue = false)
-      raise_if_no_longer_open!
-      @connection.send_frame(AMQ::Protocol::Basic::Nack.encode(@id,
-          delivery_tag,
-          multiple,
-          requeue))
+      guarding_against_stale_delivery_tags(delivery_tag) do
+        raise_if_no_longer_open!
+        @connection.send_frame(AMQ::Protocol::Basic::Nack.encode(@id,
+                                                                 delivery_tag,
+                                                                 multiple,
+                                                                 requeue))
 
-      nil
+        nil
+      end
     end
 
     # Registers a consumer for queue. Delivered messages will be handled with the block

data/lib/bunny/cruby/socket.rb

@@ -6,27 +6,24 @@ module Bunny
   #
   # Heavily inspired by Dalli by Mike Perham.
   # @private
-  class Socket < TCPSocket
+  module Socket
     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)
-
-    # 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)
+    READ_RETRY_EXCEPTION_CLASSES = [Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitReadable]
+    WRITE_RETRY_EXCEPTION_CLASSES = [Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitWritable]
 
     def self.open(host, port, options = {})
-      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)
-        end
-        sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_KEEPALIVE, true) if options.fetch(:keepalive, true)
-        sock.options = {:host => host, :port => port}.merge(options)
-        sock
+      socket = ::Socket.tcp(host, port, nil, nil,
+                            connect_timeout: options[:connect_timeout])
+      if ::Socket.constants.include?('TCP_NODELAY') || ::Socket.constants.include?(:TCP_NODELAY)
+        socket.setsockopt(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, true)
       end
+      socket.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_KEEPALIVE, true) if options.fetch(:keepalive, true)
+      socket.extend self
+      socket.options = { :host => host, :port => port }.merge(options)
+      socket
+    rescue Errno::ETIMEDOUT
+      raise ClientTimeout
     end
 
     # Reads given number of bytes with an optional timeout

data/lib/bunny/cruby/ssl_socket.rb

@@ -8,13 +8,8 @@ module Bunny
     # 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)
-
-      # 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)
+      READ_RETRY_EXCEPTION_CLASSES = [Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitReadable]
+      WRITE_RETRY_EXCEPTION_CLASSES = [Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitWritable]
 
       # Reads given number of bytes with an optional timeout
       #

data/lib/bunny/session.rb

@@ -46,11 +46,7 @@ module Bunny
     CONNECT_TIMEOUT   = Transport::DEFAULT_CONNECTION_TIMEOUT
 
     # @private
-    DEFAULT_CONTINUATION_TIMEOUT = if RUBY_VERSION.to_f < 1.9
-                                     8000
-                                   else
-                                     4000
-                                   end
+    DEFAULT_CONTINUATION_TIMEOUT = 15000
 
     # RabbitMQ client metadata
     DEFAULT_CLIENT_PROPERTIES = {
@@ -117,6 +113,8 @@ module Bunny
     # @option connection_string_or_opts [IO, String] :log_file The file or path to use when creating a logger.  Defaults to STDOUT.
     # @option connection_string_or_opts [IO, String] :logfile DEPRECATED: use :log_file instead.  The file or path to use when creating a logger.  Defaults to STDOUT.
     # @option connection_string_or_opts [Integer] :log_level The log level to use when creating a logger.  Defaults to LOGGER::WARN
+    # @option connection_string_or_opts [Boolean] :automatically_recover Should automatically recover from network failures?
+    # @option connection_string_or_opts [Integer] :recovery_attempts Max number of recovery attempts
     #
     # @option optz [String] :auth_mechanism ("PLAIN") Authentication mechanism, PLAIN or EXTERNAL
     # @option optz [String] :locale ("PLAIN") Locale RabbitMQ should use
@@ -156,6 +154,7 @@ module Bunny
                                else
                                  opts[:automatically_recover] || opts[:automatic_recovery]
                                end
+      @recovery_attempts     = opts[:recovery_attempts]
       @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
@@ -665,10 +664,18 @@ module Bunny
       rescue TCPConnectionFailedForAllHosts, TCPConnectionFailed, AMQ::Protocol::EmptyResponseError => e
         @logger.warn "TCP connection failed, reconnecting in #{@network_recovery_interval} seconds"
         sleep @network_recovery_interval
-        retry if recoverable_network_failure?(e)
+        if should_retry_recovery?
+          @recovery_attempts -= 1 if @recovery_attempts
+          retry if recoverable_network_failure?(e)
+        end
       end
     end
 
+    # @private
+    def should_retry_recovery?
+      @recovery_attempts.nil? || @recovery_attempts > 1
+    end
+
     # @private
     def recover_channels
       # default channel is reopened right after connection
@@ -898,7 +905,9 @@ module Bunny
       # If we synchronize on the channel, however, this is both thread safe and pretty fine-grained
       # locking. Note that "single frame" methods do not need this kind of synchronization. MK.
       channel.synchronize do
-        frames.each { |frame| self.send_frame(frame, false) }
+        # see rabbitmq/rabbitmq-server#156
+        data = frames.reduce("") { |acc, frame| acc << frame.encode }
+        @transport.write(data)
         signal_activity!
       end
     end # send_frameset(frames)

data/lib/bunny/timeout.rb

@@ -1,16 +1,5 @@
 module Bunny
-  # Unifies Ruby standard library's Timeout (which is not accurate on
-  # Ruby 1.8) and SystemTimer (the gem)
-  Timeout = if RUBY_VERSION < "1.9"
-              begin
-                require "bunny/system_timer"
-                Bunny::SystemTimer
-              rescue LoadError
-                Timeout
-              end
-            else
-              Timeout
-            end
+  Timeout = ::Timeout
 
   # Backwards compatibility
   # @private

data/lib/bunny/transport.rb

@@ -20,10 +20,10 @@ module Bunny
     #
 
     # Default TCP connection timeout
-    DEFAULT_CONNECTION_TIMEOUT = 25.0
+    DEFAULT_CONNECTION_TIMEOUT = 30.0
 
-    DEFAULT_READ_TIMEOUT  = 5.0
-    DEFAULT_WRITE_TIMEOUT = 5.0
+    DEFAULT_READ_TIMEOUT  = 30.0
+    DEFAULT_WRITE_TIMEOUT = 30.0
 
     attr_reader :session, :host, :port, :socket, :connect_timeout, :read_timeout, :write_timeout, :disconnect_timeout
     attr_reader :tls_context

data/lib/bunny/version.rb

@@ -2,5 +2,5 @@
 
 module Bunny
   # @return [String] Version of the library
-  VERSION = "2.0.0.rc1"
+  VERSION = "2.0.0.rc2"
 end

data/spec/higher_level_api/integration/basic_ack_spec.rb

@@ -23,12 +23,60 @@ describe Bunny::Channel, "#ack" do
       delivery_details, properties, content = q.pop(:manual_ack => true)
 
       ch.ack(delivery_details.delivery_tag, true)
+      ch.close
+
+      ch = connection.create_channel
+      q  = ch.queue("bunny.basic.ack.manual-acks", :exclusive => true)
       expect(q.message_count).to eq 0
+      ch.close
+    end
+  end
 
+  context "with a valid (known) delivery tag (multiple = true)" do
+    it "acknowledges a message" do
+      ch = connection.create_channel
+      q  = ch.queue("bunny.basic.ack.manual-acks", :exclusive => true)
+      x  = ch.default_exchange
+
+      x.publish("bunneth", :routing_key => q.name)
+      x.publish("bunneth", :routing_key => q.name)
+      sleep 0.5
+      expect(q.message_count).to eq 2
+      delivery_details_1, _properties, _content = q.pop(:manual_ack => true)
+      delivery_details_2, _properties, _content = q.pop(:manual_ack => true)
+
+      ch.ack(delivery_details_2.delivery_tag, true)
+      ch.close
+
+      ch = connection.create_channel
+      q  = ch.queue("bunny.basic.ack.manual-acks", :exclusive => true)
+      expect(q.message_count).to eq 0
       ch.close
     end
   end
 
+  context "with a valid (known) delivery tag (multiple = false)" do
+    it "acknowledges a message" do
+      ch = connection.create_channel
+      q  = ch.queue("bunny.basic.ack.manual-acks", :exclusive => true)
+      x  = ch.default_exchange
+
+      x.publish("bunneth", :routing_key => q.name)
+      x.publish("bunneth", :routing_key => q.name)
+      sleep 0.5
+      expect(q.message_count).to eq 2
+      delivery_details_1, _properties, _content = q.pop(:manual_ack => true)
+      delivery_details_2, _properties, _content = q.pop(:manual_ack => true)
+
+      ch.ack(delivery_details_2.delivery_tag, false)
+      ch.close
+
+      ch = connection.create_channel
+      q  = ch.queue("bunny.basic.ack.manual-acks", :exclusive => true)
+      expect(q.message_count).to eq 1
+      ch.close
+    end
+  end
 
   context "with a valid (known) delivery tag and automatic ack mode" do
     it "results in a channel exception" do
@@ -90,8 +138,92 @@ describe Bunny::Channel, "#ack" do
       $stderr = orig_stderr
 
       ch.ack(delivery_details.delivery_tag, true)
+      ch.close
+
+      ch = connection.create_channel
+      q  = ch.queue("bunny.basic.ack.manual-acks", :exclusive => true)
+      expect(q.message_count).to eq 0
+      ch.close
+    end
+  end
+end
+
+describe Bunny::Channel, "#basic_ack" do
+  let(:connection) do
+    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
+    c.start
+    c
+  end
+
+  after :each do
+    connection.close if connection.open?
+  end
+
+  context "with a valid (known) delivery tag (multiple = true)" do
+    it "acknowledges a message" do
+      ch = connection.create_channel
+      q  = ch.queue("bunny.basic.ack.manual-acks", :exclusive => true)
+      x  = ch.default_exchange
+
+      x.publish("bunneth", :routing_key => q.name)
+      x.publish("bunneth", :routing_key => q.name)
+      sleep 0.5
+      expect(q.message_count).to eq 2
+      delivery_details_1, _properties, _content = q.pop(:manual_ack => true)
+      delivery_details_2, _properties, _content = q.pop(:manual_ack => true)
+
+      ch.basic_ack(delivery_details_2.delivery_tag.to_i, true)
+      ch.close
+
+      ch = connection.create_channel
+      q  = ch.queue("bunny.basic.ack.manual-acks", :exclusive => true)
       expect(q.message_count).to eq 0
+      ch.close
+    end
+  end
 
+  context "with a valid (known) delivery tag (multiple = false)" do
+    it "acknowledges a message" do
+      ch = connection.create_channel
+      q  = ch.queue("bunny.basic.ack.manual-acks", :exclusive => true)
+      x  = ch.default_exchange
+
+      x.publish("bunneth", :routing_key => q.name)
+      x.publish("bunneth", :routing_key => q.name)
+      sleep 0.5
+      expect(q.message_count).to eq 2
+      delivery_details_1, _properties, _content = q.pop(:manual_ack => true)
+      delivery_details_2, _properties, _content = q.pop(:manual_ack => true)
+
+      ch.basic_ack(delivery_details_2.delivery_tag.to_i, false)
+      ch.close
+
+      ch = connection.create_channel
+      q  = ch.queue("bunny.basic.ack.manual-acks", :exclusive => true)
+      expect(q.message_count).to eq 1
+      ch.close
+    end
+  end
+
+  context "with a valid (known) delivery tag (multiple = default)" do
+    it "acknowledges a message" do
+      ch = connection.create_channel
+      q  = ch.queue("bunny.basic.ack.manual-acks", :exclusive => true)
+      x  = ch.default_exchange
+
+      x.publish("bunneth", :routing_key => q.name)
+      x.publish("bunneth", :routing_key => q.name)
+      sleep 0.5
+      expect(q.message_count).to eq 2
+      delivery_details_1, _properties, _content = q.pop(:manual_ack => true)
+      delivery_details_2, _properties, _content = q.pop(:manual_ack => true)
+
+      ch.basic_ack(delivery_details_2.delivery_tag.to_i)
+      ch.close
+
+      ch = connection.create_channel
+      q  = ch.queue("bunny.basic.ack.manual-acks", :exclusive => true)
+      expect(q.message_count).to eq 1
       ch.close
     end
   end

data/spec/higher_level_api/integration/basic_nack_spec.rb

@@ -27,9 +27,12 @@ describe Bunny::Channel, "#nack" do
 
       subject.nack(delivery_info.delivery_tag, false, false)
       sleep(0.5)
-      expect(q.message_count).to eq 0
-
       subject.close
+
+      ch = connection.create_channel
+      q = ch.queue("bunny.basic.nack.with-requeue-false", :exclusive => true)
+      expect(q.message_count).to eq 0
+      ch.close
     end
   end
 

data/spec/higher_level_api/integration/basic_publish_spec.rb

@@ -1,94 +1,5 @@
 require "spec_helper"
 
-if RUBY_VERSION <= "1.9"
-  describe "Publishing a message to the default exchange" do
-    let(:connection) do
-      c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
-      c.start
-      c
-    end
-
-    after :each do
-      connection.close if connection.open?
-    end
-
-
-    context "with all default delivery and message properties" do
-      it "routes messages to a queue with the same name as the routing key" do
-        expect(connection).to be_threaded
-        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(1)
-        expect(q.message_count).to eq 4
-
-        ch.close
-      end
-    end
-
-
-    context "with all default delivery and message properties" do
-      it "routes the messages and preserves all the metadata" do
-        expect(connection).to be_threaded
-        ch = connection.create_channel
-
-        q  = ch.queue("", :exclusive => true)
-        x  = ch.default_exchange
-
-        x.publish("xyzzy", :routing_key => q.name, :persistent => true)
-
-        sleep(1)
-        expect(q.message_count).to eq 1
-
-        envelope, headers, payload = q.pop
-
-        expect(payload).to eq "xyzzy"
-
-        expect(headers[:content_type]).to eq "application/octet-stream"
-        expect(headers[:delivery_mode]).to eq 2
-        expect(headers[:priority]).to eq 0
-
-        ch.close
-      end
-    end
-
-
-    context "with all default delivery and message properties on a single-threaded connection" do
-      let(:connection) do
-        c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed", :threaded => false)
-        c.start
-        c
-      end
-
-      it "routes messages to a queue with the same name as the routing key" do
-        expect(connection).not_to be_threaded
-        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(1)
-        expect(q.message_count).to eq 4
-
-        ch.close
-      end
-    end
-  end
-end
-
-
 describe "Published message" do
   let(:connection) do
     c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")

data/spec/higher_level_api/integration/basic_reject_spec.rb

@@ -43,8 +43,11 @@ describe Bunny::Channel, "#reject" do
 
       ch.reject(delivery_info.delivery_tag, false)
       sleep(0.5)
-      expect(q.message_count).to eq 0
+      ch.close
 
+      ch = connection.create_channel
+      q  = ch.queue("bunny.basic.reject.with-requeue-false", :exclusive => true)
+      expect(q.message_count).to eq 0
       ch.close
     end
   end
@@ -72,3 +75,78 @@ describe Bunny::Channel, "#reject" do
     end
   end
 end
+
+describe Bunny::Channel, "#basic_reject" do
+  let(:connection) do
+    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
+    c.start
+    c
+  end
+
+  after :each do
+    connection.close if connection.open?
+  end
+
+  context "with requeue = true" do
+    it "requeues a message" do
+      ch = connection.create_channel
+      q  = ch.queue("bunny.basic.reject.manual-acks", :exclusive => true)
+      x  = ch.default_exchange
+
+      x.publish("bunneth", :routing_key => q.name)
+      sleep(0.5)
+      expect(q.message_count).to eq 1
+      delivery_info, _, _ = q.pop(:manual_ack => true)
+
+      ch.basic_reject(delivery_info.delivery_tag.to_i, true)
+      sleep(0.5)
+      expect(q.message_count).to eq 1
+
+      ch.close
+    end
+  end
+
+  context "with requeue = false" do
+    it "rejects a message" do
+      ch = connection.create_channel
+      q  = ch.queue("bunny.basic.reject.with-requeue-false", :exclusive => true)
+      x  = ch.default_exchange
+
+      x.publish("bunneth", :routing_key => q.name)
+      sleep(0.5)
+      expect(q.message_count).to eq 1
+      delivery_info, _, _ = q.pop(:manual_ack => true)
+
+      ch.basic_reject(delivery_info.delivery_tag.to_i, false)
+      sleep(0.5)
+      ch.close
+
+      ch = connection.create_channel
+      q  = ch.queue("bunny.basic.reject.with-requeue-false", :exclusive => true)
+      expect(q.message_count).to eq 0
+      ch.close
+    end
+  end
+
+  context "with requeue = default" do
+    it "rejects a message" do
+      ch = connection.create_channel
+      q  = ch.queue("bunny.basic.reject.with-requeue-false", :exclusive => true)
+      x  = ch.default_exchange
+
+      x.publish("bunneth", :routing_key => q.name)
+      sleep(0.5)
+      expect(q.message_count).to eq 1
+      delivery_info, _, _ = q.pop(:manual_ack => true)
+
+      ch.basic_reject(delivery_info.delivery_tag.to_i)
+      sleep(0.5)
+      ch.close
+
+      ch = connection.create_channel
+      q  = ch.queue("bunny.basic.reject.with-requeue-false", :exclusive => true)
+      expect(q.message_count).to eq 0
+      ch.close
+    end
+  end
+end

data/spec/higher_level_api/integration/connection_recovery_spec.rb

@@ -52,6 +52,16 @@ unless ENV["CI"]
       end
     end
 
+    def with_recovery_attempts_limited_to(attempts = 3, &block)
+      c = Bunny.new(:recover_from_connection_close => true, :network_recovery_interval => 0.2, :recovery_attempts => attempts)
+      begin
+        c.start
+        block.call(c)
+      ensure
+        c.close
+      end
+    end
+
     def ensure_queue_recovery(ch, q)
       q.purge
       x = ch.default_exchange
@@ -353,5 +363,14 @@ unless ENV["CI"]
         end
       end
     end
+
+    it "tries to recover for a given number of attempts" do
+      with_recovery_attempts_limited_to(2) do |c|
+        close_all_connections!
+        expect(c).to receive(:start).exactly(2).times.and_raise(Bunny::TCPConnectionFailed.new("test"))
+
+        wait_for_recovery
+      end
+    end
   end
 end

data/spec/spec_helper.rb

@@ -14,19 +14,6 @@ require "rabbitmq/http/client"
 require "amq/protocol/version"
 puts "Using Ruby #{RUBY_VERSION}, amq-protocol #{AMQ::Protocol::VERSION}"
 
-#
-# Ruby version-specific
-#
-
-case RUBY_VERSION
-when "1.8.7" then
-  class Array
-    alias sample choice
-  end
-when "1.8.6" then
-  raise "Ruby 1.8.6 is not supported. Sorry, pal. Time to move on beyond One True Ruby. Yes, time flies by."
-end
-
 module RabbitMQ
   module Control
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bunny
 version: !ruby/object:Gem::Version
-  version: 2.0.0.rc1
+  version: 2.0.0.rc2
 platform: ruby
 authors:
 - Chris Duncan
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-12 00:00:00.000000000 Z
+date: 2015-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: amq-protocol
@@ -128,7 +128,6 @@ files:
 - lib/bunny/session.rb
 - lib/bunny/socket.rb
 - lib/bunny/ssl_socket.rb
-- lib/bunny/system_timer.rb
 - lib/bunny/test_kit.rb
 - lib/bunny/timeout.rb
 - lib/bunny/transport.rb
@@ -212,7 +211,6 @@ files:
 - spec/unit/concurrent/condition_spec.rb
 - spec/unit/concurrent/linked_continuation_queue_spec.rb
 - spec/unit/concurrent/synchronized_sorted_set_spec.rb
-- spec/unit/system_timer_spec.rb
 - spec/unit/version_delivery_tag_spec.rb
 homepage: http://rubybunny.info
 licenses:
@@ -315,6 +313,5 @@ test_files:
 - spec/unit/concurrent/condition_spec.rb
 - spec/unit/concurrent/linked_continuation_queue_spec.rb
 - spec/unit/concurrent/synchronized_sorted_set_spec.rb
-- spec/unit/system_timer_spec.rb
 - spec/unit/version_delivery_tag_spec.rb
 has_rdoc: true

data/lib/bunny/system_timer.rb

@@ -1,20 +0,0 @@
-# -*- encoding: utf-8; mode: ruby -*-
-
-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 = nil)
-      if seconds
-        ::SystemTimer.timeout_after(seconds, exception) do
-          yield
-        end
-      else
-        yield
-      end
-    end
-  end # SystemTimer
-end # Bunny

data/spec/unit/system_timer_spec.rb

@@ -1,10 +0,0 @@
-require "spec_helper"
-
-if RUBY_VERSION.to_f < 1.9
-  describe Bunny::SystemTimer do
-    it 'supports being called with a single argument' do
-      expect {Bunny::SystemTimer::timeout(1) {}}.not_to raise_error
-      expect {Bunny::SystemTimer::timeout(1, nil) {}}.not_to raise_error
-    end
-  end
-end