bunny 1.7.0 → 2.17.0

data/lib/bunny/channel_id_allocator.rb

@@ -17,7 +17,9 @@ module Bunny
     #
 
     # @param [Integer] max_channel Max allowed channel id
-    def initialize(max_channel = ((1 << 16) - 1))
+    def initialize(max_channel = ((1 << 11) - 1))
+      # channel 0 has special meaning in the protocol, so start
+      # allocator at 1
       @allocator = AMQ::IntAllocator.new(1, max_channel)
       @mutex     = Monitor.new
     end
@@ -25,7 +27,7 @@ module Bunny
 
     # Returns next available channel id. This method is thread safe.
     #
-    # @return [Fixnum]
+    # @return [Integer]
     # @api public
     # @see ChannelManager#release_channel_id
     # @see ChannelManager#reset_channel_id_allocator
@@ -37,7 +39,7 @@ module Bunny
 
     # Releases previously allocated channel id. This method is thread safe.
     #
-    # @param [Fixnum] i Channel id to release
+    # @param [Integer] i Channel id to release
     # @api public
     # @see ChannelManager#next_channel_id
     # @see ChannelManager#reset_channel_id_allocator
@@ -51,7 +53,7 @@ module Bunny
     # Returns true if given channel id has been previously allocated and not yet released.
     # This method is thread safe.
     #
-    # @param [Fixnum] i Channel id to check
+    # @param [Integer] i Channel id to check
     # @return [Boolean] true if given channel id has been previously allocated and not yet released
     # @api public
     # @see ChannelManager#next_channel_id

data/lib/bunny/concurrent/continuation_queue.rb

@@ -6,36 +6,57 @@ module Bunny
     #
     # @private
     class ContinuationQueue
-      def initialize(*args, &block)
-        @q = ::Queue.new(*args)
+      def initialize
+        @q    = []
+        @lock = ::Mutex.new
+        @cond = ::ConditionVariable.new
       end
 
-      def push(*args)
-        @q.push(*args)
+      def push(item)
+        @lock.synchronize do
+          @q.push(item)
+          @cond.signal
+        end
       end
       alias << push
 
       def pop
-        @q.pop
+        poll
       end
 
       def poll(timeout_in_ms = nil)
-        if timeout_in_ms
-          Bunny::Timeout.timeout(timeout_in_ms / 1000.0, ::Timeout::Error) do
-            @q.pop
+        timeout = timeout_in_ms ? timeout_in_ms / 1000.0 : nil
+
+        @lock.synchronize do
+          timeout_strikes_at = Time.now.utc + (timeout || 0)
+          while @q.empty?
+            wait = if timeout
+                     timeout_strikes_at - Time.now.utc
+                   else
+                     nil
+                   end
+            @cond.wait(@lock, wait)
+            raise ::Timeout::Error if wait && Time.now.utc >= timeout_strikes_at
           end
-        else
-          @q.pop
+          item = @q.shift
+          item
         end
       end
 
       def clear
-        @q.clear
+        @lock.synchronize do
+          @q.clear
+        end
+      end
+
+      def empty?
+        @q.empty?
       end
 
-      def method_missing(selector, *args, &block)
-        @q.__send__(selector, *args, &block)
+      def size
+        @q.size
       end
+      alias length size
     end
   end
 end

data/lib/bunny/consumer_work_pool.rb

@@ -15,10 +15,17 @@ module Bunny
 
     attr_reader :threads
     attr_reader :size
+    attr_reader :abort_on_exception
 
-    def initialize(size = 1)
+    def initialize(size = 1, abort_on_exception = false, shutdown_timeout = 60)
       @size  = size
+      @abort_on_exception = abort_on_exception
+      @shutdown_timeout = shutdown_timeout
+      @shutdown_mutex = ::Mutex.new
+      @shutdown_conditional = ::ConditionVariable.new
       @queue = ::Queue.new
+      @paused = false
+      @running = false
     end
 
 
@@ -31,6 +38,7 @@ module Bunny
 
       @size.times do
         t = Thread.new(&method(:run_loop))
+        t.abort_on_exception = true if abort_on_exception
         @threads << t
       end
 
@@ -41,7 +49,16 @@ module Bunny
       @running
     end
 
-    def shutdown
+    def backlog
+      @queue.length
+    end
+
+    def busy?
+      !@queue.empty?
+    end
+
+    def shutdown(wait_for_workers = false)
+      was_running = running?
       @running = false
 
       @size.times do
@@ -49,20 +66,26 @@ module Bunny
           throw :terminate
         end
       end
+
+      return if !(wait_for_workers && @shutdown_timeout && was_running)
+
+      @shutdown_mutex.synchronize do
+        @shutdown_conditional.wait(@shutdown_mutex, @shutdown_timeout)
+      end
     end
 
     def join(timeout = nil)
-      @threads.each { |t| t.join(timeout) }
+      (@threads || []).each { |t| t.join(timeout) }
     end
 
     def pause
       @running = false
-
-      @threads.each { |t| t.stop }
+      @paused = true
     end
 
     def resume
       @running = true
+      @paused = false
 
       @threads.each { |t| t.run }
     end
@@ -70,7 +93,7 @@ module Bunny
     def kill
       @running = false
 
-      @threads.each { |t| t.kill }
+      (@threads || []).each { |t| t.kill }
     end
 
     protected
@@ -78,6 +101,7 @@ module Bunny
     def run_loop
       catch(:terminate) do
         loop do
+          Thread.stop if @paused
           callable = @queue.pop
 
           begin
@@ -89,6 +113,10 @@ module Bunny
           end
         end
       end
+
+      @shutdown_mutex.synchronize do
+        @shutdown_conditional.signal unless busy?
+      end
     end
   end
 end

data/lib/bunny/cruby/socket.rb

@@ -6,27 +6,40 @@ 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 = if defined?(IO::EAGAINWaitReadable)
+                                     # Ruby 2.1+
+                                     [Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitReadable,
+                                      IO::EAGAINWaitReadable, IO::EWOULDBLOCKWaitReadable]
+                                   else
+                                     # 2.0
+                                     [Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitReadable]
+                                   end
+    WRITE_RETRY_EXCEPTION_CLASSES = if defined?(IO::EAGAINWaitWritable)
+                                      [Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitWritable,
+                                       IO::EAGAINWaitWritable, IO::EWOULDBLOCKWaitWritable]
+                                    else
+                                      # 2.0
+                                      [Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitWritable]
+                                    end
 
     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.instance_eval do
+        @__bunny_socket_eof_flag__ = false
       end
+      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,26 @@ 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)
+    READ_RETRY_EXCEPTION_CLASSES = if defined?(IO::EAGAINWaitReadable)
+                                     # Ruby 2.1+
+                                     [Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitReadable,
+                                      IO::EAGAINWaitReadable, IO::EWOULDBLOCKWaitReadable]
+                                   else
+                                     # 2.0
+                                     [Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitReadable]
+                                   end
+    WRITE_RETRY_EXCEPTION_CLASSES = if defined?(IO::EAGAINWaitWritable)
+                                      [Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitWritable,
+                                       IO::EAGAINWaitWritable, IO::EWOULDBLOCKWaitWritable]
+                                    else
+                                      # 2.0
+                                      [Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitWritable]
+                                    end
 
-      # 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)
+      def initialize(*args)
+        super
+        @__bunny_socket_eof_flag__ = false
+      end
 
       # Reads given number of bytes with an optional timeout
       #
@@ -99,7 +112,7 @@ module Bunny
       end
 
     end
-  rescue LoadError => le
+  rescue LoadError
     puts "Could not load OpenSSL"
   end
 end

data/lib/bunny/exceptions.rb

@@ -69,7 +69,7 @@ module Bunny
       m = case e
           when String then
             e
-          when Exception then
+          when ::Exception then
             e.message
           end
       if hostname && port
@@ -97,6 +97,12 @@ module Bunny
     end
   end
 
+  class ConnectionAlreadyClosed < Exception
+    def initialize
+      super('Connection has been already closed')
+    end
+  end
+
   class ShutdownSignal < Exception
   end
 

data/lib/bunny/exchange.rb

@@ -1,3 +1,5 @@
+require 'amq/protocol'
+
 module Bunny
   # Represents AMQP 0.9.1 exchanges.
   #
@@ -80,6 +82,8 @@ module Bunny
       @internal         = @options[:internal]
       @arguments        = @options[:arguments]
 
+      @bindings         = Set.new
+
       declare! unless opts[:no_declare] || predeclared? || (@name == AMQ::Protocol::EMPTY_STRING)
 
       @channel.register_exchange(self)
@@ -169,6 +173,7 @@ module Bunny
     # @api public
     def bind(source, opts = {})
       @channel.exchange_bind(source, self, opts)
+      @bindings.add(source: source, opts: opts)
 
       self
     end
@@ -189,6 +194,7 @@ module Bunny
     # @api public
     def unbind(source, opts = {})
       @channel.exchange_unbind(source, self, opts)
+      @bindings.delete(source: source, opts: opts)
 
       self
     end
@@ -214,8 +220,11 @@ module Bunny
 
     # @private
     def recover_from_network_failure
-      # puts "Recovering exchange #{@name} from network failure"
-      declare! unless predefined?
+      declare! unless @options[:no_declare] ||predefined?
+
+      @bindings.each do |b|
+        bind(b[:source], b[:opts])
+      end
     end
 
 
@@ -245,11 +254,6 @@ module Bunny
       @channel.exchange_declare(@name, @type, @options)
     end
 
-    # @private
-    def self.add_default_options(name, opts, block)
-      { :exchange => name, :nowait => (block.nil? && !name.empty?) }.merge(opts)
-    end
-
     # @private
     def self.add_default_options(name, opts)
       # :nowait is always false for Bunny

data/lib/bunny/get_response.rb

@@ -20,7 +20,7 @@ module Bunny
     attr_reader :channel
 
     # @private
-    def initialize(get_ok, consumer, channel)
+    def initialize(get_ok, channel)
       @get_ok = get_ok
       @hash          = {
         :delivery_tag => @get_ok.delivery_tag,

data/lib/bunny/heartbeat_sender.rb

@@ -29,6 +29,7 @@ module Bunny
         @interval = [(period / 2) - 1, 0.4].max
 
         @thread = Thread.new(&method(:run))
+        @thread.report_on_exception = false if @thread.respond_to?(:report_on_exception)
       end
     end
 
@@ -62,8 +63,8 @@ module Bunny
       now = Time.now
 
       if now > (@last_activity_time + @interval)
-        @logger.debug "Sending a heartbeat, last activity time: #{@last_activity_time}, interval (s): #{@interval}"
-        @transport.write_without_timeout(AMQ::Protocol::HeartbeatFrame.encode)
+        @logger.debug { "Sending a heartbeat, last activity time: #{@last_activity_time}, interval (s): #{@interval}" }
+        @transport.write_without_timeout(AMQ::Protocol::HeartbeatFrame.encode, true)
       end
     end
   end

data/lib/bunny/jruby/socket.rb

@@ -5,7 +5,22 @@ module Bunny
     # TCP socket extension that uses Socket#readpartial to avoid excessive CPU
     # burn after some time. See issue #165.
     # @private
-    class Socket < Bunny::Socket
+    module Socket
+      include Bunny::Socket
+
+      def self.open(host, port, options = {})
+        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
       #
@@ -15,17 +30,17 @@ module Bunny
       # @return [String] Data read from the socket
       # @api public
       def read_fully(count, timeout = nil)
-        return nil if @__bunny_socket_eof_flag__
-
         value = ''
+
         begin
           loop do
-            value << readpartial(count - value.bytesize)
+            value << read_nonblock(count - value.bytesize)
             break if value.bytesize >= count
           end
         rescue EOFError
-          # @eof will break Rubinius' TCPSocket implementation. MK.
-          @__bunny_socket_eof_flag__ = true
+          # JRuby specific fix via https://github.com/jruby/jruby/issues/1694#issuecomment-54873532
+          IO.select([self], nil, nil, timeout)
+          retry
         rescue *READ_RETRY_EXCEPTION_CLASSES
           if IO.select([self], nil, nil, timeout)
             retry
@@ -33,8 +48,10 @@ module Bunny
             raise Timeout::Error, "IO timeout when reading #{count} bytes"
           end
         end
+
         value
       end # read_fully
+
     end
   end
 end