bunny 0.8.0 → 0.9.0.pre1

data/lib/bunny/channel_id_allocator.rb

@@ -0,0 +1,59 @@
+require "thread"
+
+module Bunny
+  class ChannelIdAllocator
+
+    #
+    # API
+    #
+
+    def initialize
+      max_channel     =  (1 << 16) - 1
+      @int_allocator ||= AMQ::IntAllocator.new(1, max_channel)
+
+      @channel_id_mutex ||= Mutex.new
+    end
+
+
+    # Returns next available channel id. This method is thread safe.
+    #
+    # @return [Fixnum]
+    # @api public
+    # @see ChannelManager#release_channel_id
+    # @see ChannelManager#reset_channel_id_allocator
+    def next_channel_id
+      @channel_id_mutex.synchronize do
+        @int_allocator.allocate
+      end
+    end
+
+    # Releases previously allocated channel id. This method is thread safe.
+    #
+    # @param [Fixnum] Channel id to release
+    # @api public
+    # @see ChannelManager#next_channel_id
+    # @see ChannelManager#reset_channel_id_allocator
+    def release_channel_id(i)
+      @channel_id_mutex.synchronize do
+        @int_allocator.release(i)
+      end
+    end # self.release_channel_id(i)
+
+
+    def allocated_channel_id?(i)
+      @channel_id_mutex.synchronize do
+        @int_allocator.allocated?(i)
+      end      
+    end
+
+    # Resets channel allocator. This method is thread safe.
+    # @api public
+    # @see Channel.next_channel_id
+    # @see Channel.release_channel_id
+    def reset_channel_id_allocator
+      @channel_id_mutex.synchronize do
+        @int_allocator.reset
+      end
+    end # reset_channel_id_allocator
+  end
+end

data/lib/bunny/compatibility.rb

@@ -0,0 +1,24 @@
+module Bunny
+  # Helper methods necessary to stay mostly backwards-compatible with legacy (0.7.x, 0.8.x) Bunny
+  # releases that hide channels completely from the API.
+  #
+  # @private
+  module Compatibility
+
+    #
+    # API
+    #
+
+    # @api public
+    def channel_from(channel_or_connection)
+      # Bunny 0.8.x and earlier completely hide channels from the API. So, queues and exchanges are
+      # instantiated with a "Bunny object", which is a session. This function coerces two types of input to a
+      # channel.
+      if channel_or_connection.is_a?(Bunny::Session)
+        channel_or_connection.default_channel
+      else
+        channel_or_connection
+      end
+    end
+  end
+end

data/lib/bunny/concurrent/condition.rb

@@ -0,0 +1,63 @@
+require "thread"
+
+module Bunny
+  module Concurrent
+    # Akin to java.util.concurrent.Condition and intrinsic object monitors (Object#wait, Object#notify, Object#notifyAll) in Java:
+    # threads can wait (block until notified) on a condition other threads notify them about.
+    # Unlike the j.u.c. version, this one has a single waiting set.
+    #
+    # Conditions can optionally be annotated with a description string for ease of debugging.
+    class Condition
+      attr_reader :waiting_threads, :description
+
+
+      def initialize(description = nil)
+        @mutex           = Mutex.new
+        @waiting_threads = []
+        @description     = description
+      end
+
+      def wait
+        @mutex.synchronize do
+          t = Thread.current
+          @waiting_threads.push(t)
+        end
+
+        Thread.stop
+      end
+
+      def notify
+        @mutex.synchronize do
+          t = @waiting_threads.shift
+          begin
+            t.run if t
+          rescue ThreadError
+            retry
+          end
+        end
+      end
+
+      def notify_all
+        @mutex.synchronize do
+          @waiting_threads.each do |t|
+            t.run
+          end
+
+          @waiting_threads.clear
+        end
+      end
+
+      def waiting_set_size
+        @mutex.synchronize { @waiting_threads.size }
+      end
+
+      def any_threads_waiting?
+        @mutex.synchronize { !@waiting_threads.empty? }
+      end
+
+      def none_threads_waiting?
+        @mutex.synchronize { @waiting_threads.empty? }
+      end
+    end
+  end
+end

data/lib/bunny/consumer.rb

@@ -1,35 +1,51 @@
-# encoding: utf-8
+module Bunny
+  class Consumer
 
-####################################
-# NOTE: THIS CLASS IS HERE TO MAKE #
-# TRANSITION TO AMQ CLIENT EASIER  #
-####################################
+    #
+    # API
+    #
 
-require "qrack/subscription"
+    attr_reader :channel
+    attr_reader :queue
+    attr_reader :consumer_tag
+    attr_reader :arguments
 
-# NOTE: This file is rather a temporary hack to fix
-# https://github.com/ruby-amqp/bunny/issues/9 then
-# some permanent solution. It's mostly copied from
-# the AMQP and AMQ Client gems. Later on we should
-# use AMQ Client directly and just inherit from
-# the AMQ::Client::Sync::Consumer class.
 
-module Bunny
+    def initialize(channel, queue, consumer_tag, no_ack = false, exclusive = false, arguments = {})
+      @channel       = channel || raise(ArgumentError, "channel is nil")
+      @queue         = queue || raise(ArgumentError, "queue is nil")
+      @consumer_tag  = consumer_tag || raise(ArgumentError, "consumer tag is nil")
+      @exclusive     = exclusive
+      @arguments     = arguments
+      @no_ack        = no_ack
+    end
+
+
+    def on_delivery(&block)
+      @on_delivery = block
+      self
+    end
 
-  # AMQP consumers are entities that handle messages delivered
-  # to them ("push API" as opposed to "pull API") by AMQP broker.
-  # Every consumer is associated with a queue. Consumers can be
-  # exclusive (no other consumers can be registered for the same
-  # queue) or not (consumers share the queue). In the case of
-  # multiple consumers per queue, messages are distributed in
-  # round robin manner with respect to channel-level prefetch
-  # setting).
-  class Consumer < Qrack::Subscription
-    def initialize(*args)
-      super(*args)
-      @consumer_tag ||= (1..32).to_a.shuffle.join
+    def call(*args)
+      @on_delivery.call(*args) if @on_delivery
     end
+    alias handle_delivery call
 
-    alias_method :consume, :start
+    def handle_cancel(&block)
+      @on_cancellation = block
+      self
+    end
+
+    def queue_name
+      if @queue.respond_to?(:name)
+        @queue.name
+      else
+        @queue
+      end
+    end
+
+    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}>"
+    end
   end
 end

data/lib/bunny/consumer_tag_generator.rb

@@ -0,0 +1,22 @@
+module Bunny
+  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/bunny/consumer_work_pool.rb

@@ -0,0 +1,67 @@
+require "thread"
+
+module Bunny
+  # Thread pool that dispatches consumer deliveries. Not supposed to be shared between channels
+  # or threads.
+  class ConsumerWorkPool
+
+    #
+    # API
+    #
+
+    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
+
+      @started = true
+    end
+
+    def started?
+      @started
+    end
+
+    def shutdown
+      @size.times do
+        submit do |*args|
+          throw :terminate
+        end
+      end
+    end
+
+    def join
+      @threads.each { |t| t.join }
+    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/bunny/exceptions.rb

@@ -0,0 +1,128 @@
+module Bunny
+  class TCPConnectionFailed < StandardError
+    attr_reader :hostname, :port
+
+    def initialize(e, hostname, port)
+      super("Could not estabilish TCP connection to #{hostname}:#{port}: #{e.message}")
+    end
+  end
+
+  class ConnectionClosedError < StandardError
+    def initialize(frame)
+      if frame.respond_to?(:method_class)
+        super("Trying to send frame through a closed connection. Frame is #{frame.inspect}")
+      else
+        super("Trying to send frame through a closed connection. Frame is #{frame.inspect}, method class is #{frame.method_class}")
+      end
+    end
+  end
+
+  class PossibleAuthenticationFailureError < StandardError
+
+    #
+    # API
+    #
+
+    attr_reader :username, :vhost
+
+    def initialize(username, vhost, password_length)
+      @username = username
+      @vhost    = vhost
+
+      super("AMQP broker closed TCP connection before authentication succeeded: this usually means authentication failure due to misconfiguration or that RabbitMQ version does not support AMQP 0.9.1. Please check your configuration. Username: #{username}, vhost: #{vhost}, password length: #{password_length}")
+    end # initialize(settings)
+  end # PossibleAuthenticationFailureError
+
+
+  # backwards compatibility
+  ConnectionError = TCPConnectionFailed
+  ServerDownError = TCPConnectionFailed
+
+  # TODO
+  class ForcedChannelCloseError < StandardError; end
+  class ForcedConnectionCloseError < StandardError; end
+  class MessageError < StandardError; end
+  class ProtocolError < StandardError; 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 connection timeout
+  class ConnectionTimeout < Timeout::Error; end
+
+
+  # Base exception class for data consistency and framing errors.
+  class InconsistentDataError < StandardError
+  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 http://files.travis-ci.org/docs/amqp/0.9.1/AMQP091Specification.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 http://files.travis-ci.org/docs/amqp/0.9.1/AMQP091Specification.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
+
+
+  class ChannelAlreadyClosed < StandardError
+    attr_reader :channel
+
+    def initialize(message, ch)
+      super(message)
+
+      @channel = ch
+    end
+  end
+
+  class ChannelLevelException < StandardError
+    attr_reader :channel, :channel_close
+
+    def initialize(message, ch, channel_close)
+      super(message)
+
+      @channel       = ch
+      @channel_close = channel_close
+    end
+  end
+
+  class PreconditionFailed < ChannelLevelException
+  end
+
+  class NotFound < ChannelLevelException
+  end
+
+  class ResourceLocked < ChannelLevelException
+  end
+
+  class AccessRefused < ChannelLevelException
+  end
+
+
+
+  class ConnectionLevelException < StandardError
+    attr_reader :connection, :connection_close
+
+    def initialize(message, connection, connection_close)
+      super(message)
+
+      @connection       = connection
+      @connection_close = connection_close
+    end
+  end
+
+  class ChannelError < ConnectionLevelException
+  end
+end