gorgon 0.5.0.rc1 → 0.6.0.rc1

data/lib/gorgon_bunny/lib/gorgon_bunny/consumer_tag_generator.rb

@@ -0,0 +1,23 @@
+module GorgonBunny
+  # Used to generate consumer tags in the client
+  class ConsumerTagGenerator
+
+    #
+    # API
+    #
+
+    # @return [String] Generated consumer tag
+    def generate
+      "#{Kernel.rand}-#{Time.now.to_i * 1000}-#{Kernel.rand(999_999_999_999)}"
+    end # generate
+
+
+    # Unique string supposed to be used as a consumer tag.
+    #
+    # @return [String]  Unique string.
+    # @api public
+    def generate_prefixed(name = "bunny")
+      "#{name}-#{Time.now.to_i * 1000}-#{Kernel.rand(999_999_999_999)}"
+    end
+  end
+end

data/lib/gorgon_bunny/lib/gorgon_bunny/consumer_work_pool.rb

@@ -0,0 +1,94 @@
+require "thread"
+
+module GorgonBunny
+  # Thread pool that dispatches consumer deliveries. Not supposed to be shared between channels
+  # or threads.
+  #
+  # Every channel its own consumer pool.
+  #
+  # @private
+  class ConsumerWorkPool
+
+    #
+    # API
+    #
+
+    attr_reader :threads
+    attr_reader :size
+
+    def initialize(size = 1)
+      @size  = size
+      @queue = ::Queue.new
+    end
+
+
+    def submit(callable = nil, &block)
+      @queue.push(callable || block)
+    end
+
+    def start
+      @threads = []
+
+      @size.times do
+        t = Thread.new(&method(:run_loop))
+        @threads << t
+      end
+
+      @running = true
+    end
+
+    def running?
+      @running
+    end
+
+    def shutdown
+      @running = false
+
+      @size.times do
+        submit do |*args|
+          throw :terminate
+        end
+      end
+    end
+
+    def join(timeout = nil)
+      @threads.each { |t| t.join(timeout) }
+    end
+
+    def pause
+      @running = false
+
+      @threads.each { |t| t.stop }
+    end
+
+    def resume
+      @running = true
+
+      @threads.each { |t| t.run }
+    end
+
+    def kill
+      @running = false
+
+      @threads.each { |t| t.kill }
+    end
+
+    protected
+
+    def run_loop
+      catch(:terminate) do
+        loop do
+          callable = @queue.pop
+
+          begin
+            callable.call
+          rescue Exception => e
+            # TODO
+            puts e.class.name
+            puts e.message
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gorgon_bunny/lib/gorgon_bunny/delivery_info.rb

@@ -0,0 +1,93 @@
+require "gorgon_bunny/versioned_delivery_tag"
+
+module GorgonBunny
+  # Wraps {GorgonAMQ::Protocol::Basic::Deliver} to
+  # provide access to the delivery properties as immutable hash as
+  # well as methods.
+  class DeliveryInfo
+
+    #
+    # Behaviors
+    #
+
+    include Enumerable
+
+    #
+    # API
+    #
+
+    # @return [GorgonBunny::Consumer] Consumer this delivery is for
+    attr_reader :consumer
+    # @return [GorgonBunny::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/gorgon_bunny/lib/gorgon_bunny/exceptions.rb

@@ -0,0 +1,236 @@
+module GorgonBunny
+  # Base class for all GorgonBunny exceptions
+  # @api public
+  class Exception < ::StandardError
+  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
+
+
+  # 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)
+      m = case e
+          when String then
+            e
+          when Exception then
+            e.message
+          end
+      super("Could not establish TCP connection to #{hostname}:#{port}: #{m}")
+    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 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 GorgonAMQ::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 #{GorgonAMQ::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