bunny 0.9.0.pre9 → 0.9.0.pre10

data/.ruby-version

@@ -0,0 +1 @@
+1.9.3@amqp

data/ChangeLog.md

@@ -1,5 +1,48 @@
+## Changes between Bunny 0.9.0.pre9 and 0.9.0.pre10
+
+This release contains a **breaking API change**.
+
+### Explicitly Closed Sockets
+
+Bunny now will correctly close the socket previous connection had
+when recovering from network issues.
+
+
+### Bunny::Exception Now Extends StandardError
+
+`Bunny::Exception` now inherits from `StandardError` and not `Exception`.
+
+Naked rescue like this
+
+``` ruby
+begin
+  # ...
+rescue => e
+  # ...
+end
+```
+
+catches only descendents of `StandardError`. Most people don't
+know this and this is a very counter-intuitive practice, but
+apparently there is code out there that can't be changed that
+depends on this behavior.
+
+This is a **breaking API change**.
+
+
+
 ## Changes between Bunny 0.9.0.pre8 and 0.9.0.pre9
 
+### Bunny::Session#start Now Returns a Session
+
+`Bunny::Session#start` now returns a session instead of the default channel
+(which wasn't intentional, default channel is a backwards-compatibility implementation
+detail).
+
+`Bunny::Session#start` also no longer leaves dead threads behind if called multiple
+times on the same connection.
+
+
 ### More Reliable Heartbeat Sender
 
 Heartbeat sender no longer slips into an infinite loop if it encounters an exception.

data/Gemfile

@@ -21,7 +21,7 @@ extend Module.new {
 
 gem "SystemTimer", "1.2", :platform => :ruby_18
 
-gem "rake"
+gem "rake", ">= 10.0.4"
 gem "effin_utf8"
 
 group :development do
@@ -30,7 +30,7 @@ group :development do
 end
 
 group :test do
-  gem "rspec", "~> 2.8.0"
+  gem "rspec", ">= 2.13.0"
 end
 
 gemspec

data/README.md

@@ -7,7 +7,7 @@ features and is free of many limitations of earlier versions.
 
 ## Supported Ruby Versions
 
-Bunny 0.9 and more recent versions support Ruby 1.9.3, 1.9.2, JRuby 1.7, Rubinius 2.0 and 1.8.7.
+Bunny 0.9 and more recent versions support Ruby 1.9.3, 1.9.2, 2.0, JRuby 1.7, Rubinius 2.0 and 1.8.7.
 
 
 ## Supported RabbitMQ Versions
@@ -33,10 +33,12 @@ To install Bunny 0.9.x with RubyGems:
 gem install bunny --pre
 ```
 
+the most recent 0.9.x version is `0.9.0.pre10`.
+
 To use Bunny 0.9.x in a project managed with Bundler:
 
 ``` ruby
-gem "bunny", ">= 0.9.0.pre8" # optionally: , :git => "git://github.com/ruby-amqp/bunny.git", :branch => "master"
+gem "bunny", ">= 0.9.0.pre10" # optionally: , :git => "git://github.com/ruby-amqp/bunny.git", :branch => "master"
 ```
 
 

data/bunny.gemspec

@@ -29,7 +29,7 @@ Gem::Specification.new do |s|
     map { |mail| Base64.decode64(mail) }
 
   # Dependencies
-  s.add_dependency "amq-protocol", ">= 1.2.0"
+  s.add_dependency "amq-protocol", ">= 1.4.0"
 
   # Files.
   s.has_rdoc = true

data/lib/bunny/channel.rb

@@ -11,6 +11,12 @@ require "bunny/delivery_info"
 require "bunny/return_info"
 require "bunny/message_properties"
 
+if defined?(JRUBY_VERSION)
+  require "bunny/concurrent/linked_continuation_queue"
+else
+  require "bunny/concurrent/continuation_queue"
+end
+
 module Bunny
   # ## What are AMQP channels
   #
@@ -169,9 +175,8 @@ module Bunny
 
       @unconfirmed_set_mutex = Mutex.new
 
-      @continuations           = ::Queue.new
-      @confirms_continuations  = ::Queue.new
-      @basic_get_continuations = ::Queue.new
+      self.reset_continuations
+
       # threads awaiting on continuations. Used to unblock
       # them when network connection goes down so that busy loops
       # that perform synchronous operations can work. MK.
@@ -1735,5 +1740,25 @@ module Bunny
     def raise_if_no_longer_open!
       raise ChannelAlreadyClosed.new("cannot use a channel that was already closed! Channel id: #{@id}", self) if closed?
     end
-  end
-end
+
+    # @api private
+    def reset_continuations
+      @continuations           = new_continuation
+      @confirms_continuations  = new_continuation
+      @basic_get_continuations = new_continuation
+    end
+
+
+    if defined?(JRUBY_VERSION)
+      # @api private
+      def new_continuation
+        Concurrent::LinkedContinuationQueue.new
+      end
+    else
+      # @api private
+      def new_continuation
+        Concurrent::ContinuationQueue.new
+      end
+    end # if defined?
+  end # Channel
+end # Bunny

data/lib/bunny/exceptions.rb

@@ -1,5 +1,5 @@
 module Bunny
-  class Exception < ::Exception
+  class Exception < ::StandardError
   end
 
   class NetworkFailure < Exception

data/lib/bunny/session.rb

@@ -171,15 +171,23 @@ module Bunny
       @status        = :connecting
       self.reset_continuations
 
-      self.initialize_transport
+      begin
+        # close existing transport if we have one,
+        # to not leak sockets
+        self.maybe_close_transport
+        self.initialize_transport
 
-      self.init_connection
-      self.open_connection
+        self.init_connection
+        self.open_connection
 
-      @event_loop = nil
-      self.start_main_loop if @threaded
+        @event_loop = nil
+        self.start_main_loop if @threaded
 
-      @default_channel = self.create_channel
+        @default_channel = self.create_channel
+      rescue Exception => e
+        @status = :not_connected
+        raise e
+      end
 
       self
     end
@@ -733,6 +741,11 @@ module Bunny
       @transport = Transport.new(self, @host, @port, @opts.merge(:session_thread => Thread.current))
     end
 
+    # @api private
+    def maybe_close_transport
+      @transport.close if @transport
+    end
+
     # Sends AMQ protocol header (also known as preamble).
     # @api private
     def send_preamble

data/lib/bunny/version.rb

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

data/spec/higher_level_api/integration/connection_spec.rb

@@ -338,4 +338,37 @@ describe Bunny::Session do
       subject.password.should == password
     end
   end
+
+
+  context "initialized with a disconnected host" do
+    subject do
+      described_class.new(:port => 38000)
+    end
+
+    it "fails to connect" do
+      lambda do
+        subject.start
+      end.should raise_error(Bunny::TCPConnectionFailed)
+    end
+
+    it "is not connected" do
+      begin
+        subject.start
+      rescue Bunny::TCPConnectionFailed => e
+        true
+      end
+
+      subject.status.should == :not_connected
+    end
+
+    it "is not open" do
+      begin
+        subject.start
+      rescue Bunny::TCPConnectionFailed => e
+        true
+      end
+
+      subject.should_not be_open
+    end
+  end
 end

data/spec/stress/channel_open_stress_spec.rb

@@ -1,48 +1,50 @@
 require "spec_helper"
 
-describe "Rapidly opening and closing lots of channels" do
-  let(:connection) do
-    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed", :automatic_recovery => false)
-    c.start
-    c
-  end
+unless ENV["CI"]
+  describe "Rapidly opening and closing lots of channels" do
+    let(:connection) do
+      c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed", :automatic_recovery => false)
+      c.start
+      c
+    end
 
-  after :all do
-    connection.close
-  end
+    after :all do
+      connection.close
+    end
 
-  context "in a single-threaded scenario" do
-    let(:n) { 500 }
+    context "in a single-threaded scenario" do
+      let(:n) { 500 }
 
-    it "works correctly" do
-      xs = Array.new(n) { connection.create_channel }
-      puts "Opened #{n} channels"
+      it "works correctly" do
+        xs = Array.new(n) { connection.create_channel }
+        puts "Opened #{n} channels"
 
-      xs.size.should == n
-      xs.each do |ch|
-        ch.close
+        xs.size.should == n
+        xs.each do |ch|
+          ch.close
+        end
       end
     end
-  end
 
-  context "in a multi-threaded scenario" do
-    # actually, on MRI values greater than ~100 will eventually cause write
-    # operations to fail with a timeout (1 second is not enough)
-    # which will cause recovery to re-acquire @channel_mutex in Session.
-    # Because Ruby's mutexes are not re-entrant, it will raise a ThreadError.
-    #
-    # But this already demonstrates that within these platform constraints,
-    # Bunny is safe to use in such scenarios.
-    let(:n) { 50 }
-
-    it "works correctly" do
-      n.times do
-        t = Thread.new do
-          ch = connection.create_channel
-
-          ch.close
+    context "in a multi-threaded scenario" do
+      # actually, on MRI values greater than ~100 will eventually cause write
+      # operations to fail with a timeout (1 second is not enough)
+      # which will cause recovery to re-acquire @channel_mutex in Session.
+      # Because Ruby's mutexes are not re-entrant, it will raise a ThreadError.
+      #
+      # But this already demonstrates that within these platform constraints,
+      # Bunny is safe to use in such scenarios.
+      let(:n) { 20 }
+
+      it "works correctly" do
+        n.times do
+          t = Thread.new do
+            ch = connection.create_channel
+
+            ch.close
+          end
+          t.abort_on_exception = true
         end
-        t.abort_on_exception = true
       end
     end
   end

data/spec/stress/channel_open_stress_with_single_threaded_connection_spec.rb

@@ -1,48 +1,49 @@
 require "spec_helper"
 
-describe "Rapidly opening and closing lots of channels on a non-threaded connection" do
-  let(:connection) do
-    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed", :automatic_recovery => false, :threaded => false)
-    c.start
-    c
-  end
+unless ENV["CI"]
+  describe "Rapidly opening and closing lots of channels on a non-threaded connection" do
+    let(:connection) do
+      c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed", :automatic_recovery => false, :threaded => false)
+      c.start
+      c
+    end
 
-  after :all do
-    connection.close
-  end
+    after :all do
+      connection.close
+    end
 
-  context "in a single-threaded scenario" do
-    let(:n) { 500 }
+    context "in a single-threaded scenario" do
+      let(:n) { 500 }
 
-    it "works correctly" do
-      xs = Array.new(n) { connection.create_channel }
-      puts "Opened #{n} channels"
+      it "works correctly" do
+        xs = Array.new(n) { connection.create_channel }
 
-      xs.size.should == n
-      xs.each do |ch|
-        ch.close
+        xs.size.should == n
+        xs.each do |ch|
+          ch.close
+        end
       end
     end
-  end
 
-  context "in a multi-threaded scenario" do
-    # actually, on MRI values greater than ~100 will eventually cause write
-    # operations to fail with a timeout (1 second is not enough)
-    # which will cause recovery to re-acquire @channel_mutex in Session.
-    # Because Ruby's mutexes are not re-entrant, it will raise a ThreadError.
-    #
-    # But this already demonstrates that within these platform constraints,
-    # Bunny is safe to use in such scenarios.
-    let(:n) { 50 }
-
-    it "works correctly" do
-      n.times do
-        t = Thread.new do
-          ch = connection.create_channel
-
-          ch.close
+    context "in a multi-threaded scenario" do
+      # actually, on MRI values greater than ~100 will eventually cause write
+      # operations to fail with a timeout (1 second is not enough)
+      # which will cause recovery to re-acquire @channel_mutex in Session.
+      # Because Ruby's mutexes are not re-entrant, it will raise a ThreadError.
+      #
+      # But this already demonstrates that within these platform constraints,
+      # Bunny is safe to use in such scenarios.
+      let(:n) { 20 }
+
+      it "works correctly" do
+        n.times do
+          t = Thread.new do
+            ch = connection.create_channel
+
+            ch.close
+          end
+          t.abort_on_exception = true
         end
-        t.abort_on_exception = true
       end
     end
   end

data/spec/stress/concurrent_consumers_stress_spec.rb

@@ -1,66 +1,68 @@
 # -*- coding: utf-8 -*-
 require "spec_helper"
 
-describe "Concurrent consumers sharing a connection" do
-  let(:connection) do
-    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed", :automatic_recovery => false)
-    c.start
-    c
-  end
+unless ENV["CI"]
+  describe "Concurrent consumers sharing a connection" do
+    let(:connection) do
+      c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed", :automatic_recovery => false)
+      c.start
+      c
+    end
 
-  after :all do
-    connection.close
-  end
+    after :all do
+      connection.close
+    end
 
-  def any_not_drained?(qs)
-    qs.any? { |q| !q.message_count.zero? }
-  end
+    def any_not_drained?(qs)
+      qs.any? { |q| !q.message_count.zero? }
+    end
 
-  context "when publishing thousands of messages over 128K in size" do
-    let(:colors) { ["red", "blue", "white"] }
+    context "when publishing thousands of messages over 128K in size" do
+      let(:colors) { ["red", "blue", "white"] }
 
-    let(:n) { 32 }
-    let(:m) { 1000 }
+      let(:n) { 32 }
+      let(:m) { 1000 }
 
-    it "successfully drain all queues" do
-      ch   = connection.create_channel
-      body = "абвг"
-      x    = ch.topic("bunny.stress.concurrent.consumers.topic", :durable => true)
+      it "successfully drain all queues" do
+        ch   = connection.create_channel
+        body = "абвг"
+        x    = ch.topic("bunny.stress.concurrent.consumers.topic", :durable => true)
 
-      chs  = {}
-      n.times do |i|
-        chs[i] = connection.create_channel
-      end
-      qs   = []
+        chs  = {}
+        n.times do |i|
+          chs[i] = connection.create_channel
+        end
+        qs   = []
 
-      n.times do |i|
-        t = Thread.new do
-          cht = chs[i]
+        n.times do |i|
+          t = Thread.new do
+            cht = chs[i]
 
-          q = cht.queue("", :exclusive => true)
-          q.bind(x.name, :routing_key => colors.sample).subscribe do |delivery_info, meta, payload|
-            # no-op
+            q = cht.queue("", :exclusive => true)
+            q.bind(x.name, :routing_key => colors.sample).subscribe do |delivery_info, meta, payload|
+              # no-op
+            end
+            qs << q
           end
-          qs << q
+          t.abort_on_exception = true
         end
-        t.abort_on_exception = true
-      end
 
-      sleep 1.0
+        sleep 1.0
 
-      5.times do |i|
-        m.times do
-          x.publish(body, :routing_key => colors.sample)
+        5.times do |i|
+          m.times do
+            x.publish(body, :routing_key => colors.sample)
+          end
+          puts "Published #{(i + 1) * m} messages..."
         end
-        puts "Published #{(i + 1) * m} messages..."
-      end
 
-      while any_not_drained?(qs)
-        sleep 1.0
-      end
-      puts "Drained all the queues..."
+        while any_not_drained?(qs)
+          sleep 1.0
+        end
+        puts "Drained all the queues..."
 
-      ch.close
+        ch.close
+      end
     end
   end
 end

data/spec/stress/concurrent_publishers_stress_spec.rb

@@ -1,58 +1,60 @@
 # -*- coding: utf-8 -*-
 require "spec_helper"
 
-describe "Concurrent publishers sharing a connection" do
-  let(:connection) do
-    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed", :automatically_recover => false)
-    c.start
-    c
-  end
+unless ENV["CI"]
+  describe "Concurrent publishers sharing a connection" do
+    let(:connection) do
+      c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed", :automatically_recover => false)
+      c.start
+      c
+    end
 
-  after :all do
-    connection.close
-  end
+    after :all do
+      connection.close
+    end
 
-  let(:n) { 32 }
-  let(:m) { 1000 }
+    let(:n) { 32 }
+    let(:m) { 1000 }
 
-  it "successfully finish publishing" do
-    ch = connection.create_channel
+    it "successfully finish publishing" do
+      ch = connection.create_channel
 
-    q    = ch.queue("", :exclusive => true)
-    body = "сообщение"
+      q    = ch.queue("", :exclusive => true)
+      body = "сообщение"
 
-    # let the queue name be sent back by RabbitMQ
-    sleep 0.25
+      # let the queue name be sent back by RabbitMQ
+      sleep 0.25
 
-    chs  = {}
-    n.times do |i|
-      chs[i] = connection.create_channel
-    end
+      chs  = {}
+      n.times do |i|
+        chs[i] = connection.create_channel
+      end
 
-    ts = []
+      ts = []
 
-    n.times do |i|
-      t = Thread.new do
-        cht = chs[i]
-        x   = ch.default_exchange
+      n.times do |i|
+        t = Thread.new do
+          cht = chs[i]
+          x   = ch.default_exchange
 
-        5.times do |i|
-          m.times do
-            x.publish(body, :routing_key => q.name)
+          5.times do |i|
+            m.times do
+              x.publish(body, :routing_key => q.name)
+            end
+            puts "Published #{(i + 1) * m} messages..."
           end
-          puts "Published #{(i + 1) * m} messages..."
         end
+        t.abort_on_exception = true
+
+        ts << t
       end
-      t.abort_on_exception = true
 
-      ts << t
-    end
+      ts.each do |t|
+        t.join
+      end
 
-    ts.each do |t|
-      t.join
+      sleep 4.0
+      q.message_count.should == 5 * n * m
     end
-
-    sleep 4.0
-    q.message_count.should == 5 * n * m
   end
 end

data/spec/unit/concurrent/condition_spec.rb

@@ -45,27 +45,29 @@ describe Bunny::Concurrent::Condition do
   end
 
   describe "#notify_all" do
+    let(:n) { 20 }
+
     it "notifies all the threads waiting on the latch" do
       condition = described_class.new
       @xs        = []
 
-      t1 = Thread.new do
-        condition.wait
-        @xs << :notified1
-      end
-      t1.abort_on_exception = true
-
-      t2 = Thread.new do
-        condition.wait
-        @xs << :notified2
+      n.times do |i|
+        t = Thread.new do
+          condition.wait
+          @xs << "notified#{i + 1}".to_sym
+        end
+        t.abort_on_exception = true
       end
-      t2.abort_on_exception = true
 
       sleep 0.5
       condition.notify_all
       sleep 0.5
-      @xs.should include(:notified1)
-      @xs.should include(:notified2)
+
+      n.times do |i|
+        item = "notified#{i + 1}".to_sym
+
+        @xs.should include(item)
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bunny
 version: !ruby/object:Gem::Version
-  version: 0.9.0.pre9
+  version: 0.9.0.pre10
   prerelease: 6
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-04-22 00:00:00.000000000 Z
+date: 2013-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: amq-protocol
@@ -21,13 +21,13 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.2.0
+        version: 1.4.0
     none: false
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.2.0
+        version: 1.4.0
     none: false
   prerelease: false
   type: :runtime
@@ -50,6 +50,7 @@ extra_rdoc_files:
 files:
 - ".gitignore"
 - ".rspec"
+- ".ruby-version"
 - ".travis.yml"
 - ".yardopts"
 - ChangeLog.md