bunny 0.7.12 → 0.8.0

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

data/lib/bunny/queue08.rb

@@ -1,403 +0,0 @@
-# encoding: utf-8
-
-module Bunny
-
-=begin rdoc
-
-=== DESCRIPTION:
-
-Queues store and forward messages. Queues can be configured in the server or created at runtime.
-Queues must be attached to at least one exchange in order to receive messages from publishers.
-
-=end
-
-  class Queue < Qrack::Queue
-
-    def initialize(client, name, opts = {})
-      # check connection to server
-      raise Bunny::ConnectionError, 'Not connected to server' if client.status == :not_connected
-
-      @client = client
-      @opts   = opts
-      @delivery_tag = nil
-      @subscription = nil
-
-      # Queues without a given name are named by the server and are generally
-      # bound to the process that created them.
-      if !name
-        opts = {
-          :passive => false,
-          :durable => false,
-          :exclusive => true,
-          :auto_delete => true
-        }.merge(opts)
-      end
-
-      # 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)
-
-      opts = { :queue => name || '', :nowait => false }.merge(opts)
-
-      client.send_frame(Qrack::Protocol::Queue::Declare.new(opts))
-
-      method = client.next_method
-
-      client.check_response(method, Qrack::Protocol::Queue::DeclareOk, "Error declaring queue #{name}")
-
-      @name = method.queue
-      client.queues[@name] = self
-    end
-
-    # @return [Bunny::Consumer] Default consumer associated with this queue (if any), or nil
-    # @note Default consumer is the one registered with the convenience {Bunny::Queue#subscribe} method. It has no special properties of any kind.
-    # @see Queue#subscribe
-    # @see Bunny::Consumer
-    # @api public
-    def default_consumer
-      @default_consumer
-    end
-
-
-    # @return [Class]
-    # @private
-    def self.consumer_class
-      # Bunny::Consumer
-      Bunny::Subscription
-    end # self.consumer_class
-
-=begin rdoc
-
-=== DESCRIPTION:
-
-Acknowledges one or more messages delivered via the _Deliver_ or _Get_-_Ok_ methods. The client can
-ask to confirm a single message or a set of messages up to and including a specific message.
-
-==== OPTIONS:
-
-* <tt>:delivery_tag</tt>
-* <tt>:multiple => true or false (_default_)</tt> - If set to _true_, the delivery tag is treated
-  as "up to and including", so that the client can acknowledge multiple messages with a single
-  method. If set to _false_, the delivery tag refers to a single message. If the multiple field
-  is _true_, and the delivery tag is zero, tells the server to acknowledge all outstanding messages.
-
-=end
-
-    def ack(opts={})
-      # Set delivery tag
-      if delivery_tag.nil? and opts[:delivery_tag].nil?
-        raise Bunny::AcknowledgementError, "No delivery tag received"
-      else
-        self.delivery_tag = opts[:delivery_tag] if delivery_tag.nil?
-      end
-
-      opts = {:delivery_tag => delivery_tag, :multiple => false}.merge(opts)
-
-      client.send_frame(Qrack::Protocol::Basic::Ack.new(opts))
-
-      # reset delivery tag
-      self.delivery_tag = nil
-    end
-
-=begin rdoc
-
-=== DESCRIPTION:
-
-Binds a queue to an exchange. Until a queue is bound it will not receive any messages. Queues are
-bound to the direct exchange '' by default. If error occurs, a _Bunny_::_ProtocolError_ is raised.
-
-* <tt>:key => 'routing key'* <tt>:key => 'routing_key'</tt> - Specifies the routing key for
-  the binding. The routing key is used for routing messages depending on the exchange configuration.
-* <tt>:nowait => true or false (_default_)</tt> - Ignored by Bunny, always _false_.
-
-==== RETURNS:
-
-<tt>:bind_ok</tt> if successful.
-
-=end
-
-    def bind(exchange, opts = {})
-      exchange = exchange.respond_to?(:name) ? exchange.name : exchange
-
-      # 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)
-
-      opts = {
-        :queue => name,
-        :exchange => exchange,
-        :routing_key => opts.delete(:key),
-        :nowait => false
-      }.merge(opts)
-
-      client.send_frame(Qrack::Protocol::Queue::Bind.new(opts))
-
-      method = client.next_method
-
-      client.check_response(method, Qrack::Protocol::Queue::BindOk, "Error binding queue: #{name} to exchange: #{exchange}")
-
-      # return message
-      :bind_ok
-    end
-
-=begin rdoc
-
-=== DESCRIPTION:
-
-Requests that a queue is deleted from broker/server. When a queue is deleted any pending messages
-are sent to a dead-letter queue if this is defined in the server configuration. Removes reference
-from queues 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 queue if it has no consumers. If the queue has consumers the server does not
-  delete it but raises a channel exception instead.
-* <tt>:if_empty => true or false (_default_)</tt> - If set to _true_, the server will only
-  delete the queue if it has no messages. If the queue is not empty the server raises a channel
-  exception.
-* <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)
-
-      opts = { :queue => name, :nowait => false }.merge(opts)
-
-      client.send_frame(Qrack::Protocol::Queue::Delete.new(opts))
-
-      method = client.next_method
-
-      client.check_response(method, Qrack::Protocol::Queue::DeleteOk, "Error deleting queue #{name}")
-
-      client.queues.delete(name)
-
-      # return confirmation
-      :delete_ok
-    end
-
-=begin rdoc
-
-=== DESCRIPTION:
-
-Gets a message from a queue in a synchronous way. If error occurs, raises _Bunny_::_ProtocolError_.
-
-==== OPTIONS:
-
-* <tt>:ack => false (_default_) or true</tt> - If set to _false_, the server does not expect an
-  acknowledgement message from the client. If set to _true_, the server expects an acknowledgement
-  message from the client and will re-queue the message if it does not receive one within a time specified
-  by the server.
-
-==== RETURNS:
-
-Hash <tt>{:header, :payload, :delivery_details}</tt>. <tt>:delivery_details</tt> is
-a hash <tt>{:consumer_tag, :delivery_tag, :redelivered, :exchange, :routing_key}</tt>.
-
-If the queue is empty the returned hash will contain the values -
-
-  :header => nil
-  :payload => :queue_empty
-  :delivery_details => nil
-
-N.B. If a block is provided then the hash will be passed into the block and the return value
-will be nil.
-
-=end
-
-    def pop(opts = {}, &blk)
-
-      # do we want to have to provide an acknowledgement?
-      ack = opts.delete(:ack)
-
-      opts = {
-        :queue => name,
-        :consumer_tag => name,
-        :no_ack => !ack,
-        :nowait => true
-      }.merge(opts)
-
-      client.send_frame(Qrack::Protocol::Basic::Get.new(opts))
-
-      method = client.next_method
-
-      if method.is_a?(Qrack::Protocol::Basic::GetEmpty) then
-        queue_empty = true
-      elsif !method.is_a?(Qrack::Protocol::Basic::GetOk)
-        raise Bunny::ProtocolError, "Error getting message from queue #{name}"
-      end
-
-      if !queue_empty
-        # get delivery tag to use for acknowledge
-        self.delivery_tag = method.delivery_tag if ack
-
-        header = client.next_payload
-
-        # If maximum frame size is smaller than message payload body then message
-        # will have a message header and several message bodies
-        msg = ''
-        while msg.length < header.size
-          msg << client.next_payload
-        end
-
-        msg_hash = {:header => header, :payload => msg, :delivery_details => method.arguments}
-
-      else
-        msg_hash = {:header => nil, :payload => :queue_empty, :delivery_details => nil}
-      end
-
-      # Pass message hash to block or return message hash
-      blk ? blk.call(msg_hash) : msg_hash
-    end
-
-=begin rdoc
-
-=== DESCRIPTION:
-
-Removes all messages from a queue.  It does not cancel consumers.  Purged messages are deleted
-without any formal "undo" mechanism. If an error occurs raises _Bunny_::_ProtocolError_.
-
-==== Options:
-
-* <tt>:nowait => true or false (_default_)</tt> - Ignored by Bunny, always _false_.
-
-==== Returns:
-
-<tt>:purge_ok</tt> if successful
-=end
-
-    def purge(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)
-
-      opts = { :queue => name, :nowait => false }.merge(opts)
-
-      client.send_frame(Qrack::Protocol::Queue::Purge.new(opts))
-
-      method = client.next_method
-
-      client.check_response(method, Qrack::Protocol::Queue::PurgeOk, "Error purging queue #{name}")
-
-      # return confirmation
-      :purge_ok
-    end
-
-=begin rdoc
-
-=== DESCRIPTION:
-
-Returns hash {:message_count, :consumer_count}.
-
-=end
-
-    def status
-      client.send_frame(Qrack::Protocol::Queue::Declare.new(:queue => name, :passive => true))
-      method = client.next_method
-      {:message_count => method.message_count, :consumer_count => method.consumer_count}
-    end
-
-    def subscribe(opts = {}, &blk)
-      raise RuntimeError.new("This queue already has default consumer. Please instantiate Bunny::Consumer directly and call its #consume method to register additional consumers.") if @default_consumer && ! opts[:consumer_tag]
-
-      # Create a subscription.
-      @default_consumer = self.class.consumer_class.new(client, self, opts)
-      @default_consumer.consume(&blk)
-    end
-
-=begin rdoc
-
-=== DESCRIPTION:
-
-Cancels a consumer. This does not affect already delivered messages, but it does mean
-the server will not send any more messages for that consumer.
-
-==== OPTIONS:
-
-* <tt>:consumer_tag => '_tag_'</tt> - Specifies the identifier for the consumer.
-* <tt>:nowait => true or false (_default_)</tt> - Ignored by Bunny, always _false_.
-
-==== Returns:
-
-<tt>:unsubscribe_ok</tt> if successful
-
-=end
-
-    def unsubscribe(opts = {})
-      # Default consumer_tag from subscription if not passed in
-      consumer_tag = @default_consumer ? @default_consumer.consumer_tag : opts[:consumer_tag]
-
-      # Must have consumer tag to tell server what to unsubscribe
-      raise Bunny::UnsubscribeError,
-      "No consumer tag received" if !consumer_tag
-
-      # Cancel consumer
-      client.send_frame(Qrack::Protocol::Basic::Cancel.new(:consumer_tag => consumer_tag,:nowait => false))
-
-      method = client.next_method
-
-      client.check_response(method, Qrack::Protocol::Basic::CancelOk, "Error unsubscribing from queue #{name}")
-
-      # Reset subscription
-      @default_consumer = nil
-
-      # Return confirmation
-      :unsubscribe_ok
-    end
-
-=begin rdoc
-
-=== DESCRIPTION:
-
-Removes a queue binding from an exchange. If error occurs, a _Bunny_::_ProtocolError_ is raised.
-
-==== OPTIONS:
-* <tt>:key => 'routing key'* <tt>:key => 'routing_key'</tt> - Specifies the routing key for
-  the binding.
-* <tt>:nowait => true or false (_default_)</tt> - Ignored by Bunny, always _false_.
-
-==== RETURNS:
-
-<tt>:unbind_ok</tt> if successful.
-
-=end
-
-    def unbind(exchange, opts = {})
-      exchange = exchange.respond_to?(:name) ? exchange.name : exchange
-
-      # 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)
-
-      opts = {
-        :queue => name,
-        :exchange => exchange,
-        :routing_key => opts.delete(:key),
-        :nowait => false
-      }.merge(opts)
-
-      client.send_frame(Qrack::Protocol::Queue::Unbind.new(opts))
-
-      method = client.next_method
-
-      client.check_response(method, Qrack::Protocol::Queue::UnbindOk, "Error unbinding queue #{name}")
-
-      # return message
-      :unbind_ok
-    end
-
-    private
-
-    def exchange
-      @exchange ||= Bunny::Exchange.new(client, '', {:type => :direct, :key => name})
-    end
-
-  end
-
-end