gorgon 0.5.0.rc1 → 0.6.0.rc1

data/lib/gorgon_bunny/lib/gorgon_bunny/channel_id_allocator.rb

@@ -0,0 +1,80 @@
+require "thread"
+require "monitor"
+require "gorgon_amq/int_allocator"
+
+module GorgonBunny
+  # Bitset-based channel id allocator. When channels are closed,
+  # ids are released back to the pool.
+  #
+  # Every connection has its own allocator.
+  #
+  # Allocating and releasing ids is synchronized and can be performed
+  # from multiple threads.
+  class ChannelIdAllocator
+
+    #
+    # API
+    #
+
+    # @param [Integer] max_channel Max allowed channel id
+    def initialize(max_channel = ((1 << 16) - 1))
+      @allocator = GorgonAMQ::IntAllocator.new(1, max_channel)
+      @mutex     = Monitor.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
+      @mutex.synchronize do
+        @allocator.allocate
+      end
+    end
+
+    # Releases previously allocated channel id. This method is thread safe.
+    #
+    # @param [Fixnum] i Channel id to release
+    # @api public
+    # @see ChannelManager#next_channel_id
+    # @see ChannelManager#reset_channel_id_allocator
+    def release_channel_id(i)
+      @mutex.synchronize do
+        @allocator.release(i)
+      end
+    end
+
+
+    # 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
+    # @return [Boolean] true if given channel id has been previously allocated and not yet released
+    # @api public
+    # @see ChannelManager#next_channel_id
+    # @see ChannelManager#release_channel_id
+    def allocated_channel_id?(i)
+      @mutex.synchronize do
+        @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
+      @mutex.synchronize do
+        @allocator.reset
+      end
+    end
+
+    # @private
+    def synchronize(&block)
+      @mutex.synchronize(&block)
+    end
+  end
+end

data/lib/gorgon_bunny/lib/gorgon_bunny/compatibility.rb

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

data/lib/gorgon_bunny/lib/gorgon_bunny/concurrent/atomic_fixnum.rb

@@ -0,0 +1,74 @@
+require "set"
+require "thread"
+require "monitor"
+
+module GorgonBunny
+  module Concurrent
+    # Minimalistic implementation of a synchronized fixnum value,
+    # designed after (but not implementing the entire API of!)
+    #
+    # @note Designed to be intentionally minimalistic and only cover GorgonBunny's needs.
+    #
+    # @api public
+    class AtomicFixnum
+      def initialize(n = 0)
+        @n     = n
+        @mutex = Monitor.new
+      end
+
+      def get
+        @mutex.synchronize do
+          @n
+        end
+      end
+
+      def set(n)
+        @mutex.synchronize do
+          @n = n
+        end
+      end
+
+      def increment
+        @mutex.synchronize do
+          @n = @n + 1
+        end
+      end
+      alias inc increment
+      alias increment_and_get increment
+
+      def get_and_add(i)
+        @mutex.synchronize do
+          v = @n
+          @n = @n + i
+
+          v
+        end
+      end
+
+      def get_and_increment
+        @mutex.synchronize do
+          v = @n
+          @n = @n + 1
+
+          v
+        end
+      end
+
+      def decrement
+        @mutex.synchronize do
+          @n = @n - 1
+        end
+      end
+      alias dec decrement
+      alias decrement_and_get decrement
+
+      def ==(m)
+        @mutex.synchronize { @n == m }
+      end
+
+      def ===(v)
+        @mutex.synchronize { @n === v }
+      end
+    end
+  end
+end

data/lib/gorgon_bunny/lib/gorgon_bunny/concurrent/condition.rb

@@ -0,0 +1,66 @@
+require "thread"
+require "monitor"
+
+module GorgonBunny
+  # @private
+  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.
+    # @private
+    class Condition
+      attr_reader :waiting_threads, :description
+
+
+      def initialize(description = nil)
+        @mutex           = Monitor.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/gorgon_bunny/lib/gorgon_bunny/concurrent/continuation_queue.rb

@@ -0,0 +1,41 @@
+require "thread"
+
+module GorgonBunny
+  module Concurrent
+    # Continuation queue implementation for MRI and Rubinius
+    #
+    # @private
+    class ContinuationQueue
+      def initialize(*args, &block)
+        @q = ::Queue.new(*args)
+      end
+
+      def push(*args)
+        @q.push(*args)
+      end
+      alias << push
+
+      def pop
+        @q.pop
+      end
+
+      def poll(timeout_in_ms = nil)
+        if timeout_in_ms
+          GorgonBunny::Timeout.timeout(timeout_in_ms / 1000, ::Timeout::Error) do
+            @q.pop
+          end
+        else
+          @q.pop
+        end
+      end
+
+      def clear
+        @q.clear
+      end
+
+      def method_missing(selector, *args, &block)
+        @q.__send__(selector, *args, &block)
+      end
+    end
+  end
+end

data/lib/gorgon_bunny/lib/gorgon_bunny/concurrent/linked_continuation_queue.rb

@@ -0,0 +1,61 @@
+if !defined?(JRUBY_VERSION)
+  raise "GorgonBunny::Concurrent::LinkedContinuationQueue can only be used on JRuby!"
+end
+
+require "java"
+
+java_import java.util.concurrent.LinkedBlockingQueue
+java_import java.util.concurrent.TimeUnit
+
+module GorgonBunny
+  module Concurrent
+    # Continuation queue implementation for JRuby.
+    #
+    # On JRuby, we'd rather use reliable and heavily battle tested j.u.c.
+    # primitives with well described semantics than informally specified, clumsy
+    # and limited Ruby standard library parts.
+    #
+    # This is an implementation of the continuation queue on top of the linked blocking
+    # queue in j.u.c.
+    #
+    # Compared to the Ruby standard library Queue, there is one limitation: you cannot
+    # push a nil on the queue, it will fail with a null pointer exception.
+    # @private
+    class LinkedContinuationQueue
+      def initialize(*args, &block)
+        @q = LinkedBlockingQueue.new
+      end
+
+      def push(el, timeout_in_ms = nil)
+        if timeout_in_ms
+          @q.offer(el, timeout_in_ms, TimeUnit::MILLISECONDS)
+        else
+          @q.offer(el)
+        end
+      end
+      alias << push
+
+      def pop
+        @q.take
+      end
+
+      def poll(timeout_in_ms = nil)
+        if timeout_in_ms
+          v = @q.poll(timeout_in_ms, TimeUnit::MILLISECONDS)
+          raise ::Timeout::Error.new("operation did not finish in #{timeout_in_ms} ms") if v.nil?
+          v
+        else
+          @q.poll
+        end
+      end
+
+      def clear
+        @q.clear
+      end
+
+      def method_missing(selector, *args, &block)
+        @q.__send__(selector, *args, &block)
+      end
+    end
+  end
+end

data/lib/gorgon_bunny/lib/gorgon_bunny/concurrent/synchronized_sorted_set.rb

@@ -0,0 +1,56 @@
+require "set"
+require "thread"
+
+module GorgonBunny
+  module Concurrent
+    # A SortedSet variation that synchronizes key mutation operations.
+    #
+    # @note This is NOT a complete SortedSet replacement. It only synchronizes operations needed by GorgonBunny.
+    # @api public
+    class SynchronizedSortedSet < SortedSet
+      def initialize(enum = nil)
+        @mutex = Mutex.new
+
+        super
+      end
+
+      def add(o)
+        # avoid using Mutex#synchronize because of a Ruby 1.8.7-specific
+        # bug that prevents super from being called from within a block. MK.
+        @mutex.lock
+        begin
+          super
+        ensure
+          @mutex.unlock
+        end
+      end
+
+      def delete(o)
+        @mutex.lock
+        begin
+          super
+        ensure
+          @mutex.unlock
+        end
+      end
+
+      def delete_if(&block)
+        @mutex.lock
+        begin
+          super
+        ensure
+          @mutex.unlock
+        end
+      end
+
+      def include?(o)
+        @mutex.lock
+        begin
+          super
+        ensure
+          @mutex.unlock
+        end
+      end
+    end
+  end
+end

data/lib/gorgon_bunny/lib/gorgon_bunny/consumer.rb

@@ -0,0 +1,123 @@
+module GorgonBunny
+  # 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
+  # you are interested in is message deliveries, it is recommended to just use
+  # {GorgonBunny::Queue#subscribe} instead of subclassing this class.
+  #
+  # @see GorgonBunny::Queue#subscribe
+  # @see GorgonBunny::Queue#subscribe_with
+  # @see http://rubybunny.info/articles/queues.html Queues and Consumers guide
+  # @api public
+  class Consumer
+
+    #
+    # API
+    #
+
+    attr_reader   :channel
+    attr_reader   :queue
+    attr_accessor :consumer_tag
+    attr_reader   :arguments
+    attr_reader   :no_ack
+    attr_reader   :exclusive
+
+
+    # @param [GorgonBunny::Channel] channel Channel this consumer will use
+    # @param [GorgonBunny::Queue,String] queue Queue messages will be consumed from
+    # @param [String] consumer_tag Consumer tag (unique identifier). Generally it is better to let GorgonBunny generate one.
+    #                              Empty string means RabbitMQ will generate consumer tag.
+    # @param [Boolean] no_ack (true) If true, delivered messages will be automatically acknowledged.
+    #                                 If false, manual acknowledgements will be necessary.
+    # @param [Boolean] exclusive (false) Should this consumer be exclusive?
+    # @param [Hash] arguments (nil) Optional arguments that may be used by RabbitMQ extensions, etc
+    # @api public
+    def initialize(channel, queue, consumer_tag = channel.generate_consumer_tag, no_ack = true, exclusive = false, arguments = {})
+      @channel       = channel || raise(ArgumentError, "channel is nil")
+      @queue         = queue   || raise(ArgumentError, "queue is nil")
+      @consumer_tag  = consumer_tag
+      @exclusive     = exclusive
+      @arguments     = arguments
+      # no_ack set to true = no manual ack = automatic ack. MK.
+      @no_ack        = no_ack
+    end
+
+    # Defines message delivery handler
+    # @api public
+    def on_delivery(&block)
+      @on_delivery = block
+      self
+    end
+
+    # Invokes message delivery handler
+    # @private
+    def call(*args)
+      @on_delivery.call(*args) if @on_delivery
+    end
+    alias handle_delivery call
+
+    # Defines consumer cancellation notification handler
+    #
+    # @see http://rubybunny.info/articles/queues.html Queues and Consumers guide
+    # @see http://rubybunny.info/articles/extensions.html RabbitMQ Extensions guide
+    # @api public
+    def 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
+    end
+
+    # Cancels this consumer. Messages for this consumer will no longer be delivered. If the queue
+    # it was on is auto-deleted and this consumer was the last one, the queue will be deleted.
+    #
+    # @see http://rubybunny.info/articles/queues.html Queues and Consumers guide
+    # @api public
+    def cancel
+      @channel.basic_cancel(@consumer_tag)
+    end
+
+    # @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}>"
+    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}>"
+    end
+
+    # @return [Boolean] true if this consumer uses automatic acknowledgement mode
+    # @api public
+    def automatic_acknowledgement?
+      @no_ack == true
+    end
+
+    # @return [Boolean] true if this consumer uses manual (explicit) acknowledgement mode
+    # @api public
+    def manual_acknowledgement?
+      @no_ack == false
+    end
+
+    #
+    # Recovery
+    #
+
+    # @private
+    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