bunny 0.7.13 → 0.8.0

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

data/lib/bunny/subscription08.rb

@@ -1,87 +0,0 @@
-# encoding: utf-8
-
-module Bunny
-
-=begin rdoc
-
-=== DESCRIPTION:
-
-Asks the server to start a "consumer", which is a transient request for messages from a specific
-queue. Consumers last as long as the channel they were created on, or until the client cancels them
-with an _unsubscribe_. Every time a message reaches the queue it is passed to the _blk_ for
-processing. If error occurs, _Bunny_::_ProtocolError_ is raised.
-
-==== OPTIONS:
-* <tt>:consumer_tag => '_tag_'</tt> - Specifies the identifier for the consumer. The consumer tag is
-  local to a connection, so two clients can use the same consumer tags. If this option is not
-  specified a server generated name is used.
-* <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.
-* <tt>:exclusive => true or false (_default_)</tt> - Request exclusive consumer access, meaning
-  only this consumer can access the queue.
-* <tt>:nowait => true or false (_default_)</tt> - Ignored by Bunny, always _false_.
-* <tt>:timeout => number of seconds - The subscribe loop will continue to wait for
-  messages until terminated (Ctrl-C or kill command) or this timeout interval is reached.
-* <tt>:message_max => max number messages to process</tt> - When the required number of messages
-  is processed subscribe loop is exited.
-
-==== OPERATION:
-
-Passes a hash of message information to the block, if one has been supplied. The hash contains
-:header, :payload and :delivery_details. The structure of the data is as follows -
-
-:header has instance variables -
-  @klass
-  @size
-  @weight
-  @properties is a hash containing -
-    :content_type
-    :delivery_mode
-    :priority
-
-:payload contains the message contents
-
-:delivery details is a hash containing -
-  :consumer_tag
-  :delivery_tag
-  :redelivered
-  :exchange
-  :routing_key
-
-If the :timeout option is specified then the subscription will
-automatically cease if the given number of seconds passes with no
-message arriving.
-
-==== EXAMPLES
-
-my_queue.subscribe(:timeout => 5) {|msg| puts msg[:payload]}
-
-my_queue.subscribe(:message_max => 10, :ack => true) {|msg| puts msg[:payload]}
-
-=end
-
-  class Subscription < Bunny::Consumer
-
-    def setup_consumer
-      subscription_options = {
-        :queue => queue.name,
-        :consumer_tag => consumer_tag,
-        :no_ack => !ack,
-        :exclusive => exclusive,
-        :nowait => false
-      }.merge(@opts)
-
-      client.send_frame(Qrack::Protocol::Basic::Consume.new(subscription_options))
-
-      method = client.next_method
-
-      client.check_response(method, Qrack::Protocol::Basic::ConsumeOk, "Error subscribing to queue #{queue.name}")
-
-      @consumer_tag = method.consumer_tag
-    end
-
-  end
-
-end

data/lib/qrack/protocol/protocol09.rb

@@ -1,135 +0,0 @@
-# encoding: utf-8
-
-module Qrack
-  module Protocol09
-    #:stopdoc:
-    class Class::Method
-      def initialize *args
-        opts = args.pop if args.last.is_a? Hash
-        opts ||= {}
-
-        if args.size == 1 and args.first.is_a? Transport09::Buffer
-          buf = args.shift
-        else
-          buf = nil
-        end
-
-        self.class.arguments.each do |type, name|
-          val = buf ? buf.read(type) :
-            args.shift || opts[name] || opts[name.to_s]
-          instance_variable_set("@#{name}", val)
-        end
-      end
-
-      def arguments
-        self.class.arguments.inject({}) do |hash, (type, name)|
-          hash.update name => instance_variable_get("@#{name}")
-        end
-      end
-
-      def to_binary
-        buf = Transport09::Buffer.new
-        buf.write :short, self.class.parent.id
-        buf.write :short, self.class.id
-
-        bits = []
-
-        self.class.arguments.each do |type, name|
-          val = instance_variable_get("@#{name}")
-          if type == :bit
-            bits << (val || false)
-          else
-            unless bits.empty?
-              buf.write :bit, bits
-              bits = []
-            end
-            buf.write type, val
-          end
-        end
-
-        buf.write :bit, bits unless bits.empty?
-        buf.rewind
-
-        buf
-      end
-
-      def to_s
-        to_binary.to_s
-      end
-
-      def to_frame channel = 0
-        Transport09::Method.new(self, channel)
-      end
-    end
-
-    class Header
-      def initialize *args
-        opts = args.pop if args.last.is_a? Hash
-        opts ||= {}
-
-        first = args.shift
-
-        if first.is_a? ::Class and first.ancestors.include? Protocol09::Class
-          @klass = first
-          @size = args.shift || 0
-          @weight = args.shift || 0
-          @properties = opts
-
-        elsif first.is_a? Transport09::Buffer or first.is_a? String
-          buf = first
-          buf = Transport09::Buffer.new(buf) unless buf.is_a? Transport09::Buffer
-
-          @klass = Protocol09.classes[buf.read(:short)]
-          @weight = buf.read(:short)
-          @size = buf.read(:longlong)
-
-          props = buf.read(:properties, *klass.properties.map{|type,_| type })
-          @properties = Hash[*klass.properties.map{|_,name| name }.zip(props).reject{|k,v| v.nil? }.flatten]
-
-        else
-          raise ArgumentError, 'Invalid argument'
-        end
-
-      end
-      attr_accessor :klass, :size, :weight, :properties
-
-      def to_binary
-        buf = Transport09::Buffer.new
-        buf.write :short, klass.id
-        buf.write :short, weight # XXX rabbitmq only supports weight == 0
-        buf.write :longlong, size
-        buf.write :properties, (klass.properties.map do |type, name|
-                                  [ type, properties[name] || properties[name.to_s] ]
-                                end)
-        buf.rewind
-        buf
-      end
-
-      def to_s
-        to_binary.to_s
-      end
-
-      def to_frame channel = 0
-        Transport09::Header.new(self, channel)
-      end
-
-      def == header
-        [ :klass, :size, :weight, :properties ].inject(true) do |eql, field|
-          eql and __send__(field) == header.__send__(field)
-        end
-      end
-
-      def method_missing meth, *args, &blk
-        @properties.has_key?(meth) || @klass.properties.find{|_,name| name == meth } ? @properties[meth] :
-          super
-      end
-    end
-
-    def self.parse buf
-      buf = Transport09::Buffer.new(buf) unless buf.is_a? Transport09::Buffer
-      class_id, method_id = buf.read(:short, :short)
-      classes[class_id].methods[method_id].new(buf)
-    end
-
-  end
-end