garaio_bunny 2.19.1

data/lib/bunny/cruby/socket.rb

@@ -0,0 +1,110 @@
+require "socket"
+
+module Bunny
+  # TCP socket extension that uses TCP_NODELAY and supports reading
+  # fully.
+  #
+  # Heavily inspired by Dalli by Mike Perham.
+  # @private
+  module Socket
+    attr_accessor :options
+
+    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 = {})
+      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
+    #
+    # @param [Integer] count How many bytes to read
+    # @param [Integer] timeout Timeout
+    #
+    # @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 << 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
+      rescue *READ_RETRY_EXCEPTION_CLASSES
+        if IO.select([self], nil, nil, timeout)
+          retry
+        else
+          raise Timeout::Error, "IO timeout when reading #{count} bytes"
+        end
+      end
+      value
+    end # read_fully
+
+    # 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 *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
+end

data/lib/bunny/cruby/ssl_socket.rb

@@ -0,0 +1,118 @@
+require "socket"
+
+module Bunny
+  begin
+    require "openssl"
+
+    # TLS-enabled TCP socket that implements convenience
+    # methods found in Bunny::Socket.
+    class SSLSocket < OpenSSL::SSL::SSLSocket
+
+    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
+      #
+      # @param [Integer] count How many bytes to read
+      # @param [Integer] timeout Timeout
+      #
+      # @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 << read_nonblock(count - value.bytesize)
+            break if value.bytesize >= count
+          end
+        rescue EOFError => e
+          @__bunny_socket_eof_flag__ = true
+        rescue OpenSSL::SSL::SSLError => e
+          if e.message == "read would block"
+            if IO.select([self], nil, nil, timeout)
+              retry
+            else
+              raise Timeout::Error, "IO timeout when reading #{count} bytes"
+            end
+          else
+            raise e
+          end
+        rescue *READ_RETRY_EXCEPTION_CLASSES => e
+          if IO.select([self], nil, nil, timeout)
+            retry
+          else
+            raise Timeout::Error, "IO timeout when reading #{count} bytes"
+          end
+        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
+    puts "Could not load OpenSSL"
+  end
+end

data/lib/bunny/delivery_info.rb

@@ -0,0 +1,93 @@
+require "bunny/versioned_delivery_tag"
+
+module Bunny
+  # Wraps {AMQ::Protocol::Basic::Deliver} to
+  # provide access to the delivery properties as immutable hash as
+  # well as methods.
+  class DeliveryInfo
+
+    #
+    # Behaviors
+    #
+
+    include Enumerable
+
+    #
+    # API
+    #
+
+    # @return [Bunny::Consumer] Consumer this delivery is for
+    attr_reader :consumer
+    # @return [Bunny::Channel] Channel this delivery is on
+    attr_reader :channel
+
+    # @private
+    def initialize(basic_deliver, consumer, channel)
+      @basic_deliver = basic_deliver
+      @hash          = {
+        :consumer_tag => basic_deliver.consumer_tag,
+        :delivery_tag => VersionedDeliveryTag.new(basic_deliver.delivery_tag, channel.recoveries_counter),
+        :redelivered  => basic_deliver.redelivered,
+        :exchange     => basic_deliver.exchange,
+        :routing_key  => basic_deliver.routing_key,
+        :consumer     => consumer,
+        :channel      => channel
+      }
+      @consumer      = consumer
+      @channel       = channel
+    end
+
+    # Iterates over the delivery properties
+    # @see Enumerable#each
+    def each(*args, &block)
+      @hash.each(*args, &block)
+    end
+
+    # Accesses delivery properties by key
+    # @see Hash#[]
+    def [](k)
+      @hash[k]
+    end
+
+    # @return [Hash] Hash representation of this delivery info
+    def to_hash
+      @hash
+    end
+
+    # @private
+    def to_s
+      to_hash.to_s
+    end
+
+    # @private
+    def inspect
+      to_hash.inspect
+    end
+
+    # @return [String] Consumer tag this delivery is for
+    def consumer_tag
+      @basic_deliver.consumer_tag
+    end
+
+    # @return [String] Delivery identifier that is used to acknowledge, reject and nack deliveries
+    def delivery_tag
+      @basic_deliver.delivery_tag
+    end
+
+    # @return [Boolean] true if this delivery is a redelivery (the message was requeued at least once)
+    def redelivered
+      @basic_deliver.redelivered
+    end
+    alias redelivered? redelivered
+
+    # @return [String] Name of the exchange this message was published to
+    def exchange
+      @basic_deliver.exchange
+    end
+
+    # @return [String] Routing key this message was published with
+    def routing_key
+      @basic_deliver.routing_key
+    end
+  end
+end

data/lib/bunny/exceptions.rb

@@ -0,0 +1,269 @@
+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.
+  #
+  # @api public
+  class NetworkFailure < Exception
+    attr_reader :cause
+
+    def initialize(message, cause)
+      super(message)
+      @cause = cause
+    end
+  end
+
+  # Base class for all channel level exceptions
+  class ChannelLevelException < Exception
+    attr_reader :channel, :channel_close
+
+    def initialize(message, ch, channel_close)
+      super(message)
+
+      @channel       = ch
+      @channel_close = channel_close
+    end
+  end
+
+  # Base class for all connection level exceptions
+  class ConnectionLevelException < Exception
+    attr_reader :connection, :connection_close
+
+    def initialize(message, connection, connection_close)
+      super(message)
+
+      @connection       = connection
+      @connection_close = connection_close
+    end
+  end
+
+  # Can indicate either a channel or connection-level issue
+  class NotAllowedError < Exception
+    attr_reader :connection, :connection_close
+
+    def initialize(message, connection, connection_close = nil)
+      super(message)
+
+      @connection       = connection
+      @connection_close = connection_close
+    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=nil, port=nil)
+      m = case e
+          when String then
+            e
+          when ::Exception then
+            e.message
+          end
+      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
+
+  # Raised when a frame is sent over an already closed connection
+  class ConnectionClosedError < Exception
+    def initialize(frame)
+      if frame.respond_to?(:method_class)
+        super("Trying to send frame through a closed connection. Frame is #{frame.inspect}, method class is #{frame.method_class}")
+      else
+        super("Trying to send frame through a closed connection. Frame is #{frame.inspect}")
+      end
+    end
+  end
+
+  class ConnectionAlreadyClosed < Exception
+    def initialize
+      super('Connection has been already closed')
+    end
+  end
+
+  class ShutdownSignal < Exception
+  end
+
+  # Raised when RabbitMQ closes TCP connection before finishing connection
+  # sequence properly. This typically indicates an authentication issue.
+  class PossibleAuthenticationFailureError < Exception
+
+    #
+    # API
+    #
+
+    attr_reader :username, :vhost
+
+    def initialize(username, vhost, password_length)
+      @username = username
+      @vhost    = vhost
+
+      super("Authentication with RabbitMQ failed. Please check your connection settings. Username: #{username}, vhost: #{vhost}, password length: #{password_length}")
+    end # initialize(settings)
+  end # PossibleAuthenticationFailureError
+
+
+  # Raised when RabbitMQ closes TCP connection due to an authentication failure.
+  # Relies on RabbitMQ 3.2 Authentication Failure Notifications extension:
+  # http://www.rabbitmq.com/auth-notification.html
+  class AuthenticationFailureError < PossibleAuthenticationFailureError
+
+    #
+    # API
+    #
+
+    attr_reader :username, :vhost
+
+    def initialize(username, vhost, password_length)
+      @username = username
+      @vhost    = vhost
+
+      super(username, vhost, password_length)
+    end # initialize(settings)
+  end # AuthenticationFailureError
+
+
+  # backwards compatibility
+  # @private
+  ConnectionError = TCPConnectionFailed
+  # @private
+  ServerDownError = TCPConnectionFailed
+
+  # Raised when a channel is closed forcefully using rabbitmqctl
+  # or the management UI plugin
+  class ForcedChannelCloseError < ChannelLevelException; end
+  # Raised when a connection is closed forcefully using rabbitmqctl
+  # or the management UI plugin
+  class ForcedConnectionCloseError < ConnectionLevelException; end
+  # @private
+  class MessageError  < ConnectionLevelException; end
+  # @private
+  class ProtocolError < ConnectionLevelException; end
+  # Raised when RabbitMQ reports and internal error
+  class InternalError < ConnectionLevelException; end
+
+  # Raised when read or write I/O operations time out (but only if
+  # a connection is configured to use them)
+  class ClientTimeout     < Timeout::Error; end
+  # Raised on initial TCP connection timeout
+  class ConnectionTimeout < Timeout::Error; end
+
+
+  # Base exception class for data consistency and framing errors.
+  class InconsistentDataError < Exception
+  end
+
+  # Raised by adapters when frame does not end with {final octet AMQ::Protocol::Frame::FINAL_OCTET}.
+  # This suggest that there is a bug in adapter or AMQ broker implementation.
+  #
+  # @see https://www.rabbitmq.com/resources/specs/amqp0-9-1.pdf AMQP 0.9.1 specification (Section 2.3)
+  class NoFinalOctetError < InconsistentDataError
+    def initialize
+      super("Frame doesn't end with #{AMQ::Protocol::Frame::FINAL_OCTET} as it must, which means the size is miscalculated.")
+    end
+  end
+
+  # Raised by adapters when actual frame payload size in bytes is not equal
+  # to the size specified in that frame's header.
+  # This suggest that there is a bug in adapter or AMQ broker implementation.
+  #
+  # @see https://www.rabbitmq.com/resources/specs/amqp0-9-1.pdf AMQP 0.9.1 specification (Section 2.3)
+  class BadLengthError < InconsistentDataError
+    def initialize(expected_length, actual_length)
+      super("Frame payload should be #{expected_length} long, but it's #{actual_length} long.")
+    end
+  end
+
+  # Raised when a closed channel is used
+  class ChannelAlreadyClosed < Exception
+    attr_reader :channel
+
+    def initialize(message, ch)
+      super(message)
+
+      @channel = ch
+    end
+  end
+
+  # Raised when RabbitMQ responds with 406 PRECONDITION_FAILED
+  class PreconditionFailed < ChannelLevelException
+  end
+
+  # Raised when RabbitMQ responds with 404 NOT_FOUND
+  class NotFound < ChannelLevelException
+  end
+
+  # Raised when RabbitMQ responds with 405 RESOUCE_LOCKED
+  class ResourceLocked < ChannelLevelException
+  end
+
+  # Raised when RabbitMQ responds with 403 ACCESS_REFUSED
+  class AccessRefused < ChannelLevelException
+  end
+
+  # Raised when RabbitMQ responds with 504 CHANNEL_ERROR
+  class ChannelError < ConnectionLevelException
+  end
+
+  # Raised when RabbitMQ responds with 503 COMMAND_INVALID
+  class CommandInvalid < ConnectionLevelException
+  end
+
+  # Raised when RabbitMQ responds with 501 FRAME_ERROR
+  class FrameError < ConnectionLevelException
+  end
+
+  # Raised when RabbitMQ responds with 505 UNEXPECTED_FRAME
+  class UnexpectedFrame < ConnectionLevelException
+  end
+
+  # Raised when RabbitMQ responds with 506 RESOURCE_ERROR
+  class ResourceError < ConnectionLevelException
+  end
+
+  # @private
+  class NetworkErrorWrapper < Exception
+    attr_reader :other
+
+    def initialize(other)
+      super(other.message)
+      @other = other
+    end
+  end
+
+  # Raised when RabbitMQ responds with 302 CONNECTION_FORCED
+  # (which means the connection was closed using rabbitmqctl or
+  # RabbitMQ management UI)
+  class ConnectionForced < ConnectionLevelException
+  end
+
+  # @private
+  class MissingTLSCertificateFile < Exception
+  end
+
+  # @private
+  class MissingTLSKeyFile < Exception
+  end
+end