garaio_bunny 2.19.1

data/lib/bunny/channel_id_allocator.rb

@@ -0,0 +1,82 @@
+require "thread"
+require "monitor"
+require "amq/int_allocator"
+
+module Bunny
+  # 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 << 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
+
+
+    # Returns next available channel id. This method is thread safe.
+    #
+    # @return [Integer]
+    # @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 [Integer] 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 [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
+    # @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/bunny/concurrent/atomic_fixnum.rb

@@ -0,0 +1,75 @@
+require "set"
+require "thread"
+require "monitor"
+
+module Bunny
+  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 Bunny's needs.
+    #
+    # @api public
+    class AtomicFixnum
+      def initialize(n = 0)
+        @n     = n
+        @mutex = Monitor.new
+      end
+
+      def get
+        @mutex.synchronize do
+          @n
+        end
+      end
+      alias to_i get
+
+      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/bunny/concurrent/condition.rb

@@ -0,0 +1,66 @@
+require "thread"
+require "monitor"
+
+module Bunny
+  # @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/bunny/concurrent/continuation_queue.rb

@@ -0,0 +1,62 @@
+require "thread"
+
+module Bunny
+  module Concurrent
+    # Continuation queue implementation for MRI and Rubinius
+    #
+    # @private
+    class ContinuationQueue
+      def initialize
+        @q    = []
+        @lock = ::Mutex.new
+        @cond = ::ConditionVariable.new
+      end
+
+      def push(item)
+        @lock.synchronize do
+          @q.push(item)
+          @cond.signal
+        end
+      end
+      alias << push
+
+      def pop
+        poll
+      end
+
+      def poll(timeout_in_ms = nil)
+        timeout = timeout_in_ms ? timeout_in_ms / 1000.0 : nil
+
+        @lock.synchronize do
+          timeout_strikes_at = Time.now.utc + (timeout || 0)
+          while @q.empty?
+            wait = if timeout
+                     timeout_strikes_at - Time.now.utc
+                   else
+                     nil
+                   end
+            @cond.wait(@lock, wait)
+            raise ::Timeout::Error if wait && Time.now.utc >= timeout_strikes_at
+          end
+          item = @q.shift
+          item
+        end
+      end
+
+      def clear
+        @lock.synchronize do
+          @q.clear
+        end
+      end
+
+      def empty?
+        @q.empty?
+      end
+
+      def size
+        @q.size
+      end
+      alias length size
+    end
+  end
+end

data/lib/bunny/concurrent/linked_continuation_queue.rb

@@ -0,0 +1,61 @@
+if !defined?(JRUBY_VERSION)
+  raise "Bunny::Concurrent::LinkedContinuationQueue can only be used on JRuby!"
+end
+
+require "java"
+
+java_import java.util.concurrent.LinkedBlockingQueue
+java_import java.util.concurrent.TimeUnit
+
+module Bunny
+  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/bunny/concurrent/synchronized_sorted_set.rb

@@ -0,0 +1,56 @@
+require "set"
+require "thread"
+
+module Bunny
+  module Concurrent
+    # A SortedSet variation that synchronizes key mutation operations.
+    #
+    # @note This is NOT a complete SortedSet replacement. It only synchronizes operations needed by Bunny.
+    # @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/bunny/consumer.rb

@@ -0,0 +1,128 @@
+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
+  # you are interested in is message deliveries, it is recommended to just use
+  # {Bunny::Queue#subscribe} instead of subclassing this class.
+  #
+  # @see Bunny::Queue#subscribe
+  # @see Bunny::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 [Bunny::Channel] channel Channel this consumer will use
+    # @param [Bunny::Queue,String] queue Queue messages will be consumed from
+    # @param [String] consumer_tag Consumer tag (unique identifier). Generally it is better to let Bunny 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
+
+      @on_cancellation = []
+    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.each do |fn|
+        fn.call(basic_cancel)
+      end
+    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
+
+    # @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
+    #
+
+    # @private
+    def recover_from_network_failure
+      @channel.basic_consume_with(self)
+    end
+  end
+end

data/lib/bunny/consumer_tag_generator.rb

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

@@ -0,0 +1,122 @@
+require "thread"
+
+module Bunny
+  # 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
+    attr_reader :abort_on_exception
+
+    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
+
+
+    def submit(callable = nil, &block)
+      @queue.push(callable || block)
+    end
+
+    def start
+      @threads = []
+
+      @size.times do
+        t = Thread.new(&method(:run_loop))
+        t.abort_on_exception = true if abort_on_exception
+        @threads << t
+      end
+
+      @running = true
+    end
+
+    def running?
+      @running
+    end
+
+    def backlog
+      @queue.length
+    end
+
+    def busy?
+      !@queue.empty?
+    end
+
+    def shutdown(wait_for_workers = false)
+      was_running = running?
+      @running = false
+
+      @size.times do
+        submit do |*args|
+          throw :terminate
+        end
+      end
+
+      return if !(wait_for_workers && @shutdown_timeout && was_running)
+
+      @shutdown_mutex.synchronize do
+        @shutdown_conditional.wait(@shutdown_mutex, @shutdown_timeout)
+      end
+    end
+
+    def join(timeout = nil)
+      (@threads || []).each { |t| t.join(timeout) }
+    end
+
+    def pause
+      @running = false
+      @paused = true
+    end
+
+    def resume
+      @running = true
+      @paused = false
+
+      @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
+          Thread.stop if @paused
+          callable = @queue.pop
+
+          begin
+            callable.call
+          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