garaio_bunny 2.19.1

data/lib/bunny/exchange.rb

@@ -0,0 +1,275 @@
+require 'amq/protocol'
+
+module Bunny
+  # Represents AMQP 0.9.1 exchanges.
+  #
+  # @see http://rubybunny.info/articles/exchanges.html Exchanges and Publishing guide
+  # @see http://rubybunny.info/articles/extensions.html RabbitMQ Extensions guide
+  class Exchange
+
+    #
+    # API
+    #
+
+    # @return [Bunny::Channel]
+    attr_reader :channel
+
+    # @return [String]
+    attr_reader :name
+
+    # Type of this exchange (one of: :direct, :fanout, :topic, :headers).
+    # @return [Symbol]
+    attr_reader :type
+
+    # @return [Symbol]
+    # @api plugin
+    attr_reader :status
+
+    # Options hash this exchange instance was instantiated with
+    # @return [Hash]
+    attr_accessor :opts
+
+
+    # The default exchange. This exchange is a direct exchange that is predefined by the broker
+    # and that cannot be removed. Every queue is bound to this exchange by default with
+    # the following routing semantics: messages will be routed to the queue with the same
+    # name as the message's routing key. In other words, if a message is published with
+    # a routing key of "weather.usa.ca.sandiego" and there is a queue with this name,
+    # the message will be routed to the queue.
+    #
+    # @param [Bunny::Channel] channel_or_connection Channel to use. {Bunny::Session} instances
+    #                                               are only supported for backwards compatibility.
+    #
+    # @example Publishing a messages to the tasks queue
+    #   channel     = Bunny::Channel.new(connection)
+    #   tasks_queue = channel.queue("tasks")
+    #   Bunny::Exchange.default(channel).publish("make clean", :routing_key => "tasks")
+    #
+    # @see http://rubybunny.info/articles/exchanges.html Exchanges and Publishing guide
+    # @see http://www.rabbitmq.com/resources/specs/amqp0-9-1.pdf AMQP 0.9.1 specification (Section 2.1.2.4)
+    # @note Do not confuse the default exchange with amq.direct: amq.direct is a pre-defined direct
+    #       exchange that doesn't have any special routing semantics.
+    # @return [Exchange] An instance that corresponds to the default exchange (of type direct).
+    # @api public
+    def self.default(channel_or_connection)
+      self.new(channel_or_connection, :direct, AMQ::Protocol::EMPTY_STRING, :no_declare => true)
+    end
+
+    # @param [Bunny::Channel] channel Channel this exchange will use.
+    # @param [Symbol,String] type     Exchange type
+    # @param [String] name            Exchange name
+    # @param [Hash] opts              Exchange properties
+    #
+    # @option opts [Boolean] :durable (false)      Should this exchange be durable?
+    # @option opts [Boolean] :auto_delete (false)  Should this exchange be automatically deleted when it is no longer used?
+    # @option opts [Boolean] :arguments ({})       Additional optional arguments (typically used by RabbitMQ extensions and plugins)
+    #
+    # @see Bunny::Channel#topic
+    # @see Bunny::Channel#fanout
+    # @see Bunny::Channel#direct
+    # @see Bunny::Channel#headers
+    # @see http://rubybunny.info/articles/exchanges.html Exchanges and Publishing guide
+    # @see http://rubybunny.info/articles/extensions.html RabbitMQ Extensions guide
+    # @api public
+    def initialize(channel, type, name, opts = {})
+      @channel          = channel
+      @name             = name
+      @type             = type
+      @options          = self.class.add_default_options(name, opts)
+
+      @durable          = @options[:durable]
+      @auto_delete      = @options[:auto_delete]
+      @internal         = @options[:internal]
+      @arguments        = @options[:arguments]
+
+      @bindings         = Set.new
+
+      declare! unless opts[:no_declare] || predeclared? || (@name == AMQ::Protocol::EMPTY_STRING)
+
+      @channel.register_exchange(self)
+    end
+
+    # @return [Boolean] true if this exchange was declared as durable (will survive broker restart).
+    # @api public
+    def durable?
+      @durable
+    end # durable?
+
+    # @return [Boolean] true if this exchange was declared as automatically deleted (deleted as soon as last consumer unbinds).
+    # @api public
+    def auto_delete?
+      @auto_delete
+    end # auto_delete?
+
+    # @return [Boolean] true if this exchange is internal (used solely for exchange-to-exchange
+    #                   bindings and cannot be published to by clients)
+    def internal?
+      @internal
+    end
+
+    # @return [Hash] Additional optional arguments (typically used by RabbitMQ extensions and plugins)
+    # @api public
+    def arguments
+      @arguments
+    end
+
+
+    # Publishes a message
+    #
+    # @param [String] payload Message payload. It will never be modified by Bunny or RabbitMQ in any way.
+    # @param [Hash] opts Message properties (metadata) and delivery settings
+    #
+    # @option opts [String] :routing_key Routing key
+    # @option opts [Boolean] :persistent Should the message be persisted to disk?
+    # @option opts [Boolean] :mandatory Should the message be returned if it cannot be routed to any queue?
+    # @option opts [Integer] :timestamp A timestamp associated with this message
+    # @option opts [Integer] :expiration Expiration time after which the message will be deleted
+    # @option opts [String] :type Message type, e.g. what type of event or command this message represents. Can be any string
+    # @option opts [String] :reply_to Queue name other apps should send the response to
+    # @option opts [String] :content_type Message content type (e.g. application/json)
+    # @option opts [String] :content_encoding Message content encoding (e.g. gzip)
+    # @option opts [String] :correlation_id Message correlated to this one, e.g. what request this message is a reply for
+    # @option opts [Integer] :priority Message priority, 0 to 9. Not used by RabbitMQ, only applications
+    # @option opts [String] :message_id Any message identifier
+    # @option opts [String] :user_id Optional user ID. Verified by RabbitMQ against the actual connection username
+    # @option opts [String] :app_id Optional application ID
+    #
+    # @return [Bunny::Exchange] Self
+    # @see http://rubybunny.info/articles/exchanges.html Exchanges and Publishing guide
+    # @api public
+    def publish(payload, opts = {})
+      @channel.basic_publish(payload, self.name, (opts.delete(:routing_key) || opts.delete(:key)), opts)
+
+      self
+    end
+
+
+    # Deletes the exchange unless it is predeclared
+    #
+    # @param [Hash] opts Options
+    #
+    # @option opts [Boolean] if_unused (false) Should this exchange be deleted only if it is no longer used
+    #
+    # @see http://rubybunny.info/articles/exchanges.html Exchanges and Publishing guide
+    # @api public
+    def delete(opts = {})
+      @channel.deregister_exchange(self)
+      @channel.exchange_delete(@name, opts) unless predeclared?
+    end
+
+    # Binds an exchange to another (source) exchange using exchange.bind AMQP 0.9.1 extension
+    # that RabbitMQ provides.
+    #
+    # @param [String] source Source exchange name
+    # @param [Hash] opts Options
+    #
+    # @option opts [String] routing_key (nil) Routing key used for binding
+    # @option opts [Hash] arguments ({}) Optional arguments
+    #
+    # @return [Bunny::Exchange] Self
+    # @see http://rubybunny.info/articles/exchanges.html Exchanges and Publishing guide
+    # @see http://rubybunny.info/articles/bindings.html Bindings guide
+    # @see http://rubybunny.info/articles/extensions.html RabbitMQ Extensions guide
+    # @api public
+    def bind(source, opts = {})
+      @channel.exchange_bind(source, self, opts)
+      @bindings.add(source: source, opts: opts)
+
+      self
+    end
+
+    # Unbinds an exchange from another (source) exchange using exchange.unbind AMQP 0.9.1 extension
+    # that RabbitMQ provides.
+    #
+    # @param [String] source Source exchange name
+    # @param [Hash] opts Options
+    #
+    # @option opts [String] routing_key (nil) Routing key used for binding
+    # @option opts [Hash] arguments ({}) Optional arguments
+    #
+    # @return [Bunny::Exchange] Self
+    # @see http://rubybunny.info/articles/exchanges.html Exchanges and Publishing guide
+    # @see http://rubybunny.info/articles/bindings.html Bindings guide
+    # @see http://rubybunny.info/articles/extensions.html RabbitMQ Extensions guide
+    # @api public
+    def unbind(source, opts = {})
+      @channel.exchange_unbind(source, self, opts)
+      @bindings.delete(source: source, opts: opts)
+
+      self
+    end
+
+    # Defines a block that will handle returned messages
+    # @see http://rubybunny.info/articles/exchanges.html
+    # @api public
+    def on_return(&block)
+      @on_return = block
+
+      self
+    end
+
+    # Waits until all outstanding publisher confirms on the channel
+    # arrive.
+    #
+    # This is a convenience method that delegates to {Bunny::Channel#wait_for_confirms}
+    #
+    # @api public
+    def wait_for_confirms
+      @channel.wait_for_confirms
+    end
+
+    # @private
+    def recover_from_network_failure
+      declare! unless @options[:no_declare] ||predefined?
+
+      @bindings.each do |b|
+        bind(b[:source], b[:opts])
+      end
+    end
+
+
+    #
+    # Implementation
+    #
+
+    # @private
+    def handle_return(basic_return, properties, content)
+      if @on_return
+        @on_return.call(basic_return, properties, content)
+      else
+        # TODO: log a warning
+      end
+    end
+
+    # @return [Boolean] true if this exchange is a pre-defined one (amq.direct, amq.fanout, amq.match and so on)
+    def predefined?
+      (@name == AMQ::Protocol::EMPTY_STRING) || !!(@name =~ /^amq\.(direct|fanout|topic|headers|match)/i)
+    end # predefined?
+    alias predeclared? predefined?
+
+    protected
+
+    # @private
+    def declare!
+      @channel.exchange_declare(@name, @type, @options)
+    end
+
+    # @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,
+          :auto_delete => false,
+          :internal    => false,
+          :arguments   => nil
+        }.merge(h)
+      else
+        h
+      end
+    end
+  end
+end

data/lib/bunny/framing.rb

@@ -0,0 +1,56 @@
+module Bunny
+  # @private
+  module Framing
+    ENCODINGS_SUPPORTED = defined? Encoding
+    HEADER_SLICE = (0..6).freeze
+    DATA_SLICE = (7..-1).freeze
+    PAYLOAD_SLICE = (0..-2).freeze
+
+    # @private
+    module String
+      class Frame < AMQ::Protocol::Frame
+        def self.decode(string)
+          header              = string[HEADER_SLICE]
+          type, channel, size = self.decode_header(header)
+          data                = string[DATA_SLICE]
+          payload             = data[PAYLOAD_SLICE]
+          frame_end           = data[-1, 1]
+
+          frame_end.force_encoding(AMQ::Protocol::Frame::FINAL_OCTET.encoding) if ENCODINGS_SUPPORTED
+
+          # 1) the size is miscalculated
+          if payload.bytesize != size
+            raise BadLengthError.new(size, payload.bytesize)
+          end
+
+          # 2) the size is OK, but the string doesn't end with FINAL_OCTET
+          raise NoFinalOctetError.new if frame_end != AMQ::Protocol::Frame::FINAL_OCTET
+
+          self.new(type, payload, channel)
+        end
+      end
+    end # String
+
+
+    # @private
+    module IO
+      class Frame < AMQ::Protocol::Frame
+        def self.decode(io)
+          header = io.read(7)
+          type, channel, size = self.decode_header(header)
+          data = io.read_fully(size + 1)
+          payload, frame_end = data[PAYLOAD_SLICE], data[-1, 1]
+
+          # 1) the size is miscalculated
+          if payload.bytesize != size
+            raise BadLengthError.new(size, payload.bytesize)
+          end
+
+          # 2) the size is OK, but the string doesn't end with FINAL_OCTET
+          raise NoFinalOctetError.new if frame_end != AMQ::Protocol::Frame::FINAL_OCTET
+          self.new(type, payload, channel)
+        end # self.from
+      end # Frame
+    end # IO
+  end # Framing
+end # Bunny

data/lib/bunny/get_response.rb

@@ -0,0 +1,83 @@
+require "bunny/versioned_delivery_tag"
+
+module Bunny
+  # Wraps {AMQ::Protocol::Basic::GetOk} to
+  # provide access to the delivery properties as immutable hash as
+  # well as methods.
+  class GetResponse
+
+    #
+    # Behaviors
+    #
+
+    include Enumerable
+
+    #
+    # API
+    #
+
+    # @return [Bunny::Channel] Channel this basic.get-ok response is on
+    attr_reader :channel
+
+    # @private
+    def initialize(get_ok, channel)
+      @get_ok = get_ok
+      @hash          = {
+        :delivery_tag => @get_ok.delivery_tag,
+        :redelivered  => @get_ok.redelivered,
+        :exchange     => @get_ok.exchange,
+        :routing_key  => @get_ok.routing_key,
+        :channel      => channel
+      }
+      @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] Delivery identifier that is used to acknowledge, reject and nack deliveries
+    def delivery_tag
+      @get_ok.delivery_tag
+    end
+
+    # @return [Boolean] true if this delivery is a redelivery (the message was requeued at least once)
+    def redelivered
+      @get_ok.redelivered
+    end
+    alias redelivered? redelivered
+
+    # @return [String] Name of the exchange this message was published to
+    def exchange
+      @get_ok.exchange
+    end
+
+    # @return [String] Routing key this message was published with
+    def routing_key
+      @get_ok.routing_key
+    end
+  end
+end

data/lib/bunny/heartbeat_sender.rb

@@ -0,0 +1,71 @@
+require "thread"
+require "amq/protocol/client"
+require "amq/protocol/frame"
+
+module Bunny
+  # Periodically sends heartbeats, keeping track of the last publishing activity.
+  #
+  # @private
+  class HeartbeatSender
+
+    #
+    # API
+    #
+
+    def initialize(transport, logger)
+      @transport = transport
+      @logger    = logger
+      @mutex     = Monitor.new
+
+      @last_activity_time = Time.now
+    end
+
+    def start(period = 30)
+      @mutex.synchronize do
+        # calculate interval as half the given period plus
+        # some compensation for Ruby's implementation inaccuracy
+        # (we cannot get at the nanos level the Java client uses, and
+        # our approach is simplistic). MK.
+        @interval = [(period / 2) - 1, 0.4].max
+
+        @thread = Thread.new(&method(:run))
+        @thread.report_on_exception = false if @thread.respond_to?(:report_on_exception)
+      end
+    end
+
+    def stop
+      @mutex.synchronize { @thread.exit }
+    end
+
+    def signal_activity!
+      @last_activity_time = Time.now
+    end
+
+    protected
+
+    def run
+      begin
+        loop do
+          self.beat
+
+          sleep @interval
+        end
+      rescue IOError => ioe
+        @logger.error "I/O error in the hearbeat sender: #{ioe.message}"
+        stop
+      rescue Exception => e
+        @logger.error "Error in the hearbeat sender: #{e.message}"
+        stop
+      end
+    end
+
+    def beat
+      now = Time.now
+
+      if now > (@last_activity_time + @interval)
+        @logger.debug { "Sending a heartbeat, last activity time: #{@last_activity_time}, interval (s): #{@interval}" }
+        @transport.write_without_timeout(AMQ::Protocol::HeartbeatFrame.encode, true)
+      end
+    end
+  end
+end

data/lib/bunny/jruby/socket.rb

@@ -0,0 +1,57 @@
+require "bunny/cruby/socket"
+
+module Bunny
+  module JRuby
+    # TCP socket extension that uses Socket#readpartial to avoid excessive CPU
+    # burn after some time. See issue #165.
+    # @private
+    module Socket
+      include Bunny::Socket
+
+      def self.open(host, port, options = {})
+        socket = ::Socket.tcp(host, port, nil, nil,
+                              connect_timeout: options[:connect_timeout])
+        if ::Socket.constants.include?('TCP_NODELAY') || ::Socket.constants.include?(:TCP_NODELAY)
+          socket.setsockopt(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, true)
+        end
+        socket.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_KEEPALIVE, true) if options.fetch(:keepalive, true)
+        socket.extend self
+        socket.options = { :host => host, :port => port }.merge(options)
+        socket
+      rescue Errno::ETIMEDOUT
+        raise ClientTimeout
+      end
+
+      # Reads given number of bytes with an optional timeout
+      #
+      # @param [Integer] count How many bytes to read
+      # @param [Integer] timeout Timeout
+      #
+      # @return [String] Data read from the socket
+      # @api public
+      def read_fully(count, timeout = nil)
+        value = ''
+
+        begin
+          loop do
+            value << read_nonblock(count - value.bytesize)
+            break if value.bytesize >= count
+          end
+        rescue EOFError
+          # JRuby specific fix via https://github.com/jruby/jruby/issues/1694#issuecomment-54873532
+          IO.select([self], nil, nil, timeout)
+          retry
+        rescue *READ_RETRY_EXCEPTION_CLASSES
+          if IO.select([self], nil, nil, timeout)
+            retry
+          else
+            raise Timeout::Error, "IO timeout when reading #{count} bytes"
+          end
+        end
+
+        value
+      end # read_fully
+
+    end
+  end
+end

data/lib/bunny/jruby/ssl_socket.rb

@@ -0,0 +1,58 @@
+module Bunny
+  module JRuby
+    begin
+      require "bunny/cruby/ssl_socket"
+      require "openssl"
+
+      # TLS-enabled TCP socket that implements convenience
+      # methods found in Bunny::Socket.
+      class SSLSocket < Bunny::SSLSocket
+
+        def initialize(*args)
+          super
+          @__bunny_socket_eof_flag__ = false
+        end
+
+        # Reads given number of bytes with an optional timeout
+        #
+        # @param [Integer] count How many bytes to read
+        # @param [Integer] timeout Timeout
+        #
+        # @return [String] Data read from the socket
+        # @api public
+        def read_fully(count, timeout = nil)
+          return nil if @__bunny_socket_eof_flag__
+
+          value = ''
+          begin
+            loop do
+              value << read_nonblock(count - value.bytesize)
+              break if value.bytesize >= count
+            end
+          rescue EOFError => e
+            @__bunny_socket_eof_flag__ = true
+          rescue OpenSSL::SSL::SSLError => e
+            if e.message == "read would block"
+              if IO.select([self], nil, nil, timeout)
+                retry
+              else
+                raise Timeout::Error, "IO timeout when reading #{count} bytes"
+              end
+            else
+              raise e
+            end
+          rescue *READ_RETRY_EXCEPTION_CLASSES => e
+            if IO.select([self], nil, nil, timeout)
+              retry
+            else
+              raise Timeout::Error, "IO timeout when reading #{count} bytes"
+            end
+          end
+          value
+        end
+      end
+    rescue LoadError => le
+      puts "Could not load OpenSSL"
+    end
+  end
+end