bunny 0.8.0 → 0.9.0.pre1

data/lib/bunny/exchange.rb

@@ -1,166 +1,161 @@
-# encoding: utf-8
+require "bunny/compatibility"
 
 module Bunny
-
-  # *Exchanges* are the routing and distribution hub of AMQP. All messages that Bunny sends
-  # to an AMQP broker/server @have_to pass through an exchange in order to be routed to a
-  # destination queue. The AMQP specification defines the types of exchange that you can create.
-  #
-  # At the time of writing there are four (4) types of exchange defined:
-  #
-  # * @:direct@
-  # * @:fanout@
-  # * @:topic@
-  # * @:headers@
-  #
-  # AMQP-compliant brokers/servers are required to provide default exchanges for the @direct@ and
-  # @fanout@ exchange types. All default exchanges are prefixed with @'amq.'@, for example:
-  #
-  # * @amq.direct@
-  # * @amq.fanout@
-  # * @amq.topic@
-  # * @amq.match@ or @amq.headers@
-  #
-  # If you want more information about exchanges, please consult the documentation for your
-  # target broker/server or visit the "AMQP website":http://www.amqp.org to find the version of the
-  # specification that applies to your target broker/server.
   class Exchange
 
-    attr_reader :client, :type, :name, :opts, :key
-
-    def initialize(client, name, opts = {})
-      # check connection to server
-      raise Bunny::ConnectionError, 'Not connected to server' if client.status == :not_connected
+    include Bunny::Compatibility
 
-      @client, @name, @opts = client, name, opts
 
-      # set up the exchange type catering for default names
-      if name =~ /^amq\.(.+)$/
-        predeclared = true
-        new_type = $1
-        # handle 'amq.match' default
-        new_type = 'headers' if new_type == 'match'
-        @type = new_type.to_sym
-      else
-        @type = opts[:type] || :direct
-      end
+    #
+    # API
+    #
 
-      @key = opts[:key]
-      @client.exchanges[@name] ||= self
+    # @return [Bunny::Channel]
+    attr_reader :channel
 
-      # ignore the :nowait option if passed, otherwise program will hang waiting for a
-      # response that will not be sent by the server
-      opts.delete(:nowait)
+    # @return [String]
+    attr_reader :name
 
-      unless predeclared or name == ''
-        opts = {
-          :exchange => name, :type => type, :nowait => false,
-          :deprecated_ticket => 0, :deprecated_auto_delete => false, :deprecated_internal => false
-        }.merge(opts)
+    # Type of this exchange (one of: :direct, :fanout, :topic, :headers).
+    # @return [Symbol]
+    attr_reader :type
 
-        client.send_frame(Qrack::Protocol::Exchange::Declare.new(opts))
+    # @return [Symbol]
+    # @api plugin
+    attr_reader :status
 
-        method = client.next_method
+    # Options hash this exchange instance was instantiated with
+    # @return [Hash]
+    attr_accessor :opts
 
-        client.check_response(method, Qrack::Protocol::Exchange::DeclareOk, "Error declaring exchange #{name}: type = #{type}")
-      end
-    end
 
-    # Requests that an exchange is deleted from broker/server. Removes reference from exchanges
-    # if successful. If an error occurs raises {Bunny::ProtocolError}.
+    # The default exchange. Default exchange is a direct exchange that is predefined.
+    # It cannot be removed. Every queue is bind to this (direct) exchange by default with
+    # the following routing semantics: messages will be routed to the queue withe same
+    # same name as 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 Q with this name,
+    # that message will be routed to Q.
     #
-    # @option opts [Boolean] :if_unused (false)
-    #   If set to @true@, the server will only delete the exchange if it has no queue bindings. If the exchange has queue bindings the server does not delete it but raises a channel exception instead.
+    # @param [Bunny::Channel] channel Channel to use.
     #
-    # @option opts [Boolean] :nowait (false)
-    #   Ignored by Bunny, always @false@.
+    # @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")
     #
-    # @return [Symbol] @:delete_ok@ if successful.
-    def delete(opts = {})
-      # ignore the :nowait option if passed, otherwise program will hang waiting for a
-      # response that will not be sent by the server
-      opts.delete(:nowait)
+    # @see Exchange
+    # @see http://files.travis-ci.org/docs/amqp/0.9.1/AMQP091Specification.pdf AMQP 0.9.1 specification (Section 2.1.2.4)
+    # @note Do not confuse 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_from(channel_or_connection), :direct, AMQ::Protocol::EMPTY_STRING, :no_declare => true)
+    end
+
+
+    def initialize(channel_or_connection, type, name, opts = {})
+      # old Bunny versions pass a connection here. In that case,
+      # we just use default channel from it. MK.
+      @channel          = channel_from(channel_or_connection)
+      @name             = name
+      @type             = type
+      @options          = self.class.add_default_options(name, opts)
 
-      opts = { :exchange => name, :nowait => false, :deprecated_ticket => 0 }.merge(opts)
+      @durable          = @options[:durable]
+      @auto_delete      = @options[:auto_delete]
+      @arguments        = @options[:arguments]
 
-      client.send_frame(Qrack::Protocol::Exchange::Delete.new(opts))
+      declare! unless opts[:no_declare] || (@name =~ /^amq\..+/) || (@name == AMQ::Protocol::EMPTY_STRING)
 
-      method = client.next_method
+      @channel.register_exchange(self)
+    end
 
-      client.check_response(method, Qrack::Protocol::Exchange::DeleteOk, "Error deleting exchange #{name}")
+    # @return [Boolean] true if this exchange was declared as durable (will survive broker restart).
+    # @api public
+    def durable?
+      @durable
+    end # durable?
 
-      client.exchanges.delete(name)
+    # @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 confirmation
-      :delete_ok
+    def arguments
+      @arguments
     end
 
-    # Publishes a message to a specific exchange. The message will be routed to queues as defined
-    # by the exchange configuration and distributed to any active consumers when the transaction,
-    # if any, is committed.
-    #
-    # @option opts [String] :key
-    #   Specifies the routing key for the message. The routing key is
-    #   used for routing messages depending on the exchange configuration.
-    #
-    # @option opts [String] :content_type
-    #   Specifies the content type for the message.
-    #
-    # @option opts [Boolean] :mandatory (false)
-    #   Tells the server how to react if the message cannot be routed to a queue.
-    #   If set to @true@, the server will return an unroutable message
-    #   with a Return method. If this flag is zero, the server silently drops the message.
-    #
-    # @option opts [Boolean] :immediate (false)
-    #   Tells the server how to react if the message cannot be routed to a queue consumer
-    #   immediately. If set to @true@, the server will return an undeliverable message with
-    #   a Return method. If set to @false@, the server will queue the message, but with no
-    #   guarantee that it will ever be consumed.
+
+
+    def publish(payload, opts = {})
+      @channel.basic_publish(payload, self.name, opts.delete(:routing_key), opts)
+
+      self
+    end
+
+
+    # Deletes the exchange
+    # @api public
+    def delete(opts = {})
+      @channel.exchange_delete(@name, opts)
+    end
+
+
+    def bind(source, opts = {})
+      @channel.exchange_bind(source, self, opts)
+    end
+
+    def unbind(source, opts = {})
+      @channel.exchange_unbind(source, self, opts)
+    end
+
+
+    def on_return(&block)
+      @on_return = block
+    end
+
+
     #
-    # @option opts [Boolean] :persistent (false)
-    #   Tells the server whether to persist the message. If set to @true@, the message will
-    #   be persisted to disk and not lost if the server restarts. If set to @false@, the message
-    #   will not be persisted across server restart. Setting to @true@ incurs a performance penalty
-    #   as there is an extra cost associated with disk access.
+    # Implementation
     #
-    # @return [NilClass] nil
-    def publish(data, opts = {})
-      opts = opts.dup
-      out = []
-
-
-      # Set up options
-      routing_key = opts.delete(:key) || key
-      mandatory = opts.delete(:mandatory)
-      immediate = opts.delete(:immediate)
-      delivery_mode = opts.delete(:persistent) ? 2 : 1
-      content_type = opts.delete(:content_type) || 'application/octet-stream'
-      reply_to = opts.delete(:reply_to)
-      correlation_id = opts.delete(:correlation_id)
-      user_id = opts.delete(:user_id)
-
-      out << Qrack::Protocol::Basic::Publish.new({ :exchange => name,
-                                                     :routing_key => routing_key,
-                                                     :mandatory => mandatory,
-                                                     :immediate => immediate,
-                                                     :deprecated_ticket => 0 })
-      data = data.to_s
-      out << Qrack::Protocol::Header.new(
-                                           Qrack::Protocol::Basic,
-                                           data.bytesize, {
-                                             :content_type  => content_type,
-                                             :delivery_mode => delivery_mode,
-                                             :reply_to => reply_to,
-                                             :correlation_id => correlation_id,
-                                             :user_id => user_id,
-                                             :priority      => 0
-                                           }.merge(opts)
-                                           )
-      out << Qrack::Transport::Body.new(data)
-
-      client.send_frame(*out)
+
+    def handle_return(basic_return, properties, content)
+      if @on_return
+        @on_return.call(basic_return, properties, content)
+      else
+        # TODO: log a warning
+      end
     end
 
-  end
+    protected
 
+    # @private
+    def declare!
+      @channel.exchange_declare(@name, @type, @options)
+    end
+
+    # @private
+    def self.add_default_options(name, opts, block)
+      { :exchange => name, :nowait => (block.nil? && !name.empty?) }.merge(opts)
+    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,
+          :arguments   => nil
+        }.merge(h)
+      else
+        h
+      end
+    end
+  end
 end

data/lib/bunny/framing.rb

@@ -0,0 +1,53 @@
+module Bunny
+  module Framing
+    ENCODINGS_SUPPORTED = defined? Encoding
+    HEADER_SLICE = (0..6).freeze
+    DATA_SLICE = (7..-1).freeze
+    PAYLOAD_SLICE = (0..-2).freeze
+
+    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
+
+
+    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/heartbeat_sender.rb

@@ -0,0 +1,59 @@
+require "thread"
+require "amq/protocol/client"
+require "amq/protocol/frame"
+
+module Bunny
+  class HeartbeatSender
+
+    #
+    # API
+    #
+
+    def initialize(transport)
+      @transport = transport
+      @mutex     = Mutex.new
+
+      @last_activity_time = Time.now
+    end
+
+    def start(period = 30)
+      @mutex.synchronize do
+        @period = period
+
+        @thread = Thread.new(&method(:run))
+      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 (@period / 2)
+        end
+      rescue IOError => ioe
+        # ignored
+      rescue Exception => e
+        puts e.message
+      end
+    end
+
+    def beat
+      now = Time.now
+
+      if now > (@last_activity_time + @period)
+        @transport.send_raw(AMQ::Protocol::HeartbeatFrame.encode)
+      end
+    end
+  end
+end

data/lib/bunny/main_loop.rb

@@ -0,0 +1,70 @@
+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.
+  class MainLoop
+
+    def initialize(transport, session)
+      @transport = transport
+      @session   = session
+    end
+
+
+    def start
+      @thread    = Thread.new(&method(:run_loop))
+    end
+
+    def run_loop
+      loop do
+        begin
+          break if @stopping
+
+          frame = @transport.read_next_frame
+          @session.signal_activity!
+
+          next 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
+        rescue Timeout::Error => te
+          # given that the server may be pushing data to us, timeout detection/handling
+          # should happen per operation and not in this loop
+        rescue Errno::EBADF => ebadf
+          # ignored, happens when we loop after the transport has already been closed
+        rescue Exception => e
+          puts e.class.name
+          puts e.message
+          puts e.backtrace
+        end
+      end
+    end
+
+    def stop
+      @stopping = true
+    end
+
+    def kill
+      @thread.kill
+      @thread.join
+    end
+  end
+end