garaio_bunny 2.19.1

data/lib/bunny/message_properties.rb

@@ -0,0 +1,119 @@
+module Bunny
+  # Wraps basic properties hash as returned by amq-protocol to
+  # provide access to the delivery properties as immutable hash as
+  # well as methods.
+  class MessageProperties
+
+    #
+    # Behaviors
+    #
+
+    include Enumerable
+
+    #
+    # API
+    #
+
+    # @private
+    def initialize(properties)
+      @properties = properties
+    end
+
+    # Iterates over the message properties
+    # @see Enumerable#each
+    def each(*args, &block)
+      @properties.each(*args, &block)
+    end
+
+    # Accesses message properties by key
+    # @see Hash#[]
+    def [](k)
+      @properties[k]
+    end
+
+    # @return [Hash] Hash representation of this delivery info
+    def to_hash
+      @properties
+    end
+
+    # @private
+    def to_s
+      to_hash.to_s
+    end
+
+    # @private
+    def inspect
+      to_hash.inspect
+    end
+
+    # @return [String] (Optional) content type of the message, as set by the publisher
+    def content_type
+      @properties[:content_type]
+    end
+
+    # @return [String] (Optional) content encoding of the message, as set by the publisher
+    def content_encoding
+      @properties[:content_encoding]
+    end
+
+    # @return [String] Message headers
+    def headers
+      @properties[:headers]
+    end
+
+    # @return [Integer] Delivery mode (persistent or transient)
+    def delivery_mode
+      @properties[:delivery_mode]
+    end
+
+    # @return [Integer] Message priority, as set by the publisher
+    def priority
+      @properties[:priority]
+    end
+
+    # @return [String] What message this message is a reply to (or corresponds to), as set by the publisher
+    def correlation_id
+      @properties[:correlation_id]
+    end
+
+    # @return [String] (Optional) How to reply to the publisher (usually a reply queue name)
+    def reply_to
+      @properties[:reply_to]
+    end
+
+    # @return [String] Message expiration, as set by the publisher
+    def expiration
+      @properties[:expiration]
+    end
+
+    # @return [String] Message ID, as set by the publisher
+    def message_id
+      @properties[:message_id]
+    end
+
+    # @return [Time] Message timestamp, as set by the publisher
+    def timestamp
+      @properties[:timestamp]
+    end
+
+    # @return [String] Message type, as set by the publisher
+    def type
+      @properties[:type]
+    end
+
+    # @return [String] Publishing user, as set by the publisher
+    def user_id
+      @properties[:user_id]
+    end
+
+    # @return [String] Publishing application, as set by the publisher
+    def app_id
+      @properties[:app_id]
+    end
+
+    # @return [String] Cluster ID, as set by the publisher
+    def cluster_id
+      @properties[:cluster_id]
+    end
+  end
+end

data/lib/bunny/queue.rb

@@ -0,0 +1,393 @@
+require "bunny/get_response"
+
+module Bunny
+  # Represents AMQP 0.9.1 queue.
+  #
+  # @see http://rubybunny.info/articles/queues.html Queues and Consumers guide
+  # @see http://rubybunny.info/articles/extensions.html RabbitMQ Extensions guide
+  class Queue
+
+    #
+    # API
+    #
+
+    # @return [Bunny::Channel] Channel this queue uses
+    attr_reader :channel
+    # @return [String] Queue name
+    attr_reader :name
+    # @return [Hash] Options this queue was created with
+    attr_reader :options
+
+    # @param [Bunny::Channel] channel Channel this queue will use.
+    # @param [String] name                          Queue name. Pass an empty string to make RabbitMQ generate a unique one.
+    # @param [Hash] opts                            Queue properties
+    #
+    # @option opts [Boolean] :durable (false)      Should this queue be durable?
+    # @option opts [Boolean] :auto_delete (false)  Should this queue be automatically deleted when the last consumer disconnects?
+    # @option opts [Boolean] :exclusive (false)    Should this queue be exclusive (only can be used by this connection, removed when the connection is closed)?
+    # @option opts [Boolean] :arguments ({})       Additional optional arguments (typically used by RabbitMQ extensions and plugins)
+    #
+    # @see Bunny::Channel#queue
+    # @see http://rubybunny.info/articles/queues.html Queues and Consumers guide
+    # @see http://rubybunny.info/articles/extensions.html RabbitMQ Extensions guide
+    # @api public
+    def initialize(channel, name = AMQ::Protocol::EMPTY_STRING, opts = {})
+      # old Bunny versions pass a connection here. In that case,
+      # we just use default channel from it. MK.
+      @channel          = channel
+      @name             = name
+      @options          = self.class.add_default_options(name, opts)
+
+      @durable          = @options[:durable]
+      @exclusive        = @options[:exclusive]
+      @server_named     = @name.empty?
+      @auto_delete      = @options[:auto_delete]
+      @arguments        = @options[:arguments]
+
+      @bindings         = Array.new
+
+      @default_consumer = nil
+
+      declare! unless opts[:no_declare]
+
+      @channel.register_queue(self)
+    end
+
+    # @return [Boolean] true if this queue was declared as durable (will survive broker restart).
+    # @api public
+    # @see http://rubybunny.info/articles/queues.html Queues and Consumers guide
+    def durable?
+      @durable
+    end # durable?
+
+    # @return [Boolean] true if this queue was declared as exclusive (limited to just one consumer)
+    # @api public
+    # @see http://rubybunny.info/articles/queues.html Queues and Consumers guide
+    def exclusive?
+      @exclusive
+    end # exclusive?
+
+    # @return [Boolean] true if this queue was declared as automatically deleted (deleted as soon as last consumer unbinds).
+    # @api public
+    # @see http://rubybunny.info/articles/queues.html Queues and Consumers guide
+    def auto_delete?
+      @auto_delete
+    end # auto_delete?
+
+    # @return [Boolean] true if this queue was declared as server named.
+    # @api public
+    # @see http://rubybunny.info/articles/queues.html Queues and Consumers guide
+    def server_named?
+      @server_named
+    end # server_named?
+
+    # @return [Hash] Additional optional arguments (typically used by RabbitMQ extensions and plugins)
+    # @api public
+    def arguments
+      @arguments
+    end
+
+    def to_s
+      oid = ("0x%x" % (self.object_id << 1))
+      "<#{self.class.name}:#{oid} @name=\"#{name}\" channel=#{@channel.to_s} @durable=#{@durable} @auto_delete=#{@auto_delete} @exclusive=#{@exclusive} @arguments=#{@arguments}>"
+    end
+
+    def inspect
+      to_s
+    end
+
+    # Binds queue to an exchange
+    #
+    # @param [Bunny::Exchange,String] exchange Exchange to bind to
+    # @param [Hash] opts                       Binding properties
+    #
+    # @option opts [String] :routing_key  Routing key
+    # @option opts [Hash] :arguments ({}) Additional optional binding arguments
+    #
+    # @see http://rubybunny.info/articles/queues.html Queues and Consumers guide
+    # @see http://rubybunny.info/articles/bindings.html Bindings guide
+    # @api public
+    def bind(exchange, opts = {})
+      @channel.queue_bind(@name, exchange, opts)
+
+      exchange_name = if exchange.respond_to?(:name)
+                        exchange.name
+                      else
+                        exchange
+                      end
+
+
+      # store bindings for automatic recovery. We need to be very careful to
+      # not cause an infinite rebinding loop here when we recover. MK.
+      binding = { :exchange => exchange_name, :routing_key => (opts[:routing_key] || opts[:key]), :arguments => opts[:arguments] }
+      @bindings.push(binding) unless @bindings.include?(binding)
+
+      self
+    end
+
+    # Unbinds queue from an exchange
+    #
+    # @param [Bunny::Exchange,String] exchange Exchange to unbind from
+    # @param [Hash] opts                       Binding properties
+    #
+    # @option opts [String] :routing_key  Routing key
+    # @option opts [Hash] :arguments ({}) Additional optional binding arguments
+    #
+    # @see http://rubybunny.info/articles/queues.html Queues and Consumers guide
+    # @see http://rubybunny.info/articles/bindings.html Bindings guide
+    # @api public
+    def unbind(exchange, opts = {})
+      @channel.queue_unbind(@name, exchange, opts)
+
+      exchange_name = if exchange.respond_to?(:name)
+                        exchange.name
+                      else
+                        exchange
+                      end
+
+
+      @bindings.delete_if { |b| b[:exchange] == exchange_name && b[:routing_key] == (opts[:routing_key] || opts[:key]) && b[:arguments] == opts[:arguments] }
+
+      self
+    end
+
+    # Adds a consumer to the queue (subscribes for message deliveries).
+    #
+    # @param [Hash] opts Options
+    #
+    # @option opts [Boolean] :ack (false) [DEPRECATED] Use :manual_ack instead
+    # @option opts [Boolean] :manual_ack (false) Will this consumer use manual acknowledgements?
+    # @option opts [Boolean] :exclusive (false) Should this consumer be exclusive for this queue?
+    # @option opts [#call] :on_cancellation Block to execute when this consumer is cancelled remotely (e.g. via the RabbitMQ Management plugin)
+    # @option opts [String] :consumer_tag Unique consumer identifier. It is usually recommended to let Bunny generate it for you.
+    # @option opts [Hash] :arguments ({}) Additional (optional) arguments, typically used by RabbitMQ extensions
+    #
+    # @see http://rubybunny.info/articles/queues.html Queues and Consumers guide
+    # @api public
+    def subscribe(opts = {
+                    :consumer_tag    => @channel.generate_consumer_tag,
+                    :manual_ack      => false,
+                    :exclusive       => false,
+                    :block           => false,
+                    :on_cancellation => nil
+                  }, &block)
+
+      unless opts[:ack].nil?
+        warn "[DEPRECATION] `:ack` is deprecated.  Please use `:manual_ack` instead."
+        opts[:manual_ack] = opts[:ack]
+      end
+
+      ctag       = opts.fetch(:consumer_tag, @channel.generate_consumer_tag)
+      consumer   = Consumer.new(@channel,
+                                self,
+                                ctag,
+                                !opts[:manual_ack],
+                                opts[:exclusive],
+                                opts[:arguments])
+
+      consumer.on_delivery(&block)
+      consumer.on_cancellation(&opts[:on_cancellation]) if opts[:on_cancellation]
+
+      @channel.basic_consume_with(consumer)
+      if opts[:block]
+        # joins current thread with the consumers pool, will block
+        # the current thread for as long as the consumer pool is active
+        @channel.work_pool.join
+      end
+
+      consumer
+    end
+
+    # Adds a consumer object to the queue (subscribes for message deliveries).
+    #
+    # @param [Bunny::Consumer] consumer a {Bunny::Consumer} subclass that implements consumer interface
+    # @param [Hash] opts Options
+    #
+    # @option opts [Boolean] block (false) Should the call block calling thread?
+    #
+    # @see http://rubybunny.info/articles/queues.html Queues and Consumers guide
+    # @api public
+    def subscribe_with(consumer, opts = {:block => false})
+      @channel.basic_consume_with(consumer)
+
+      @channel.work_pool.join if opts[:block]
+      consumer
+    end
+
+    # @param [Hash] opts Options
+    #
+    # @option opts [Boolean] :ack (false) [DEPRECATED] Use :manual_ack instead
+    # @option opts [Boolean] :manual_ack (false) Will the message be acknowledged manually?
+    #
+    # @return [Array] Triple of delivery info, message properties and message content.
+    #                 If the queue is empty, all three will be nils.
+    # @see http://rubybunny.info/articles/queues.html Queues and Consumers guide
+    # @see Bunny::Queue#subscribe
+    # @api public
+    #
+    # @example
+    #   conn = Bunny.new
+    #   conn.start
+    #
+    #   ch   = conn.create_channel
+    #   q = ch.queue("test1")
+    #   x = ch.default_exchange
+    #   x.publish("Hello, everybody!", :routing_key => 'test1')
+    #
+    #   delivery_info, properties, payload = q.pop
+    #
+    #   puts "This is the message: " + payload + "\n\n"
+    #   conn.close
+    def pop(opts = {:manual_ack => false}, &block)
+      unless opts[:ack].nil?
+        warn "[DEPRECATION] `:ack` is deprecated.  Please use `:manual_ack` instead."
+        opts[:manual_ack] = opts[:ack]
+      end
+
+      get_response, properties, content = @channel.basic_get(@name, opts)
+
+      if block
+        if properties
+          di = GetResponse.new(get_response, @channel)
+          mp = MessageProperties.new(properties)
+
+          block.call(di, mp, content)
+        else
+          block.call(nil, nil, nil)
+        end
+      else
+        if properties
+          di = GetResponse.new(get_response, @channel)
+          mp = MessageProperties.new(properties)
+          [di, mp, content]
+        else
+          [nil, nil, nil]
+        end
+      end
+    end
+    alias get pop
+
+    # Publishes a message to the queue via default exchange. Takes the same arguments
+    # as {Bunny::Exchange#publish}
+    #
+    # @see Bunny::Exchange#publish
+    # @see Bunny::Channel#default_exchange
+    # @see http://rubybunny.info/articles/exchanges.html Exchanges and Publishing guide
+    def publish(payload, opts = {})
+      @channel.default_exchange.publish(payload, opts.merge(:routing_key => @name))
+
+      self
+    end
+
+
+    # Deletes the queue
+    #
+    # @param [Hash] opts Options
+    #
+    # @option opts [Boolean] if_unused (false) Should this queue be deleted only if it has no consumers?
+    # @option opts [Boolean] if_empty (false) Should this queue be deleted only if it has no messages?
+    #
+    # @see http://rubybunny.info/articles/queues.html Queues and Consumers guide
+    # @api public
+    def delete(opts = {})
+      @channel.deregister_queue(self)
+      @channel.queue_delete(@name, opts)
+    end
+
+    # Purges a queue (removes all messages from it)
+    # @see http://rubybunny.info/articles/queues.html Queues and Consumers guide
+    # @api public
+    def purge(opts = {})
+      @channel.queue_purge(@name, opts)
+
+      self
+    end
+
+    # @return [Hash] A hash with information about the number of queue messages and consumers
+    # @see #message_count
+    # @see #consumer_count
+    def status
+      queue_declare_ok = @channel.queue_declare(@name, @options.merge(:passive => true))
+      {:message_count => queue_declare_ok.message_count,
+        :consumer_count => queue_declare_ok.consumer_count}
+    end
+
+    # @return [Integer] How many messages the queue has ready (e.g. not delivered but not unacknowledged)
+    def message_count
+      s = self.status
+      s[:message_count]
+    end
+
+    # @return [Integer] How many active consumers the queue has
+    def consumer_count
+      s = self.status
+      s[:consumer_count]
+    end
+
+    #
+    # Recovery
+    #
+
+    # @private
+    def recover_from_network_failure
+      if self.server_named?
+        old_name = @name.dup
+        @name    = AMQ::Protocol::EMPTY_STRING
+
+        @channel.deregister_queue_named(old_name)
+      end
+
+      # TODO: inject and use logger
+      # puts "Recovering queue #{@name}"
+      begin
+        declare! unless @options[:no_declare]
+
+        @channel.register_queue(self)
+      rescue Exception => e
+        # TODO: inject and use logger
+        puts "Caught #{e.inspect} while redeclaring and registering #{@name}!"
+      end
+      recover_bindings
+    end
+
+    # @private
+    def recover_bindings
+      @bindings.each do |b|
+        # TODO: inject and use logger
+        # puts "Recovering binding #{b.inspect}"
+        self.bind(b[:exchange], b)
+      end
+    end
+
+
+    #
+    # Implementation
+    #
+
+    # @private
+    def declare!
+      queue_declare_ok = @channel.queue_declare(@name, @options)
+      @name = queue_declare_ok.queue
+    end
+
+    protected
+
+    # @private
+    def self.add_default_options(name, opts)
+      # :nowait is always false for Bunny
+      h = { :queue => name, :nowait => false }.merge(opts)
+
+      if name.empty?
+        {
+          :passive     => false,
+          :durable     => false,
+          :exclusive   => false,
+          :auto_delete => false,
+          :arguments   => nil
+        }.merge(h)
+      else
+        h
+      end
+    end
+  end
+end

data/lib/bunny/reader_loop.rb

@@ -0,0 +1,158 @@
+require "thread"
+
+module Bunny
+  # Network activity loop that reads and passes incoming AMQP 0.9.1 methods for
+  # processing. They are dispatched further down the line in Bunny::Session and Bunny::Channel.
+  # This loop uses a separate thread internally.
+  #
+  # This mimics the way RabbitMQ Java is designed quite closely.
+  # @private
+  class ReaderLoop
+
+    def initialize(transport, session, session_error_handler)
+      @transport             = transport
+      @session               = session
+      @session_error_handler = session_error_handler
+      @logger                = @session.logger
+
+      @mutex                 = Mutex.new
+
+      @stopping              = false
+      @stopped               = false
+      @network_is_down       = false
+    end
+
+
+    def start
+      @thread    = Thread.new(&method(:run_loop))
+    end
+
+    def resume
+      start
+    end
+
+
+    def run_loop
+      loop do
+        begin
+          break if @mutex.synchronize { @stopping || @stopped || @network_is_down }
+          run_once
+        rescue AMQ::Protocol::EmptyResponseError, IOError, SystemCallError, Timeout::Error,
+               OpenSSL::OpenSSLError => e
+          break if terminate? || @session.closing? || @session.closed?
+
+          @network_is_down = true
+          if @session.automatically_recover?
+            log_exception(e, level: :warn)
+            @session.handle_network_failure(e)
+          else
+            log_exception(e)
+            @session_error_handler.raise(Bunny::NetworkFailure.new("detected a network failure: #{e.message}", e))
+          end
+        rescue ShutdownSignal => _
+          @mutex.synchronize { @stopping = true }
+          break
+        rescue Exception => e
+          break if terminate?
+          if !(@session.closing? || @session.closed?)
+            log_exception(e)
+
+            @network_is_down = true
+            @session_error_handler.raise(Bunny::NetworkFailure.new("caught an unexpected exception in the network loop: #{e.message}", e))
+          end
+        rescue Errno::EBADF => _ebadf
+          break if terminate?
+          # ignored, happens when we loop after the transport has already been closed
+          @mutex.synchronize { @stopping = true }
+        end
+      end
+
+      @mutex.synchronize { @stopped = true }
+    end
+
+    def run_once
+      frame = @transport.read_next_frame
+      return if frame.is_a?(AMQ::Protocol::HeartbeatFrame)
+
+      if !frame.final? || frame.method_class.has_content?
+        header   = @transport.read_next_frame
+        content  = ''
+
+        if header.body_size > 0
+          loop do
+            body_frame = @transport.read_next_frame
+            content << body_frame.decode_payload
+
+            break if content.bytesize >= header.body_size
+          end
+        end
+
+        @session.handle_frameset(frame.channel, [frame.decode_payload, header.decode_payload, content])
+      else
+        @session.handle_frame(frame.channel, frame.decode_payload)
+      end
+    end
+
+    def stop
+      @mutex.synchronize { @stopping = true }
+    end
+
+    def stopped?
+      @mutex.synchronize { @stopped }
+    end
+
+    def stopping?
+      @mutex.synchronize { @stopping }
+    end
+
+    def terminate_with(e)
+      @mutex.synchronize { @stopping = true }
+
+      self.raise(e)
+    end
+
+    def raise(e)
+      @thread.raise(e) if @thread
+    end
+
+    def join
+      # Thread#join can/would trigger a re-raise of an unhandled exception in this thread.
+      # In addition, Thread.handle_interrupt can be used by other libraries or application code
+      # that would make this join operation fail with an obscure exception.
+      # So we try to save everyone some really unpleasant debugging time by introducing
+      # this condition which typically would not evaluate to true anyway.
+      #
+      # See ruby-amqp/bunny#589 and ruby-amqp/bunny#590 for background.
+      @thread.join if @thread && @thread != Thread.current
+    end
+
+    def kill
+      if @thread
+        @thread.kill
+        @thread.join
+      end
+    end
+
+    protected
+
+    def log_exception(e, level: :error)
+      if !(io_error?(e) && (@session.closing? || @session.closed?))
+        @logger.send level, "Exception in the reader loop: #{e.class.name}: #{e.message}"
+        @logger.send level, "Backtrace: "
+        e.backtrace.each do |line|
+          @logger.send level, "\t#{line}"
+        end
+      end
+    end
+
+    def io_error?(e)
+      [AMQ::Protocol::EmptyResponseError, IOError, SystemCallError].any? do |klazz|
+        e.is_a?(klazz)
+      end
+    end
+
+    def terminate?
+      @mutex.synchronize { @stopping || @stopped }
+    end
+  end
+end