bunny 0.6.3.rc2 → 0.7

data/lib/bunny/queue08.rb

@@ -1,5 +1,7 @@
+# encoding: utf-8
+
 module Bunny
-	
+
 =begin rdoc
 
 === DESCRIPTION:
@@ -9,14 +11,14 @@ Queues must be attached to at least one exchange in order to receive messages fr
 
 =end
 
-	class Queue < Qrack::Queue
+  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
 
-	  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
+      @client = client
+      @opts   = opts
       @delivery_tag = nil
       @subscription = nil
 
@@ -30,22 +32,39 @@ Queues must be attached to at least one exchange in order to receive messages fr
           :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)
-			
-	    client.send_frame(
-	      Qrack::Protocol::Queue::Declare.new({ :queue => name || '', :nowait => false }.merge(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::Declare.new(opts))
+
       method = client.next_method
 
-			client.check_response(method,	Qrack::Protocol::Queue::DeclareOk, "Error declaring queue #{name}")
+      client.check_response(method, Qrack::Protocol::Queue::DeclareOk, "Error declaring queue #{name}")
 
       @name = method.queue
-			client.queues[@name] = self
-	  end
+      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
 
@@ -63,21 +82,21 @@ ask to confirm a single message or a set of messages up to and including a speci
   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
-			
-      client.send_frame(
-        Qrack::Protocol::Basic::Ack.new({:delivery_tag => delivery_tag, :multiple => false}.merge(opts))
-      )
-
-			# reset delivery tag
-			self.delivery_tag = nil
+
+    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
@@ -97,29 +116,30 @@ bound to the direct exchange '' by default. If error occurs, a _Bunny_::_Protoco
 
 =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)
-
-	    client.send_frame(
-	      Qrack::Protocol::Queue::Bind.new({ :queue => name,
-		 																:exchange => exchange,
-		 																:routing_key => opts.delete(:key),
-		 																:nowait => false }.merge(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
-	
+    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:
@@ -143,24 +163,24 @@ from queues if successful. If an error occurs raises _Bunny_::_ProtocolError_.
 <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)
+    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({ :queue => name, :nowait => false }.merge(opts))
-	    )
-	
-			method = client.next_method
+      client.send_frame(Qrack::Protocol::Queue::Delete.new(opts))
 
-			client.check_response(method,	Qrack::Protocol::Queue::DeleteOk, "Error deleting queue #{name}")
+      method = client.next_method
 
-			client.queues.delete(name)
+      client.check_response(method, Qrack::Protocol::Queue::DeleteOk, "Error deleting queue #{name}")
 
-			# return confirmation
-			:delete_ok
-	  end
+      client.queues.delete(name)
+
+      # return confirmation
+      :delete_ok
+    end
 
 =begin rdoc
 
@@ -169,7 +189,7 @@ from queues if successful. If an error occurs raises _Bunny_::_ProtocolError_.
 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
@@ -191,50 +211,51 @@ will be nil.
 
 =end
 
-	  def pop(opts = {}, &blk)
-			
-			# do we want to have to provide an acknowledgement?
-			ack = opts.delete(:ack)
-			
-	    client.send_frame(
-	      Qrack::Protocol::Basic::Get.new({ :queue => name,
-																	 :consumer_tag => name,
-																	 :no_ack => !ack,
-																	 :nowait => true }.merge(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
-	
+    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:
@@ -251,23 +272,22 @@ without any formal "undo" mechanism. If an error occurs raises _Bunny_::_Protoco
 <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)
+    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)
 
-	    client.send_frame(
-	      Qrack::Protocol::Queue::Purge.new({ :queue => name, :nowait => false }.merge(opts))
-	    )
-	
-			method = client.next_method
+      opts = { :queue => name, :nowait => false }.merge(opts)
 
-			client.check_response(method,	Qrack::Protocol::Queue::PurgeOk, "Error purging queue #{name}")
+      client.send_frame(Qrack::Protocol::Queue::Purge.new(opts))
+
+      method = client.next_method
 
-			# return confirmation
-			:purge_ok
+      client.check_response(method, Qrack::Protocol::Queue::PurgeOk, "Error purging queue #{name}")
 
-	  end
+      # return confirmation
+      :purge_ok
+    end
 
 =begin rdoc
 
@@ -276,25 +296,21 @@ without any formal "undo" mechanism. If an error occurs raises _Bunny_::_Protoco
 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 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)
-			# Create subscription
-			s = Bunny::Subscription.new(client, self, opts)
-			s.start(&blk)
-			
-			# Reset when subscription finished
-			@subscription = nil
-		end
-		
+      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:
@@ -312,30 +328,27 @@ the server will not send any more messages for that consumer.
 <tt>:unsubscribe_ok</tt> if successful
 
 =end
-		
-		def unsubscribe(opts = {})
-			# Default consumer_tag from subscription if not passed in
-			consumer_tag = subscription ? subscription.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
-			
+
+    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
-			@subscription = nil
-				
-			# Return confirmation
-			:unsubscribe_ok
-			
+      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
@@ -355,35 +368,36 @@ Removes a queue binding from an exchange. If error occurs, a _Bunny_::_ProtocolE
 
 =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)
-
-	    client.send_frame(
-	      Qrack::Protocol::Queue::Unbind.new({ :queue => name,
-		 																	:exchange => exchange,
-		 																	:routing_key => opts.delete(:key),
-		 																	:nowait => false }.merge(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
-	
+    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