bunny 1.0.7 → 2.24.0

data/lib/bunny/channel_id_allocator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "thread"
 require "monitor"
 require "amq/int_allocator"
@@ -17,7 +19,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 +29,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 +41,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 +55,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/atomic_fixnum.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "set"
 require "thread"
 require "monitor"

data/lib/bunny/concurrent/condition.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "thread"
 require "monitor"
 

data/lib/bunny/concurrent/continuation_queue.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "thread"
 
 module Bunny
@@ -6,36 +8,58 @@ 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, ::Timeout::Error) do
-            @q.pop
+        timeout_in_sec = timeout_in_ms ? timeout_in_ms / 1000.0 : nil
+
+        @lock.synchronize do
+          started_at = Bunny::Timestamp.monotonic
+          while @q.empty?
+            wait = !(timeout_in_sec.nil?)
+            @cond.wait(@lock, timeout_in_sec)
+
+            if wait
+              ended_at = Bunny::Timestamp.monotonic
+              elapsed = ended_at - started_at
+              raise ::Timeout::Error if (elapsed > timeout_in_sec)
+            end
           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/concurrent/synchronized_sorted_set.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "set"
 require "thread"
 

data/lib/bunny/consumer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Bunny
   # Base class that represents consumer interface. Subclasses of this class implement
   # specific logic of handling consumer life cycle events. Note that when the only event
@@ -39,6 +41,8 @@ module Bunny
       @arguments     = arguments
       # no_ack set to true = no manual ack = automatic ack. MK.
       @no_ack        = no_ack
+
+      @on_cancellation = []
     end
 
     # Defines message delivery handler
@@ -61,14 +65,16 @@ module Bunny
     # @see http://rubybunny.info/articles/extensions.html RabbitMQ Extensions guide
     # @api public
     def on_cancellation(&block)
-      @on_cancellation = block
+      @on_cancellation << block
       self
     end
 
     # Invokes consumer cancellation notification handler
     # @private
     def handle_cancellation(basic_cancel)
-      @on_cancellation.call(basic_cancel) if @on_cancellation
+      @on_cancellation.each do |fn|
+        fn.call(basic_cancel)
+      end
     end
 
     # Cancels this consumer. Messages for this consumer will no longer be delivered. If the queue
@@ -82,12 +88,12 @@ module Bunny
 
     # @return [String] More detailed human-readable string representation of this consumer
     def inspect
-      "#<#{self.class.name}:#{object_id} @channel_id=#{@channel.number} @queue=#{self.queue_name}> @consumer_tag=#{@consumer_tag} @exclusive=#{@exclusive} @no_ack=#{@no_ack}>"
+      "#<#{self.class.name}:#{object_id} @channel_id=#{@channel.number} @queue=#{self.queue_name} @consumer_tag=#{@consumer_tag} @exclusive=#{@exclusive} @no_ack=#{@no_ack}>"
     end
 
     # @return [String] Brief human-readable string representation of this consumer
     def to_s
-      "#<#{self.class.name}:#{object_id} @channel_id=#{@channel.number} @queue=#{self.queue_name}> @consumer_tag=#{@consumer_tag}>"
+      "#<#{self.class.name}:#{object_id} @channel_id=#{@channel.number} @queue=#{self.queue_name} @consumer_tag=#{@consumer_tag}>"
     end
 
     # @return [Boolean] true if this consumer uses automatic acknowledgement mode
@@ -102,6 +108,16 @@ module Bunny
       @no_ack == false
     end
 
+    # @return [String] Name of the queue this consumer is on
+    # @api public
+    def queue_name
+      if @queue.respond_to?(:name)
+        @queue.name
+      else
+        @queue
+      end
+    end
+
     #
     # Recovery
     #
@@ -110,14 +126,5 @@ module Bunny
     def recover_from_network_failure
       @channel.basic_consume_with(self)
     end
-
-    # @private
-    def queue_name
-      if @queue.respond_to?(:name)
-        @queue.name
-      else
-        @queue
-      end
-    end
   end
 end

data/lib/bunny/consumer_tag_generator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Bunny
   # Used to generate consumer tags in the client
   class ConsumerTagGenerator
@@ -8,7 +10,8 @@ module Bunny
 
     # @return [String] Generated consumer tag
     def generate
-      "#{Kernel.rand}-#{Time.now.to_i * 1000}-#{Kernel.rand(999_999_999_999)}"
+      t = Bunny::Timestamp.now
+      "#{Kernel.rand}-#{t.to_i * 1000}-#{Kernel.rand(999_999_999_999)}"
     end # generate
 
 
@@ -17,7 +20,8 @@ module Bunny
     # @return [String]  Unique string.
     # @api public
     def generate_prefixed(name = "bunny")
-      "#{name}-#{Time.now.to_i * 1000}-#{Kernel.rand(999_999_999_999)}"
+      t = Bunny::Timestamp.now
+      "#{name}-#{t.to_i * 1000}-#{Kernel.rand(999_999_999_999)}"
     end
   end
 end

data/lib/bunny/consumer_work_pool.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "thread"
 
 module Bunny
@@ -15,10 +17,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 +40,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 +51,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 +68,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) if busy?
+      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 +95,7 @@ module Bunny
     def kill
       @running = false
 
-      @threads.each { |t| t.kill }
+      (@threads || []).each { |t| t.kill }
     end
 
     protected
@@ -78,17 +103,22 @@ module Bunny
     def run_loop
       catch(:terminate) do
         loop do
+          Thread.stop if @paused
           callable = @queue.pop
 
           begin
             callable.call
-          rescue ::Exception => e
+          rescue ::StandardError => e
             # TODO: use connection logger
             $stderr.puts e.class.name
             $stderr.puts e.message
           end
         end
       end
+
+      @shutdown_mutex.synchronize do
+        @shutdown_conditional.signal unless busy?
+      end
     end
   end
 end

data/lib/bunny/cruby/socket.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "socket"
 
 module Bunny
@@ -6,23 +8,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
@@ -35,7 +54,7 @@ module Bunny
     def read_fully(count, timeout = nil)
       return nil if @__bunny_socket_eof_flag__
 
-      value = ''
+      value = +''
       begin
         loop do
           value << read_nonblock(count - value.bytesize)
@@ -62,22 +81,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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "socket"
 
 module Bunny
@@ -8,10 +10,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
       #
@@ -23,7 +41,7 @@ module Bunny
       def read_fully(count, timeout = nil)
         return nil if @__bunny_socket_eof_flag__
 
-        value = ''
+        value = +''
         begin
           loop do
             value << read_nonblock(count - value.bytesize)
@@ -50,8 +68,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/delivery_info.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "bunny/versioned_delivery_tag"
 
 module Bunny
@@ -37,7 +39,7 @@ module Bunny
       @channel       = channel
     end
 
-    # Iterates over the delivery properties
+    # Iterates over delivery properties
     # @see Enumerable#each
     def each(*args, &block)
       @hash.each(*args, &block)

data/lib/bunny/exceptions.rb

@@ -1,9 +1,17 @@
+# frozen_string_literal: true
+
 module Bunny
   # Base class for all Bunny exceptions
   # @api public
   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 +62,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 +99,12 @@ module Bunny
     end
   end
 
+  class ConnectionAlreadyClosed < Exception
+    def initialize
+      super('Connection has been already closed')
+    end
+  end
+
   class ShutdownSignal < Exception
   end