bunny 0.7.13 → 0.8.0

data/lib/bunny/client08.rb

@@ -1,480 +0,0 @@
-# encoding: utf-8
-
-module Bunny
-
-=begin rdoc
-
-=== DESCRIPTION:
-
-The Client class provides the major Bunny API methods.
-
-=end
-
-  class Client < Qrack::Client
-
-    attr_accessor :ticket
-
-=begin rdoc
-
-=== DESCRIPTION:
-
-Sets up a Bunny::Client object ready for connection to a broker/server. _Client_._status_ is set to
-<tt>:not_connected</tt>.
-
-==== OPTIONS:
-
-* <tt>:host => '_hostname_' (default = 'localhost')</tt>
-* <tt>:port => _portno_ (default = 5672 or 5671 if :ssl set to true)</tt>
-* <tt>:vhost => '_vhostname_' (default = '/')</tt>
-* <tt>:user => '_username_' (default = 'guest')</tt>
-* <tt>:pass => '_password_' (default = 'guest')</tt>
-* <tt>:ssl => true or false (default = false)</tt> - If set to _true_, ssl
-  encryption will be used and port will default to 5671.
-* <tt>:verify_ssl => true or false (default = true)</tt> - If ssl is enabled,
-  this will cause OpenSSL to validate the server certificate unless this
-  parameter is set to _false_.
-* <tt>:logfile => '_logfilepath_' (default = nil)</tt>
-* <tt>:logging => true or false (_default_)</tt> - If set to _true_, session information is sent
-  to STDOUT if <tt>:logfile</tt> has not been specified. Otherwise, session information is written to
-  <tt>:logfile</tt>.
-* <tt>:insist => true or false (_default_)</tt> - In a configuration with multiple load-sharing
-  servers, the server may respond to a Connection::Open method with a Connection::Redirect. The insist
-  option, if set to _true_, tells the server that the client is insisting on a connection to the
-  specified server.
-* <tt>:frame_max => maximum frame size in bytes (default = 131072)</tt>
-* <tt>:channel_max => maximum number of channels (default = 0 no maximum)</tt>
-* <tt>:heartbeat => number of seconds (default = 0 no heartbeat)</tt>
-* <tt>:connect_timeout => number of seconds before Qrack::ConnectionTimeout is raised (default = 5)</tt>
-
-=end
-
-    def initialize(connection_string_or_opts = Hash.new, opts = Hash.new)
-      super
-      @spec = '0-8'
-      @port = self.__opts__[:port] || (self.__opts__[:ssl] ? Qrack::Protocol::SSL_PORT : Qrack::Protocol::PORT)
-      @insist = self.__opts__[:insist]
-    end
-
-=begin rdoc
-
-=== DESCRIPTION:
-
-Checks response from AMQP methods and takes appropriate action
-
-=end
-
-    def check_response(received_method, expected_method, err_msg, err_class = Bunny::ProtocolError)
-      case
-      when received_method.is_a?(Qrack::Protocol::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::Protocol::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::Protocol::Connection::Close.new(:reply_code => 200, :reply_text => 'Goodbye', :class_id => 0, :method_id => 0))
-
-      method = next_method
-
-      check_response(method, Qrack::Protocol::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::Channel.new(self)
-    end
-
-=begin rdoc
-
-=== DESCRIPTION:
-
-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, the existing object is returned.
-If an error occurs a _Bunny_::_ProtocolError_ is raised.
-
-==== OPTIONS:
-
-* <tt>:type => one of :direct (_default_), :fanout, :topic, :headers</tt>
-* <tt>:passive => true or false</tt> - 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.
-* <tt>:durable => true or false (_default_)</tt> - 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.
-* <tt>:auto_delete => true or false (_default_)</tt> - If set to _true_, the exchange is deleted
-  when all queues have finished using it.
-* <tt>:nowait => true or false (_default_)</tt> - Ignored by Bunny, always _false_.
-
-==== RETURNS:
-
-Exchange
-
-=end
-
-    def exchange(name, opts = {})
-      exchanges[name] || Bunny::Exchange.new(self, name, opts)
-    end
-
-    def init_connection
-      write(Qrack::Protocol::HEADER)
-      write([1, 1, Qrack::Protocol::VERSION_MAJOR, Qrack::Protocol::VERSION_MINOR].pack('C4'))
-
-      frame = next_frame
-      if frame.nil? or !frame.payload.is_a?(Qrack::Protocol::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::Transport::Frame.parse(buffer)
-        end
-      else
-        frame = Qrack::Transport::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::Transport::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_opts = { :platform => 'Ruby', :product => 'Bunny', :information => 'http://github.com/ruby-amqp/bunny', :version => VERSION }
-
-      send_frame(Qrack::Protocol::Connection::StartOk.new(client_opts, 'AMQPLAIN', {:LOGIN => @user, :PASSWORD => @pass}, 'en_US'))
-
-      frame = next_frame
-      raise Bunny::ProtocolError, "Connection failed - user: #{@user}" if frame.nil?
-
-      method = frame.payload
-
-      if method.is_a?(Qrack::Protocol::Connection::Tune)
-        @frame_max = method.frame_max if method.frame_max > 0 && method.frame_max < @frame_max
-        @channel_max = method.channel_max if method.channel_max > 0 && method.channel_max < @channel_max
-        send_frame(Qrack::Protocol::Connection::TuneOk.new( :channel_max => @channel_max, :frame_max => @frame_max, :heartbeat => @heartbeat))
-      end
-
-      send_frame(Qrack::Protocol::Connection::Open.new(:virtual_host => @vhost, :capabilities => '', :insist => @insist))
-
-      case method = next_method
-      when Qrack::Protocol::Connection::OpenOk
-        :ok
-      when Qrack::Protocol::Connection::Redirect
-        raise Bunny::ConnectionError, "Cannot connect to the specified server - host: #{@host}, port: #{@port}" if @insist
-
-        @host, @port = method.host.split(':')
-        close_socket
-      else
-        raise Bunny::ProtocolError, 'Cannot open connection'
-      end
-    end
-
-=begin rdoc
-
-=== DESCRIPTION:
-
-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.
-
-==== Options:
-
-* <tt>:prefetch_size => size in no. of octets (default = 0)</tt> - 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. Prefetching 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.
-* <tt>:prefetch_count => no. messages (default = 1)</tt> - 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.
-* <tt>:global => true or false (_default_)</tt> - By default the QoS settings apply to the current channel only. If set to
-true, they are applied to the entire connection.
-
-==== RETURNS:
-
-<tt>:qos_ok</tt> if successful.
-
-=end
-
-    def qos(opts = {})
-      send_frame(Qrack::Protocol::Basic::Qos.new({ :prefetch_size => 0, :prefetch_count => 1, :global => false }.merge(opts)))
-
-      method = next_method
-
-      check_response(method, Qrack::Protocol::Basic::QosOk, "Error specifying Quality of Service")
-
-      # return confirmation
-      :qos_ok
-    end
-
-=begin rdoc
-
-=== DESCRIPTION:
-
-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.
-
-==== OPTIONS:
-
-* <tt>:passive => true or false (_default_)</tt> - 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.
-* <tt>:durable => true or false (_default_)</tt> -      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 queues) 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.
-* <tt>:exclusive => true or false (_default_)</tt> - 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'.
-* <tt>:auto_delete => true or false (_default_)</tt> -  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.
-* <tt>:nowait => true or false (_default_)</tt> - Ignored by Bunny, always _false_.
-
-==== RETURNS:
-
-Queue
-
-=end
-
-    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::Queue.new(self, name, opts)
-    end
-
-=begin rdoc
-
-=== DESCRIPTION:
-
-Asks the broker to redeliver all unacknowledged messages on a specified channel. Zero or
-more messages may be redelivered.
-
-==== Options:
-
-* <tt>:requeue => true or false (_default_)</tt> - 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.
-
-=end
-
-    def recover(opts = {})
-      send_frame(Qrack::Protocol::Basic::Recover.new({ :requeue => false }.merge(opts)))
-    end
-
-    def request_access
-      send_frame(Qrack::Protocol::Access::Request.new(:realm => '/data', :read => true, :write => true, :active => true, :passive => true))
-
-      method = next_method
-
-      check_response(method, Qrack::Protocol::Access::RequestOk, "Access denied")
-
-      self.ticket = method.ticket
-    end
-
-    def send_frame(*args)
-      args.each do |data|
-        data.ticket  = ticket if ticket and data.respond_to?(:ticket=)
-        data         = data.to_frame(channel.number) unless data.is_a?(Qrack::Transport::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::Transport::Heartbeat.new('')
-      # Channel 0 must be used
-      switch_channel(0) if @channel.number > 0
-      # Send the heartbeat to server
-      send_frame(hb)
-    end
-
-=begin rdoc
-
-=== DESCRIPTION:
-
-Opens a communication channel and starts a connection. If an error occurs, a
-_Bunny_::_ProtocolError_ is raised. If successful, _Client_._status_ is set to <tt>:connected</tt>.
-
-==== RETURNS:
-
-<tt>:connected</tt> if successful.
-
-=end
-
-    def start_session
-      @connecting = true
-
-      loop do
-        # Create/get socket
-        socket
-
-        # Initiate connection
-        init_connection
-
-        # Open connection
-        break if open_connection == :ok
-      end
-
-      # Open another channel because channel zero is used for specific purposes
-      c = create_channel()
-      c.open
-
-      # Get access ticket
-      request_access
-
-      @connecting = false
-
-      # return status
-      @status = :connected
-    end
-
-    alias start start_session
-
-=begin rdoc
-
-=== DESCRIPTION:
-This method commits all messages published and acknowledged in
-the current transaction. A new transaction starts immediately
-after a commit.
-
-==== RETURNS:
-
-<tt>:commit_ok</tt> if successful.
-
-=end
-
-    def tx_commit
-      send_frame(Qrack::Protocol::Tx::Commit.new())
-
-      method = next_method
-
-      check_response(method, Qrack::Protocol::Tx::CommitOk, "Error commiting transaction")
-
-      # return confirmation
-      :commit_ok
-    end
-
-=begin rdoc
-
-=== DESCRIPTION:
-This method abandons all messages published and acknowledged in
-the current transaction. A new transaction starts immediately
-after a rollback.
-
-==== RETURNS:
-
-<tt>:rollback_ok</tt> if successful.
-
-=end
-
-    def tx_rollback
-      send_frame(Qrack::Protocol::Tx::Rollback.new())
-
-      method = next_method
-
-      check_response(method, Qrack::Protocol::Tx::RollbackOk, "Error rolling back transaction")
-
-      # return confirmation
-      :rollback_ok
-    end
-
-=begin rdoc
-
-=== DESCRIPTION:
-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.
-
-==== RETURNS:
-
-<tt>:select_ok</tt> if successful.
-
-=end
-
-    def tx_select
-      send_frame(Qrack::Protocol::Tx::Select.new())
-
-      method = next_method
-
-      check_response(method, Qrack::Protocol::Tx::SelectOk, "Error initiating transactions for current channel")
-
-      # return confirmation
-      :select_ok
-    end
-
-    protected
-
-    def check_returned_message(method)
-      check_response(method, Qrack::Protocol::Basic::Return, "Expected a returned message")
-    end
-
-    private
-
-    def buffer
-      @buffer ||= Qrack::Transport::Buffer.new(self)
-    end
-
-  end
-end

data/lib/bunny/exchange08.rb

@@ -1,177 +0,0 @@
-# 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)
-      )
-
-      limit = @client.frame_max - 8
-      i = 0
-      while i < data.bytesize
-        out << Qrack::Transport::Body.new(data.byteslice(i, limit))
-        i += limit
-      end
-
-      client.send_frame(*out)
-    end
-
-  end
-
-end