sparqcode_bunny 0.0.1

data/lib/bunny/client09.rb

@@ -0,0 +1,374 @@
+# encoding: utf-8
+
+module Bunny
+
+  # The Client class provides the major Bunny API methods.
+  class Client09 < Qrack::Client
+
+    # Sets up a Bunny::Client object ready for connection to a broker.
+    # {Client.status} is set to @:not_connected@.
+    #
+    # @option opts [String] :host ("localhost")
+    # @option opts [Integer] :port (5672 or 5671 if :ssl set to true)
+    # @option opts [String] :vhost ("/")
+    # @option opts [String] :user ("guest")
+    # @option opts [String] :pass ("guest")
+    # @option opts [Boolean] :ssl (false)
+    #   If set to @true@, ssl encryption will be used and port will default to 5671.
+    # @option opts [Boolean] :verify_ssl (true)
+    #   If ssl is enabled, this will cause OpenSSL to validate
+    #   the server certificate unless this parameter is set to @false@.
+    # @option opts [String] :logfile (nil)
+    # @option opts [Boolean] :logging (false)
+    #   If set to @true@, session information is sent to STDOUT if @:logfile@
+    #   has not been specified. Otherwise, session information is written to @:logfile@.
+    # @option opts [Integer] :frame_max (131072)
+    #   Maximum frame size in bytes.
+    # @option opts [Integer] :channel_max (0)
+    #   Maximum number of channels. Defaults to 0 which means no maximum.
+    # @option opts [Integer] :heartbeat (0)
+    #   Number of seconds. Defaults to 0 which means no heartbeat.
+    # @option opts [Integer] :connect_timeout (5)
+    #   Number of seconds before {Qrack::ConnectionTimeout} is raised.@
+    def initialize(connection_string_or_opts = Hash.new, opts = Hash.new)
+      super
+      @spec = '0-9-1'
+      @port = self.__opts__[:port] || (self.__opts__[:ssl] ? Qrack::Protocol09::SSL_PORT : Qrack::Protocol09::PORT)
+    end
+
+    # Checks response from AMQP methods and takes appropriate action
+    def check_response(received_method, expected_method, err_msg, err_class = Bunny::ProtocolError)
+      case
+      when received_method.is_a?(Qrack::Protocol09::Connection::Close)
+        # Clean up the socket
+        close_socket
+
+        raise Bunny::ForcedConnectionCloseError, "Error Reply Code: #{received_method.reply_code}\nError Reply Text: #{received_method.reply_text}"
+
+      when received_method.is_a?(Qrack::Protocol09::Channel::Close)
+        # Clean up the channel
+        channel.active = false
+
+        raise Bunny::ForcedChannelCloseError, "Error Reply Code: #{received_method.reply_code}\nError Reply Text: #{received_method.reply_text}"
+
+      when !received_method.is_a?(expected_method)
+        raise err_class, err_msg
+
+      else
+        :response_ok
+      end
+    end
+
+    def close_connection
+      # Set client channel to zero
+      switch_channel(0)
+
+      send_frame(Qrack::Protocol09::Connection::Close.new(:reply_code => 200, :reply_text => 'Goodbye', :class_id => 0, :method_id => 0))
+
+      method = next_method
+
+      check_response(method, Qrack::Protocol09::Connection::CloseOk, "Error closing connection")
+
+    end
+
+    def create_channel
+      channels.each do |c|
+        return c if (!c.open? and c.number != 0)
+      end
+      # If no channel to re-use instantiate new one
+      Bunny::Channel09.new(self)
+    end
+
+    # Declares an exchange to the broker/server. If the exchange does not exist, a new one is created
+    # using the arguments passed in. If the exchange already exists, a reference to it is created, provided
+    # that the arguments passed in do not conflict with the existing attributes of the exchange. If an error
+    # occurs a _Bunny_::_ProtocolError_ is raised.
+    #
+    # @option opts [Symbol] :type (:direct)
+    #   One of :direct@, @:fanout@, @:topic@, or @:headers@.
+    #
+    # @option opts [Boolean] :passive
+    #   If set to @true@, the server will not create the exchange.
+    #   The client can use this to check whether an exchange exists without modifying the server state.
+    #
+    # @option opts [Boolean] :durable (false)
+    #   If set to @true@ when creating a new exchange, the exchange
+    #   will be marked as durable. Durable exchanges remain active
+    #   when a server restarts. Non-durable exchanges (transient exchanges)
+    #   are purged if/when a server restarts.
+    #
+    # @option opts [Boolean] :auto_delete (false)
+    #   If set to @true@, the exchange is deleted when all queues have finished using it.
+    #
+    # @option opts [Boolean] :nowait (false)
+    #   Ignored by Bunny, always @false@.
+    #
+    # @return [Bunny::Exchange09]
+    def exchange(name, opts = {})
+      exchanges[name] || Bunny::Exchange09.new(self, name, opts)
+    end
+
+    def init_connection
+      write(Qrack::Protocol09::HEADER)
+      write([0, Qrack::Protocol09::VERSION_MAJOR, Qrack::Protocol09::VERSION_MINOR, Qrack::Protocol09::REVISION].pack('C4'))
+
+      frame = next_frame
+      if frame.nil? or !frame.payload.is_a?(Qrack::Protocol09::Connection::Start)
+        raise Bunny::ProtocolError, 'Connection initiation failed'
+      end
+    end
+
+    def next_frame(opts = {})
+      frame = nil
+
+      case
+      when channel.frame_buffer.size > 0
+        frame = channel.frame_buffer.shift
+      when (timeout = opts[:timeout]) && timeout > 0
+        Bunny::Timer::timeout(timeout, Qrack::FrameTimeout) do
+          frame = Qrack::Transport09::Frame.parse(buffer)
+        end
+      else
+        frame = Qrack::Transport09::Frame.parse(buffer)
+      end
+
+      @logger.info("received") { frame } if @logging
+
+      raise Bunny::ConnectionError, 'No connection to server' if (frame.nil? and !connecting?)
+
+      # Monitor server activity and discard heartbeats
+      @message_in = true
+
+      case
+      when frame.is_a?(Qrack::Transport09::Heartbeat)
+        next_frame(opts)
+      when frame.nil?
+        frame
+      when ((frame.channel != channel.number) and (frame.channel != 0))
+        channel.frame_buffer << frame
+        next_frame(opts)
+      else
+        frame
+      end
+
+    end
+
+    def open_connection
+      client_props = { :platform => 'Ruby', :product => 'Bunny', :information => 'http://github.com/ruby-amqp/bunny', :version => VERSION }
+      start_opts = {
+        :client_properties => client_props,
+        :mechanism => 'PLAIN',
+        :response => "\0" + @user + "\0" + @pass,
+        :locale => 'en_US'
+      }
+      send_frame(Qrack::Protocol09::Connection::StartOk.new(start_opts))
+
+      frame = next_frame
+      raise Bunny::ProtocolError, "Connection failed - user: #{@user}" if frame.nil?
+
+      method = frame.payload
+
+      if method.is_a?(Qrack::Protocol09::Connection::Tune)
+        send_frame(Qrack::Protocol09::Connection::TuneOk.new(:channel_max => @channel_max, :frame_max => @frame_max, :heartbeat => @heartbeat))
+      end
+
+      send_frame(Qrack::Protocol09::Connection::Open.new(:virtual_host => @vhost, :reserved_1 => 0, :reserved_2 => false))
+
+      raise Bunny::ProtocolError, 'Cannot open connection' unless next_method.is_a?(Qrack::Protocol09::Connection::OpenOk)
+    end
+
+    # Requests a specific quality of service. The QoS can be specified for the current channel
+    # or for all channels on the connection. The particular properties and semantics of a QoS
+    # method always depend on the content class semantics. Though the QoS method could in principle
+    # apply to both peers, it is currently meaningful only for the server.
+    #
+    # @option opts [Integer] :prefetch_size (0)
+    #   Size in number of octets. The client can request that messages be sent in advance
+    #   so that when the client finishes processing a message, the following message is
+    #   already held locally, rather than needing to be sent down the channel. refetching
+    #   gives a performance improvement. This field specifies the prefetch window size
+    #   in octets. The server will send a message in advance if it is equal to or smaller
+    #   in size than the available prefetch size (and also falls into other prefetch limits).
+    #   May be set to zero, meaning "no specific limit", although other prefetch limits may
+    #   still apply. The prefetch-size is ignored if the no-ack option is set.
+    #
+    # @option opts [Integer] :prefetch_count (1)
+    #   Number of messages to prefetch. Specifies a prefetch window in terms of whole messages.
+    #   This field may be used in combination with the prefetch-size field; a message will only
+    #   be sent in advance if both prefetch windows (and those at the channel and connection level)
+    #   allow it. The prefetch-count is ignored if the no-ack option is set.
+    #
+    # @option opts [Boolean] :global (false)
+    #   By default the QoS settings apply to the current channel only. If set to true,
+    #   they are applied to the entire connection.
+    #
+    # @return [Symbol] @:qos_ok@ if successful.
+    def qos(opts = {})
+      send_frame(Qrack::Protocol09::Basic::Qos.new({ :prefetch_size => 0, :prefetch_count => 1, :global => false }.merge(opts)))
+
+      method = next_method
+
+      check_response(method, Qrack::Protocol09::Basic::QosOk, "Error specifying Quality of Service")
+
+      # return confirmation
+      :qos_ok
+    end
+
+    # Declares a queue to the broker/server. If the queue does not exist, a new one is created
+    # using the arguments passed in. If the queue already exists, a reference to it is created, provided
+    # that the arguments passed in do not conflict with the existing attributes of the queue. If an error
+    # occurs a {Bunny::ProtocolError} is raised.
+    #
+    # @option opts [Boolean] :passive (false)
+    #   If set to @true@, the server will not create the queue. The client can use this to check
+    #   whether a queue exists without modifying the server state.
+    #
+    # @option opts [Boolean] :durable (false)
+    #   If set to @true@ when creating a new queue, the queue will be marked as durable.
+    #   Durable queues remain active when a server restarts. Non-durable queues (transient ones)
+    #   are purged if/when a server restarts. Note that durable queues do not necessarily hold
+    #   persistent messages, although it does not make sense to send persistent messages
+    #   to a transient queue.
+    #
+    # @option opts [Boolean] :exclusive (false)
+    #   If set to @true@, requests an exclusive queue. Exclusive queues may only be consumed
+    #   from by the current connection. Setting the 'exclusive' flag always implies 'auto-delete'.
+    #
+    # @option opts [Boolean] :auto_delete (false)
+    #   If set to @true@, the queue is deleted when all consumers have finished using it.
+    #   Last consumer can be cancelled either explicitly or because its channel is closed.
+    #   If there has never been a consumer on the queue, it is not deleted.
+    #
+    # @option opts [Boolean] :nowait (false)
+    #   Ignored by Bunny, always @false@.
+    #
+    # @return [Bunny::Queue09]
+    def queue(name = nil, opts = {})
+      if name.is_a?(Hash)
+        opts = name
+        name = nil
+      end
+
+      # Queue is responsible for placing itself in the list of queues
+      queues[name] || Bunny::Queue09.new(self, name, opts)
+    end
+
+    # Asks the broker to redeliver all unacknowledged messages on a specified channel. Zero or
+    # more messages may be redelivered.
+    #
+    # @option opts [Boolean] :requeue (false)
+    #   If set to @false@, the message will be redelivered to the original recipient.
+    #   If set to @true@, the server will attempt to requeue the message, potentially
+    #   then delivering it to an alternative subscriber.
+    def recover(opts = {})
+      send_frame(Qrack::Protocol09::Basic::Recover.new({ :requeue => false }.merge(opts)))
+    end
+
+    def send_frame(*args)
+      args.each do |data|
+        data         = data.to_frame(channel.number) unless data.is_a?(Qrack::Transport09::Frame)
+        data.channel = channel.number
+
+        @logger.info("send") { data } if @logging
+        write(data.to_s)
+
+        # Monitor client activity for heartbeat purposes
+        @message_out = true
+      end
+
+      nil
+    end
+
+    def send_heartbeat
+      # Create a new heartbeat frame
+      hb = Qrack::Transport09::Heartbeat.new('')
+      # Channel 0 must be used
+      switch_channel(0) if @channel.number > 0
+      # Send the heartbeat to server
+      send_frame(hb)
+    end
+
+    # Opens a communication channel and starts a connection. If an error occurs, a
+    # {Bunny::ProtocolError} is raised. If successful, {Client.status} is set to @:connected@.
+    #
+    # @return [Symbol] @:connected@ if successful.
+    def start_session
+      @connecting = true
+
+      # Create/get socket
+      socket
+
+      # Initiate connection
+      init_connection
+
+      # Open connection
+      open_connection
+
+      # Open another channel because channel zero is used for specific purposes
+      c = create_channel()
+      c.open
+
+      @connecting = false
+
+      # return status
+      @status = :connected
+    end
+
+    alias start start_session
+
+    # This method commits all messages published and acknowledged in
+    # the current transaction. A new transaction starts immediately
+    # after a commit.
+    #
+    # @return [Symbol] @:commit_ok@ if successful.
+    def tx_commit
+      send_frame(Qrack::Protocol09::Tx::Commit.new())
+
+      method = next_method
+
+      check_response(method, Qrack::Protocol09::Tx::CommitOk, "Error commiting transaction")
+
+      # return confirmation
+      :commit_ok
+    end
+
+    # This method abandons all messages published and acknowledged in
+    # the current transaction. A new transaction starts immediately
+    # after a rollback.
+    #
+    # @return [Symbol] @:rollback_ok@ if successful.
+    def tx_rollback
+      send_frame(Qrack::Protocol09::Tx::Rollback.new())
+
+      method = next_method
+
+      check_response(method, Qrack::Protocol09::Tx::RollbackOk, "Error rolling back transaction")
+
+      # return confirmation
+      :rollback_ok
+    end
+
+    # This method sets the channel to use standard transactions. The
+    # client must use this method at least once on a channel before
+    # using the Commit or Rollback methods.
+    #
+    # @return [Symbol] @:select_ok@ if successful.
+    def tx_select
+      send_frame(Qrack::Protocol09::Tx::Select.new())
+
+      method = next_method
+
+      check_response(method, Qrack::Protocol09::Tx::SelectOk, "Error initiating transactions for current channel")
+
+      # return confirmation
+      :select_ok
+    end
+
+    private
+
+    def buffer
+      @buffer ||= Qrack::Transport09::Buffer.new(self)
+    end
+
+  end
+end

data/lib/bunny/consumer.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+####################################
+# NOTE: THIS CLASS IS HERE TO MAKE #
+# TRANSITION TO AMQ CLIENT EASIER  #
+####################################
+
+require "qrack/subscription"
+
+# NOTE: This file is rather a temporary hack to fix
+# https://github.com/ruby-amqp/bunny/issues/9 then
+# some permanent solution. It's mostly copied from
+# the AMQP and AMQ Client gems. Later on we should
+# use AMQ Client directly and just inherit from
+# the AMQ::Client::Sync::Consumer class.
+
+module Bunny
+
+  # AMQP consumers are entities that handle messages delivered
+  # to them ("push API" as opposed to "pull API") by AMQP broker.
+  # Every consumer is associated with a queue. Consumers can be
+  # exclusive (no other consumers can be registered for the same
+  # queue) or not (consumers share the queue). In the case of
+  # multiple consumers per queue, messages are distributed in
+  # round robin manner with respect to channel-level prefetch
+  # setting).
+  class Consumer < Qrack::Subscription
+    def initialize(*args)
+      super(*args)
+      @consumer_tag ||= (1..32).to_a.shuffle.join
+    end
+
+    alias_method :consume, :start
+  end
+end

data/lib/bunny/exchange08.rb

@@ -0,0 +1,171 @@
+# encoding: utf-8
+
+module Bunny
+
+=begin rdoc
+
+=== DESCRIPTION:
+
+*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 -
+
+* <tt>:direct</tt>
+* <tt>:fanout</tt>
+* <tt>:topic</tt>
+* <tt>:headers</tt>
+
+AMQP-compliant brokers/servers are required to provide default exchanges for the _direct_ and
+_fanout_ exchange types. All default exchanges are prefixed with <tt>'amq.'</tt>, for example -
+
+* <tt>amq.direct</tt>
+* <tt>amq.fanout</tt>
+* <tt>amq.topic</tt>
+* <tt>amq.match</tt> or <tt>amq.headers</tt>
+
+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.
+
+=end
+
+  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
+
+      @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
+
+      @key = opts[:key]
+      @client.exchanges[@name] ||= self
+
+      # 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)
+
+      unless predeclared or name == ''
+        opts = { :exchange => name, :type => type, :nowait => false }.merge(opts)
+
+        client.send_frame(Qrack::Protocol::Exchange::Declare.new(opts))
+
+        method = client.next_method
+
+        client.check_response(method, Qrack::Protocol::Exchange::DeclareOk, "Error declaring exchange #{name}: type = #{type}")
+      end
+    end
+
+=begin rdoc
+
+=== DESCRIPTION:
+
+Requests that an exchange is deleted from broker/server. Removes reference from exchanges
+if successful. If an error occurs raises _Bunny_::_ProtocolError_.
+
+==== Options:
+
+* <tt>:if_unused => true or false (_default_)</tt> - 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.
+* <tt>:nowait => true or false (_default_)</tt> - Ignored by Bunny, always _false_.
+
+==== Returns:
+
+<tt>:delete_ok</tt> if successful
+=end
+
+    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)
+
+      client.send_frame(Qrack::Protocol::Exchange::Delete.new({ :exchange => name, :nowait => false }.merge(opts)))
+
+      method = client.next_method
+
+      client.check_response(method, Qrack::Protocol::Exchange::DeleteOk, "Error deleting exchange #{name}")
+
+      client.exchanges.delete(name)
+
+      # return confirmation
+      :delete_ok
+    end
+
+=begin rdoc
+
+=== DESCRIPTION:
+
+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.
+
+==== OPTIONS:
+
+* <tt>:key => 'routing_key'</tt> - Specifies the routing key for the message. The routing key is
+  used for routing messages depending on the exchange configuration.
+* <tt>:content_type => 'content/type'</tt> - Specifies the content type to use for the message.
+* <tt>:mandatory => true or false (_default_)</tt> - 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.
+* <tt>:immediate => true or false (_default_)</tt> - 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.
+* <tt>:persistent => true or false (_default_)</tt> - 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.
+
+==== RETURNS:
+
+nil
+
+=end
+
+    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'
+
+      out << Qrack::Protocol::Basic::Publish.new({ :exchange => name,
+                                                   :routing_key => routing_key,
+                                                   :mandatory => mandatory,
+                                                   :immediate => immediate })
+      data = data.to_s
+      out << Qrack::Protocol::Header.new(
+        Qrack::Protocol::Basic,
+        data.bytesize, {
+          :content_type  => content_type,
+          :delivery_mode => delivery_mode,
+          :priority      => 0
+        }.merge(opts)
+      )
+      out << Qrack::Transport::Body.new(data)
+
+      client.send_frame(*out)
+    end
+
+  end
+
+end