bunny 0.8.0 → 0.9.0.pre1

data/lib/bunny/message_metadata.rb

@@ -0,0 +1,126 @@
+module Bunny
+  # Combines message delivery metadata and message metadata behind a single Hash-like
+  # immutable data structure that mimics AMQP::Header in amqp gem.
+  class MessageMetadata
+
+    #
+    # Behaviors
+    #
+
+    include Enumerable
+
+    #
+    # API
+    #
+
+    def initialize(basic_deliver, properties)
+      h = {
+        :consumer_tag => basic_deliver.consumer_tag,
+        :delivery_tag => basic_deliver.delivery_tag,
+        :redelivered  => basic_deliver.redelivered,
+        :exchange     => basic_deliver.exchange,
+        :routing_key  => basic_deliver.routing_key
+      }
+
+      @basic_deliver = basic_deliver
+      @properties    = properties
+      @combined      = properties.merge(h)
+    end
+
+    def each(*args, &block)
+      @combined.each(*args, &block)
+    end
+
+    def [](k)
+      @combined[k]
+    end
+
+    def to_hash
+      @combined
+    end
+
+    def to_s
+      to_hash.to_s
+    end
+
+    def inspect
+      to_hash.inspect
+    end
+
+    def consumer_tag
+      @basic_deliver.consumer_tag
+    end
+
+    def deliver_tag
+      @basic_deliver.deliver_tag
+    end
+
+    def redelivered
+      @basic_deliver.redelivered
+    end
+
+    def exchange
+      @basic_deliver.exchange
+    end
+
+    def routing_key
+      @basic_deliver.routing_key
+    end
+
+    def content_type
+      @properties[:content_type]
+    end
+
+    def content_encoding
+      @properties[:content_encoding]
+    end
+
+    def headers
+      @properties[:headers]
+    end
+
+    def delivery_mode
+      @properties[:delivery_mode]
+    end
+
+    def priority
+      @properties[:priority]
+    end
+
+    def correlation_id
+      @properties[:correlation_id]
+    end
+
+    def reply_to
+      @properties[:reply_to]
+    end
+
+    def expiration
+      @properties[:expiration]
+    end
+
+    def message_id
+      @properties[:message_id]
+    end
+
+    def timestamp
+      @properties[:timestamp]
+    end
+
+    def type
+      @properties[:type]
+    end
+
+    def user_id
+      @properties[:user_id]
+    end
+
+    def app_id
+      @properties[:app_id]
+    end
+
+    def cluster_id
+      @properties[:cluster_id]
+    end
+  end
+end

data/lib/bunny/queue.rb

@@ -1,328 +1,155 @@
-# encoding: utf-8
+require "bunny/compatibility"
 
 module Bunny
+  class Queue
 
-  # 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.
-  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
-
-      # 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,
-          :deprecated_ticket => 0
-        }.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, :deprecated_ticket => 0 }.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
-
-    # 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.
-    #
-    # @option opts [String] :delivery_tag
-    #
-    # @option opts [Boolean] :multiple (false)
-    #   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.
-    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))
+    include Bunny::Compatibility
 
-      # reset delivery tag
-      self.delivery_tag = nil
-    end
 
-    # Binds a queue to an exchange. Until a queue is bound it won't receive
-    # any messages. Queues are bound to the direct exchange '' by default.
-    # If error occurs, a {Bunny::ProtocolError} is raised.
-    #
-    # @option opts [String] :key
-    #   Specifies the routing key for the binding. The routing key is used
-    #   for routing messages depending on the exchange configuration.
     #
-    # @option opts [Boolean] :nowait (false)
-    #   Ignored by Bunny, always @false@.
+    # API
     #
-    # @return [Symbol] @:bind_ok@ if successful.
-    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)
+    attr_reader :channel, :name, :options
 
-      opts = {
-        :queue => name,
-        :exchange => exchange,
-        :routing_key => opts.delete(:key),
-        :nowait => false,
-        :deprecated_ticket => 0
-      }.merge(opts)
+    def initialize(channel_or_connection, name = AMQ::Protocol::EMPTY_STRING, 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
+      @options          = self.class.add_default_options(name, opts)
+      @consumers        = Hash.new
 
-      client.send_frame(Qrack::Protocol::Queue::Bind.new(opts))
+      @durable          = @options[:durable]
+      @exclusive        = @options[:exclusive]
+      @server_named     = @name.empty?
+      @auto_delete      = @options[:auto_delete]
+      @arguments        = @options[:arguments]
 
-      method = client.next_method
+      @default_consumer = nil
 
-      client.check_response(method, Qrack::Protocol::Queue::BindOk, "Error binding queue: #{name} to exchange: #{exchange}")
+      declare! unless opts[:no_declare]
 
-      # return message
-      :bind_ok
+      @channel.register_queue(self)
     end
 
-    # 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@.
-    #
-    # @option opts [Boolean] :if_unused (false)
-    #   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.
-    #
-    # @option opts [Boolean] :if_empty (false)
-    #   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.
-    #
-    # @option opts [Boolean] :nowait (false)
-    #   Ignored by Bunny, always @false@.
-    #
-    # @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)
+    # @return [Boolean] true if this queue was declared as durable (will survive broker restart).
+    # @api public
+    def durable?
+      @durable
+    end # durable?
 
-      opts = { :queue => name, :nowait => false, :deprecated_ticket => 0 }.merge(opts)
+    # @return [Boolean] true if this queue was declared as exclusive (limited to just one consumer)
+    # @api public
+    def exclusive?
+      @exclusive
+    end # exclusive?
 
-      client.send_frame(Qrack::Protocol::Queue::Delete.new(opts))
+    # @return [Boolean] true if this queue was declared as automatically deleted (deleted as soon as last consumer unbinds).
+    # @api public
+    def auto_delete?
+      @auto_delete
+    end # auto_delete?
 
-      method = client.next_method
+    # @return [Boolean] true if this queue was declared as server named.
+    # @api public
+    def server_named?
+      @server_named
+    end # server_named?
 
-      client.check_response(method, Qrack::Protocol::Queue::DeleteOk, "Error deleting queue #{name}")
+    def arguments
+      @arguments
+    end
 
-      client.queues.delete(name)
 
-      # return confirmation
-      :delete_ok
+    def bind(exchange, opts = {})
+      @channel.queue_bind(@name, exchange, opts)
     end
 
-    # Gets a message from a queue in a synchronous way. If error occurs, raises _Bunny_::_ProtocolError_.
-    #
-    # @option opts [Boolean] :ack (false)
-    #   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.
-    #
-    # @return [Hash] Hash with @:header@, @:payload@ and @:delivery_details@ keys. @:delivery_details@ is a hash @:consumer_tag@, @:delivery_tag@, @:redelivered@, @:exchange@ and @:routing_key@. If the queue is empty the returned hash will contain: @{: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.
-    def pop(opts = {}, &blk)
-      opts = {
-        :queue => name,
-        :consumer_tag => name,
-        :no_ack => !opts[:ack],
-        :nowait => true,
-        :deprecated_ticket => 0
-      }.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 opts[:ack]
+    def unbind(exchange, opts = {})
+      @channel.queue_unbind(@name, exchange, opts)
+    end
 
-        header = client.next_payload
+    def subscribe(opts = {:consumer_tag => "", :ack => false, :exclusive => false}, &block)
+      @channel.basic_consume(@name, opts.fetch(:consumer_tag, ""), !opts[:ack], opts[:exclusive], opts[:arguments], &block)
 
-        # 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
+      # joins current thread with the consumers pool
+      @channel.work_pool.join
+    end
 
-        msg_hash = {:header => header, :payload => msg, :delivery_details => method.arguments}
+    def pop(opts = {:ack => true}, &block)
+      delivery_info, properties, content = @channel.basic_get(@name, opts)
 
+      if block
+        block.call(delivery_info, properties, content)
       else
-        msg_hash = {:header => nil, :payload => :queue_empty, :delivery_details => nil}
+        [delivery_info, properties, content]
       end
-
-      # Pass message hash to block or return message hash
-      blk ? blk.call(msg_hash) : msg_hash
     end
+    alias get pop
 
-    # 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}.
-    #
-    # @option opts [Boolean] :nowait (false)
-    #   Ignored by Bunny, always @false@.
-    #
-    # @return [Symbol] @:purge_ok@ if successful
-    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, :deprecated_ticket => 0 }.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}")
+    # Deletes the queue
+    # @api public
+    def delete(opts = {})
+      @channel.queue_delete(@name, opts)
+    end
 
-      # return confirmation
-      :purge_ok
+    def purge(opts = {})
+      @channel.queue_purge(@name, opts)
     end
 
-    # @return [Hash] Hash with keys @:message_count@ and @consumer_count@.
     def status
-      opts = { :queue => name, :passive => true, :deprecated_ticket => 0 }
-      client.send_frame(Qrack::Protocol::Queue::Declare.new(opts))
-
-      method = client.next_method
-      {:message_count => method.message_count, :consumer_count => method.consumer_count}
+      queue_declare_ok = @channel.queue_declare(@name, @options.merge(:passive => true))
+      {:message_count => queue_declare_ok.message_count,
+        :consumer_count => queue_declare_ok.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)
+    def message_count
+      s = self.status
+      s[:message_count]
     end
 
-    # Removes a queue binding from an exchange. If error occurs, a _Bunny_::_ProtocolError_ is raised.
-    #
-    # @option opts [String] :key
-    #   Specifies the routing key for the binding.
-    #
-    # @option opts [Boolean] :nowait (false)
-    #   Ignored by Bunny, always @false@.
-    #
-    # @return [Symbol] @:unbind_ok@ if successful.
-    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,
-        :deprecated_ticket => 0
-      }.merge(opts)
-
-      client.send_frame(Qrack::Protocol::Queue::Unbind.new(opts))
-
-      method = client.next_method
+    def consumer_count
+      s = self.status
+      s[:consumer_count]
+    end
 
-      client.check_response(method, Qrack::Protocol::Queue::UnbindOk, "Error unbinding queue #{name}")
 
-      # return message
-      :unbind_ok
-    end
 
-    # 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.
     #
-    # @option opts [String] :consumer_tag
-    #   Specifies the identifier for the consumer.
+    # Implementation
     #
-    # @option opts [Boolean] :nowait (false)
-    #   Ignored by Bunny, always @false@.
-    #
-    # @option opts [Boolean] :nowait (false)
-    #   Ignored by Bunny, always @false@.
-    #
-    # @return [Symbol] @:unsubscribe_ok@ if successful
-    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))
-
-      # Reset subscription
-      @default_consumer = nil
-
-      method = client.next_method
-
-      client.check_response(method, Qrack::Protocol::Basic::CancelOk, "Error unsubscribing from queue #{name}, got #{method.class}")
 
-      # Return confirmation
-      :unsubscribe_ok
+    # @private
+    def declare!
+      queue_declare_ok = @channel.queue_declare(@name, @options)
+      @name = queue_declare_ok.queue
     end
 
-    private
+    protected
 
-    def exchange
-      @exchange ||= Bunny::Exchange.new(client, '', :type => :direct, :key => name, :reserved_1 => 0, :reserved_2 => false, :reserved_3 => false)
+    # @private
+    def self.add_default_options(name, opts, block)
+      { :queue => 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,
+          :exclusive   => false,
+          :auto_delete => false,
+          :arguments   => nil
+        }.merge(h)
+      else
+        h
+      end
+    end
   end
-
 end