bunny 0.5.2 → 0.5.3

data/lib/bunny/exchange08.rb

@@ -88,6 +88,10 @@ if any, is committed.
   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:
 
@@ -96,6 +100,7 @@ nil
 =end
 
     def publish(data, opts = {})
+      opts = opts.dup
       out = []
 
       out << Qrack::Protocol::Basic::Publish.new(
@@ -155,4 +160,4 @@ if successful. If an error occurs raises _Bunny_::_ProtocolError_.
 
   end
   
-end
+end

data/lib/bunny/exchange09.rb

@@ -89,6 +89,10 @@ if any, is committed.
   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:
 
@@ -97,6 +101,7 @@ nil
 =end
 
     def publish(data, opts = {})
+      opts = opts.dup
       out = []
 
       out << Qrack::Protocol09::Basic::Publish.new(
@@ -156,4 +161,4 @@ if successful. If an error occurs raises _Bunny_::_ProtocolError_.
 
   end
   
-end
+end

data/lib/bunny/queue08.rb

@@ -9,9 +9,7 @@ Queues must be attached to at least one exchange in order to receive messages fr
 
 =end
 
-	class Queue
-	  attr_reader :name, :client
-	  attr_accessor :delivery_tag
+	class Queue < Qrack::Queue
 
 	  def initialize(client, name, opts = {})
 			# check connection to server
@@ -80,6 +78,87 @@ ask to confirm a single message or a set of messages up to and including a speci
 
 === 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)
+
+	    client.send_frame(
+	      Qrack::Protocol::Queue::Bind.new({ :queue => name,
+		 																:exchange => exchange,
+		 																:routing_key => opts.delete(:key),
+		 																:nowait => false }.merge(opts))
+	    )
+
+			raise Bunny::ProtocolError,
+				"Error binding queue #{name}" unless
+				client.next_method.is_a?(Qrack::Protocol::Queue::BindOk)
+
+			# 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)
+
+	    client.send_frame(
+	      Qrack::Protocol::Queue::Delete.new({ :queue => name, :nowait => false }.merge(opts))
+	    )
+
+			raise Bunny::ProtocolError,
+				"Error deleting queue #{name}" unless
+				client.next_method.is_a?(Qrack::Protocol::Queue::DeleteOk)
+
+			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:
@@ -126,54 +205,49 @@ a hash <tt>{:delivery_tag, :redelivered, :exchange, :routing_key, :message_count
 			self.delivery_tag = method.delivery_tag if ack
 			
 	    header = client.next_payload
-	    msg    = client.next_payload
-	    raise Bunny::MessageError, 'unexpected length' if msg.length < header.size
+	
+	    # 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
 
 			# Return message with additional info if requested
 			hdr ? {:header => header, :payload => msg, :delivery_details => method.arguments} : msg
 			
 	  end
-
+	
 =begin rdoc
 
 === DESCRIPTION:
 
-Publishes a message to the queue via the default nameless '' direct exchange.
-
-==== RETURNS:
-
-nil
-
-=end
-
-	  def publish(data, opts = {})
-	    exchange.publish(data, opts)
-	  end
+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_.
 
-=begin rdoc
+==== Options:
 
-=== DESCRIPTION:
+* <tt>:nowait => true or false (_default_)</tt> - Ignored by Bunny, always _false_.
 
-Returns message count from Queue#status.
+==== Returns:
 
+<tt>:purge_ok</tt> if successful
 =end
 
-	  def message_count
-	    s = status
-			s[:message_count]
-	  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)
 
-=begin rdoc
+	    client.send_frame(
+	      Qrack::Protocol::Queue::Purge.new({ :queue => name, :nowait => false }.merge(opts))
+	    )
 
-=== DESCRIPTION:
+			raise Bunny::ProtocolError, "Error purging queue #{name}" unless client.next_method.is_a?(Qrack::Protocol::Queue::PurgeOk)
 
-Returns consumer count from Queue#status.
+			# return confirmation
+			:purge_ok
 
-=end
-		
-	  def consumer_count
-	    s = status
-			s[:consumer_count]
 	  end
 
 =begin rdoc
@@ -214,21 +288,27 @@ processing. If error occurs, _Bunny_::_ProtocolError_ is raised.
 * <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 (default = 0 no timeout) - The subscribe loop will continue to wait for
+* <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.
 
 ==== RETURNS:
 
 If <tt>:header => true</tt> returns hash <tt>{:header, :delivery_details, :payload}</tt> for each message.
 <tt>:delivery_details</tt> is a hash <tt>{:consumer_tag, :delivery_tag, :redelivered, :exchange, :routing_key}</tt>.
 If <tt>:header => false</tt> only message payload is returned.
-If <tt>:timeout => > 0</tt> is reached returns :timed_out
+If <tt>:timeout => > 0</tt> is reached Qrack::ClientTimeout is raised
 
 =end
 	
 		def subscribe(opts = {}, &blk)
-			consumer_tag = opts[:consumer_tag] || name
-			secs = opts[:timeout] || 0
+			# Get maximum amount of messages to process
+			message_max = opts[:message_max] || nil
+			return if message_max == 0
+						
+			# If a consumer tag is not passed in the server will generate one
+			consumer_tag = opts[:consumer_tag] || nil
 			
 			# ignore the :nowait option if passed, otherwise program will hang waiting for a
 			# response from the server causing an error.
@@ -251,26 +331,32 @@ If <tt>:timeout => > 0</tt> is reached returns :timed_out
 				"Error subscribing to queue #{name}" unless
 				client.next_method.is_a?(Qrack::Protocol::Basic::ConsumeOk)
 			
+			# Initialize message counter
+			counter = 0
+			
 			loop do
-				begin
-					Timeout::timeout(secs) do
-						@method = client.next_method
-					end
-				rescue Timeout::Error
-					return :timed_out
-				end
-
-				break if @method.is_a?(Qrack::Protocol::Basic::CancelOk)
+        method = client.next_method(:timeout => opts[:timeout])
 			
 				# get delivery tag to use for acknowledge
-				self.delivery_tag = @method.delivery_tag if ack
+				self.delivery_tag = method.delivery_tag if ack
 			
 				header = client.next_payload
-		    msg    = client.next_payload
-		    raise Bunny::MessageError, 'unexpected length' if msg.length < header.size
+
+		    # 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
 				
 				# pass the message and related info, if requested, to the block for processing
 				blk.call(hdr ? {:header => header, :payload => msg, :delivery_details => method.arguments} : msg)
+				
+				# Increment message counter
+				counter += 1
+				
+				# Exit loop if message_max condition met
+				break if !message_max.nil? and counter == message_max
 			end
 			
 		end
@@ -287,6 +373,10 @@ the server will not send any more messages for that consumer.
 * <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 = {})
@@ -301,48 +391,10 @@ the server will not send any more messages for that consumer.
 			raise Bunny::ProtocolError,
 				"Error unsubscribing from queue #{name}" unless
 				client.next_method.is_a?(Qrack::Protocol::Basic::CancelOk)
-			
-    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)
-			
-	    bindings[exchange] = opts
-	    client.send_frame(
-	      Qrack::Protocol::Queue::Bind.new({ :queue => name,
-		 																:exchange => exchange,
-		 																:routing_key => opts.delete(:key),
-		 																:nowait => false }.merge(opts))
-	    )
-	
-			raise Bunny::ProtocolError,
-				"Error binding queue #{name}" unless
-				client.next_method.is_a?(Qrack::Protocol::Queue::BindOk)
 				
-			# return message
-			:bind_ok
-	  end
+			# return confirmation
+			:unsubscribe_ok
+    end
 
 =begin rdoc
 
@@ -367,8 +419,6 @@ Removes a queue binding from an exchange. If error occurs, a _Bunny_::_ProtocolE
 			# 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)
-			
-	    bindings.delete(exchange)
 
 	    client.send_frame(
 	      Qrack::Protocol::Queue::Unbind.new({ :queue => name,
@@ -386,88 +436,12 @@ Removes a queue binding from an exchange. If error occurs, a _Bunny_::_ProtocolE
 			:unbind_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)
-			
-	    client.send_frame(
-	      Qrack::Protocol::Queue::Delete.new({ :queue => name, :nowait => false }.merge(opts))
-	    )
-	
-			raise Bunny::ProtocolError,
-				"Error deleting queue #{name}" unless
-				client.next_method.is_a?(Qrack::Protocol::Queue::DeleteOk)
-	
-			client.queues.delete(name)
-			
-			# return confirmation
-			:delete_ok
-	  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)
+		private
 		
-    client.send_frame(
-      Qrack::Protocol::Queue::Purge.new({ :queue => name, :nowait => false }.merge(opts))
-    )
-
-		raise Bunny::ProtocolError, "Error purging queue #{name}" unless client.next_method.is_a?(Qrack::Protocol::Queue::PurgeOk)
-		
-		# return confirmation
-		:purge_ok
-		
-  end
-
-	private
-	  def exchange
+		def exchange
 	    @exchange ||= Bunny::Exchange.new(client, '', {:type => :direct, :key => name})
 	  end
-
-	  def bindings
-	    @bindings ||= {}
-	  end
+	
 	end
 	
 end