bunny 1.3.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,23 +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)
+    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[:socket_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
@@ -62,22 +79,32 @@ module Bunny
     # if this is not appropriate in your case.
     #
     # @param [String] data Data to write
+    # @param [Integer] timeout Timeout
     #
     # @api public
-    def write_nonblock_fully(data)
+    def write_nonblock_fully(data, timeout = nil)
       return nil if @__bunny_socket_eof_flag__
 
-      begin
-        while !data.empty?
-          written = self.write_nonblock(data)
-          data.slice!(0, written)
+      length = data.bytesize
+      total_count = 0
+      count = 0
+      loop do
+        begin
+          count = self.write_nonblock(data)
+        rescue *WRITE_RETRY_EXCEPTION_CLASSES
+          if IO.select([], [self], nil, timeout)
+            retry
+          else
+            raise Timeout::Error, "IO timeout when writing to socket"
+          end
         end
-      rescue Errno::EWOULDBLOCK, Errno::EAGAIN
-        IO.select([], [self])
-        retry
+
+        total_count += count
+        return total_count if total_count >= length
+        data = data.byteslice(count..-1)
       end
 
-      data.bytesize
     end
+
   end
 end

data/lib/bunny/cruby/ssl_socket.rb

@@ -8,10 +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
 
+      def initialize(*args)
+        super
+        @__bunny_socket_eof_flag__ = false
+      end
 
       # Reads given number of bytes with an optional timeout
       #
@@ -50,8 +66,53 @@ module Bunny
         end
         value
       end
+
+      # 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
+      # @param [Integer] timeout Timeout
+      #
+      # @api public
+      def write_nonblock_fully(data, timeout = nil)
+        return nil if @__bunny_socket_eof_flag__
+
+        length = data.bytesize
+        total_count = 0
+        count = 0
+        loop do
+          begin
+            count = self.write_nonblock(data)
+          rescue OpenSSL::SSL::SSLError => e
+            if e.message == "write would block"
+              if IO.select([], [self], nil, timeout)
+                retry
+              else
+                raise Timeout::Error, "IO timeout when writing to socket"
+              end
+            end
+            raise e
+          rescue *WRITE_RETRY_EXCEPTION_CLASSES
+            if IO.select([], [self], nil, timeout)
+              retry
+            else
+              raise Timeout::Error, "IO timeout when writing to socket"
+            end
+          end
+
+          total_count += count
+          return total_count if total_count >= length
+          data = data.byteslice(count..-1)
+        end
+
+      end
+
     end
-  rescue LoadError => le
+  rescue LoadError
     puts "Could not load OpenSSL"
   end
 end

data/lib/bunny/exceptions.rb

@@ -4,6 +4,12 @@ module Bunny
   class Exception < ::StandardError
   end
 
+  class HostListDepleted < Exception
+    def initialize
+      super("No more hosts to try in the supplied list of hosts")
+    end
+  end
+
   # Indicates a network failure. If automatic network
   # recovery mode is enabled, these will be typically handled
   # by the client itself.
@@ -54,20 +60,29 @@ module Bunny
     end
   end
 
-
   # Raised when TCP connection to RabbitMQ fails because of an unresolved
   # hostname, connectivity problem, etc
   class TCPConnectionFailed < Exception
     attr_reader :hostname, :port
 
-    def initialize(e, hostname, port)
+    def initialize(e, hostname=nil, port=nil)
       m = case e
           when String then
             e
-          when Exception then
+          when ::Exception then
             e.message
           end
-      super("Could not establish TCP connection to #{hostname}:#{port}: #{m}")
+      if hostname && port
+        super("Could not establish TCP connection to #{hostname}:#{port}: #{m}")
+      else
+        super(m)
+      end
+    end
+  end
+
+  class TCPConnectionFailedForAllHosts < TCPConnectionFailed
+    def initialize
+      super("Could not establish TCP connection to any of the configured hosts", nil, nil)
     end
   end
 
@@ -82,6 +97,12 @@ module Bunny
     end
   end
 
+  class ConnectionAlreadyClosed < Exception
+    def initialize
+      super('Connection has been already closed')
+    end
+  end
+
   class ShutdownSignal < Exception
   end