bunny 0.5.3 → 0.6.0

data/lib/bunny/queue08.rb

@@ -18,6 +18,7 @@ Queues must be attached to at least one exchange in order to receive messages fr
 	    @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.
@@ -39,7 +40,8 @@ Queues must be attached to at least one exchange in order to receive messages fr
 	    )
 	
       method = client.next_method
-			raise Bunny::ProtocolError, "Error declaring queue #{name}" unless method.is_a?(Qrack::Protocol::Queue::DeclareOk)
+
+			client.check_response(method,	Qrack::Protocol::Queue::DeclareOk, "Error declaring queue #{name}")
 
       @name = method.queue
 			client.queues[@name] = self
@@ -63,8 +65,12 @@ ask to confirm a single message or a set of messages up to and including a speci
 =end
 	
 		def ack(opts={})
-			# If delivery tag is nil then set it to 1 to prevent errors
-			self.delivery_tag = 1 if self.delivery_tag.nil?
+			# 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))
@@ -104,10 +110,11 @@ bound to the direct exchange '' by default. If error occurs, a _Bunny_::_Protoco
 		 																:routing_key => opts.delete(:key),
 		 																:nowait => false }.merge(opts))
 	    )
+	
+			method = client.next_method
 
-			raise Bunny::ProtocolError,
-				"Error binding queue #{name}" unless
-				client.next_method.is_a?(Qrack::Protocol::Queue::BindOk)
+			client.check_response(method,	Qrack::Protocol::Queue::BindOk,
+				"Error binding queue: #{name} to exchange: #{exchange}")
 
 			# return message
 			:bind_ok
@@ -144,10 +151,10 @@ from queues if successful. If an error occurs raises _Bunny_::_ProtocolError_.
 	    client.send_frame(
 	      Qrack::Protocol::Queue::Delete.new({ :queue => name, :nowait => false }.merge(opts))
 	    )
+	
+			method = client.next_method
 
-			raise Bunny::ProtocolError,
-				"Error deleting queue #{name}" unless
-				client.next_method.is_a?(Qrack::Protocol::Queue::DeleteOk)
+			client.check_response(method,	Qrack::Protocol::Queue::DeleteOk, "Error deleting queue #{name}")
 
 			client.queues.delete(name)
 
@@ -162,26 +169,29 @@ 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>:header => true or false (_default_)</tt> - If set to _true_,
-  hash <tt>{:header, :delivery_details, :payload}</tt> is returned. 
-* <tt>:no_ack => true (_default_) or false</tt> - If set to _true_, the server does not expect an
-  acknowledgement message from the client. If set to _false_, the server expects an acknowledgement
+ 
+* <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:
 
-If <tt>:header => true</tt> returns hash <tt>{:header, :delivery_details, :payload}</tt>. <tt>:delivery_details</tt> is
-a hash <tt>{:delivery_tag, :redelivered, :exchange, :routing_key, :message_count}</tt>. If 
-<tt>:header => false</tt> only the message payload is returned.
+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 = {})
-			
-			# do we want the message header?
-			hdr = opts.delete(:header)
+	  def pop(opts = {}, &blk)
 			
 			# do we want to have to provide an acknowledgement?
 			ack = opts.delete(:ack)
@@ -196,25 +206,32 @@ a hash <tt>{:delivery_tag, :redelivered, :exchange, :routing_key, :message_count
 			method = client.next_method
 			
 			if method.is_a?(Qrack::Protocol::Basic::GetEmpty) then
-				return :queue_empty
+				queue_empty = true
 			elsif	!method.is_a?(Qrack::Protocol::Basic::GetOk)
 				raise Bunny::ProtocolError, "Error getting message from queue #{name}"
 			end
 			
-			# get delivery tag to use for acknowledge
-			self.delivery_tag = method.delivery_tag if ack
+			if !queue_empty
+				# get delivery tag to use for acknowledge
+				self.delivery_tag = method.delivery_tag if ack
 			
-	    header = client.next_payload
+		    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
+		    # 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
-
-			# Return message with additional info if requested
-			hdr ? {:header => header, :payload => msg, :delivery_details => method.arguments} : msg
+			
+			# Pass message hash to block or return message hash
+			blk ? blk.call(msg_hash) : msg_hash		
 			
 	  end
 	
@@ -242,8 +259,10 @@ without any formal "undo" mechanism. If an error occurs raises _Bunny_::_Protoco
 	    client.send_frame(
 	      Qrack::Protocol::Queue::Purge.new({ :queue => name, :nowait => false }.merge(opts))
 	    )
+	
+			method = client.next_method
 
-			raise Bunny::ProtocolError, "Error purging queue #{name}" unless client.next_method.is_a?(Qrack::Protocol::Queue::PurgeOk)
+			client.check_response(method,	Qrack::Protocol::Queue::PurgeOk, "Error purging queue #{name}")
 
 			# return confirmation
 			:purge_ok
@@ -266,99 +285,14 @@ Returns hash {:message_count, :consumer_count}.
 	    {:message_count => method.message_count, :consumer_count => method.consumer_count}
 	  end
 
-=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>:header => true or false (_default_)</tt> - If set to _true_, hash is delivered for each message
-  <tt>{:header, :delivery_details, :payload}</tt>.
-* <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 field is empty the
-  queue name is used.
-* <tt>:no_ack=> true (_default_) or false</tt> - If set to _true_, the server does not expect an
-  acknowledgement message from the client. If set to _false_, 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.
-
-==== 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 Qrack::ClientTimeout is raised
-
-=end
 	
-		def subscribe(opts = {}, &blk)
-			# 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.
-			opts.delete(:nowait)
-			
-			# do we want the message header?
-			hdr = opts.delete(:header)
-			
-			# do we want to have to provide an acknowledgement?
-			ack = opts.delete(:ack)
-			
-			client.send_frame(
-				Qrack::Protocol::Basic::Consume.new({ :queue => name,
-																	 		 :consumer_tag => consumer_tag,
-																	 		 :no_ack => !ack,
-																	 		 :nowait => false }.merge(opts))
-			)
-			
-			raise Bunny::ProtocolError,
-				"Error subscribing to queue #{name}" unless
-				client.next_method.is_a?(Qrack::Protocol::Basic::ConsumeOk)
-			
-			# Initialize message counter
-			counter = 0
-			
-			loop do
-        method = client.next_method(:timeout => opts[:timeout])
-			
-				# 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
-				
-				# 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
+    def subscribe(opts = {}, &blk)
+			# Create subscription
+			s = Bunny::Subscription.new(client, self, opts)
+			s.start(&blk)
 			
+			# Reset when subscription finished
+			@subscription = nil
 		end
 		
 =begin rdoc
@@ -380,20 +314,28 @@ the server will not send any more messages for that consumer.
 =end
 		
 		def unsubscribe(opts = {})
-			consumer_tag = opts[:consumer_tag] || name
+			# Default consumer_tag from subscription if not passed in
+			consumer_tag = subscription ? subscription.consumer_tag : opts[:consumer_tag]
 			
-			# ignore the :nowait option if passed, otherwise program will hang waiting for a
-			# response from the server causing an error
-			opts.delete(:nowait)
+			# Must have consumer tag to tell server what to unsubscribe
+			raise Bunny::UnsubscribeError,
+				"No consumer tag received" if !consumer_tag
 			
-      client.send_frame( Qrack::Protocol::Basic::Cancel.new({ :consumer_tag => consumer_tag }.merge(opts)))
+      # 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}")
 
-			raise Bunny::ProtocolError,
-				"Error unsubscribing from queue #{name}" unless
-				client.next_method.is_a?(Qrack::Protocol::Basic::CancelOk)
+			# Reset subscription
+			@subscription = nil
 				
-			# return confirmation
+			# Return confirmation
 			:unsubscribe_ok
+			
     end
 
 =begin rdoc
@@ -428,9 +370,9 @@ Removes a queue binding from an exchange. If error occurs, a _Bunny_::_ProtocolE
 	      )
 	    )
 	
-			raise Bunny::ProtocolError,
-				"Error unbinding queue #{name}" unless
-				client.next_method.is_a?(Qrack::Protocol::Queue::UnbindOk)
+			method = client.next_method
+
+			client.check_response(method,	Qrack::Protocol::Queue::UnbindOk, "Error unbinding queue #{name}")
 				
 			# return message
 			:unbind_ok

data/lib/bunny/queue09.rb

@@ -40,7 +40,8 @@ Queues must be attached to at least one exchange in order to receive messages fr
 	    )
 	
       method = client.next_method
-			raise Bunny::ProtocolError, "Error declaring queue #{name}" unless method.is_a?(Qrack::Protocol09::Queue::DeclareOk)
+
+			client.check_response(method,	Qrack::Protocol09::Queue::DeclareOk, "Error declaring queue #{name}")
 
       @name = method.queue
 			client.queues[@name] = self
@@ -64,8 +65,12 @@ ask to confirm a single message or a set of messages up to and including a speci
 =end
 	
 		def ack(opts={})
-			# If delivery tag is nil then set it to 1 to prevent errors
-			self.delivery_tag = 1 if self.delivery_tag.nil?
+			# 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::Protocol09::Basic::Ack.new({:delivery_tag => delivery_tag, :multiple => false}.merge(opts))
@@ -107,9 +112,10 @@ bound to the direct exchange '' by default. If error occurs, a _Bunny_::_Protoco
 		 																:reserved_1 => 0 }.merge(opts))
 	    )
 
-			raise Bunny::ProtocolError,
-				"Error binding queue #{name}" unless
-				client.next_method.is_a?(Qrack::Protocol09::Queue::BindOk)
+			method = client.next_method
+
+			client.check_response(method,	Qrack::Protocol09::Queue::BindOk,
+				"Error binding queue: #{name} to exchange: #{exchange}")
 
 			# return message
 			:bind_ok
@@ -147,9 +153,9 @@ from queues if successful. If an error occurs raises _Bunny_::_ProtocolError_.
 	      Qrack::Protocol09::Queue::Delete.new({ :queue => name, :nowait => false, :reserved_1 => 0 }.merge(opts))
 	    )
 
-			raise Bunny::ProtocolError,
-				"Error deleting queue #{name}" unless
-				client.next_method.is_a?(Qrack::Protocol09::Queue::DeleteOk)
+			method = client.next_method
+
+			client.check_response(method,	Qrack::Protocol09::Queue::DeleteOk, "Error deleting queue #{name}")
 
 			client.queues.delete(name)
 
@@ -164,26 +170,29 @@ 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>:header => true or false (_default_)</tt> - If set to _true_,
-  hash <tt>{:header, :delivery_details, :payload}</tt> is returned. 
-* <tt>:no_ack => true (_default_) or false</tt> - If set to _true_, the server does not expect an
-  acknowledgement message from the client. If set to _false_, the server expects an acknowledgement
+ 
+* <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:
 
-If <tt>:header => true</tt> returns hash <tt>{:header, :delivery_details, :payload}</tt>. <tt>:delivery_details</tt> is
-a hash <tt>{:delivery_tag, :redelivered, :exchange, :routing_key, :message_count}</tt>. If 
-<tt>:header => false</tt> only the message payload is returned.
+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 = {})
-			
-			# do we want the message header?
-			hdr = opts.delete(:header)
+	  def pop(opts = {}, &blk)
 			
 			# do we want to have to provide an acknowledgement?
 			ack = opts.delete(:ack)
@@ -199,26 +208,33 @@ a hash <tt>{:delivery_tag, :redelivered, :exchange, :routing_key, :message_count
 			method = client.next_method
 			
 			if method.is_a?(Qrack::Protocol09::Basic::GetEmpty) then
-				return :queue_empty
+				queue_empty = true
 			elsif	!method.is_a?(Qrack::Protocol09::Basic::GetOk)
 				raise Bunny::ProtocolError, "Error getting message from queue #{name}"
 			end
-			
-			# 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
+
+			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
 
-			# Return message with additional info if requested
-			hdr ? {:header => header, :payload => msg, :delivery_details => method.arguments} : msg
-			
+			# Pass message hash to block or return message hash
+			blk ? blk.call(msg_hash) : msg_hash		
+
 	  end
 	
 =begin rdoc
@@ -246,7 +262,9 @@ without any formal "undo" mechanism. If an error occurs raises _Bunny_::_Protoco
 	      Qrack::Protocol09::Queue::Purge.new({ :queue => name, :nowait => false, :reserved_1 => 0 }.merge(opts))
 	    )
 
-			raise Bunny::ProtocolError, "Error purging queue #{name}" unless client.next_method.is_a?(Qrack::Protocol09::Queue::PurgeOk)
+			method = client.next_method
+
+			client.check_response(method,	Qrack::Protocol09::Queue::PurgeOk, "Error purging queue #{name}")
 
 			# return confirmation
 			:purge_ok
@@ -269,100 +287,13 @@ Returns hash {:message_count, :consumer_count}.
 	    {:message_count => method.message_count, :consumer_count => method.consumer_count}
 	  end
 
-=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>:header => true or false (_default_)</tt> - If set to _true_, hash is delivered for each message
-  <tt>{:header, :delivery_details, :payload}</tt>.
-* <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 field is empty the
-  queue name is used.
-* <tt>:no_ack=> true (_default_) or false</tt> - If set to _true_, the server does not expect an
-  acknowledgement message from the client. If set to _false_, 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.
-
-==== 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 Qrack::ClientTimeout is raised
-
-=end
-	
 		def subscribe(opts = {}, &blk)
-			# 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.
-			opts.delete(:nowait)
-			
-			# do we want the message header?
-			hdr = opts.delete(:header)
-			
-			# do we want to have to provide an acknowledgement?
-			ack = opts.delete(:ack)
-			
-			client.send_frame(
-				Qrack::Protocol09::Basic::Consume.new({ :reserved_1 => 0,
-																			 					:queue => name,
-																	 		 					:consumer_tag => consumer_tag,
-																	 		 					:no_ack => !ack,
-																	 		 					:nowait => false }.merge(opts))
-			)
-			
-			raise Bunny::ProtocolError,
-				"Error subscribing to queue #{name}" unless
-				client.next_method.is_a?(Qrack::Protocol09::Basic::ConsumeOk)
-				
-			# Initialize message counter
-			counter = 0
-			
-			loop do
-        method = client.next_method(:timeout => opts[:timeout])
-			
-				# 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
-				
-				# 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
+			# Create subscription
+			s = Bunny::Subscription09.new(client, self, opts)
+			s.start(&blk)
 			
+			# Reset when subscription finished
+			@subscription = nil
 		end
 		
 =begin rdoc
@@ -398,9 +329,9 @@ Removes a queue binding from an exchange. If error occurs, a _Bunny_::_ProtocolE
 	      )
 	    )
 
-			raise Bunny::ProtocolError,
-				"Error unbinding queue #{name}" unless
-				client.next_method.is_a?(Qrack::Protocol09::Queue::UnbindOk)
+			method = client.next_method
+
+			client.check_response(method,	Qrack::Protocol09::Queue::UnbindOk, "Error unbinding queue #{name}")
 
 			# return message
 			:unbind_ok
@@ -425,19 +356,26 @@ the server will not send any more messages for that consumer.
 =end
 		
 		def unsubscribe(opts = {})
-			consumer_tag = opts[:consumer_tag] || name
+			# Default consumer_tag from subscription if not passed in
+			consumer_tag = subscription ? subscription.consumer_tag : opts[:consumer_tag]
 			
-			# ignore the :nowait option if passed, otherwise program will hang waiting for a
-			# response from the server causing an error
-			opts.delete(:nowait)
+			# Must have consumer tag to tell server what to unsubscribe
+			raise Bunny::UnsubscribeError,
+				"No consumer tag received" if !consumer_tag
 			
-      client.send_frame( Qrack::Protocol09::Basic::Cancel.new({ :consumer_tag => consumer_tag }.merge(opts)))
+      # Cancel consumer
+      client.send_frame( Qrack::Protocol09::Basic::Cancel.new(:consumer_tag => consumer_tag,
+																														:nowait => false))
 
-			raise Bunny::ProtocolError,
-				"Error unsubscribing from queue #{name}" unless
-				client.next_method.is_a?(Qrack::Protocol09::Basic::CancelOk)
+			method = client.next_method
+
+			client.check_response(method,	Qrack::Protocol09::Basic::CancelOk,
+				"Error unsubscribing from queue #{name}")
+
+			# Reset subscription
+			@subscription = nil
 				
-			# return confirmation
+			# Return confirmation
 			:unsubscribe_ok
 			
     end