bunny 0.5.3 → 0.6.0

data/lib/bunny/subscription08.rb

@@ -0,0 +1,85 @@
+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 Qrack::ClientTimeout is raised if method times out
+waiting to receive the next message from the queue.
+
+==== 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 < Qrack::Subscription
+
+	
+		def setup_consumer
+			client.send_frame(
+				Qrack::Protocol::Basic::Consume.new({ :queue => queue.name,
+																					 		:consumer_tag => consumer_tag,
+																					 		:no_ack => !ack,
+																							:exclusive => exclusive,
+																					 		:nowait => false }.merge(@opts))
+												)
+
+			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/bunny/subscription09.rb

@@ -0,0 +1,85 @@
+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 Qrack::ClientTimeout is raised if method times out
+waiting to receive the next message from the queue.
+
+==== EXAMPLES
+
+my_queue.subscribe(:timeout => 5) {|msg| puts msg[:payload]}
+
+my_queue.subscribe(:message_max => 10, :ack => true) {|msg| puts msg[:payload]}
+
+=end
+	
+	class Subscription09 < Qrack::Subscription
+	
+		def setup_consumer
+			client.send_frame(
+				Qrack::Protocol09::Basic::Consume.new({ :reserved_1 => 0,
+																			 					:queue => queue.name,
+																	 		 					:consumer_tag => consumer_tag,
+																	 		 					:no_ack => !ack,
+																								:exclusive => exclusive,
+																	 		 					:nowait => false}.merge(@opts))
+												)
+
+			method = client.next_method
+
+			client.check_response(method,	Qrack::Protocol09::Basic::ConsumeOk,
+				"Error subscribing to queue #{queue.name}")
+
+			@consumer_tag = method.consumer_tag
+		
+		end
+	
+	end
+	
+end

data/lib/qrack/client.rb

@@ -1,11 +1,12 @@
 module Qrack
 	
 	class ClientTimeout < Timeout::Error; end
+  class ConnectionTimeout < Timeout::Error; end
 	
 	# Client ancestor class
 	class Client
 		
-		CONNECT_TIMEOUT = 1.0
+		CONNECT_TIMEOUT = 5.0
     RETRY_DELAY     = 10.0
 
     attr_reader   :status, :host, :vhost, :port, :logging, :spec, :heartbeat
@@ -19,10 +20,13 @@ module Qrack
       @vhost  = opts[:vhost] || '/'
 			@logfile = opts[:logfile] || nil
 			@logging = opts[:logging] || false
+			@ssl = opts[:ssl] || false
+      @verify_ssl = opts[:verify_ssl].nil? || opts[:verify_ssl]
       @status = :not_connected
 			@frame_max = opts[:frame_max] || 131072
 			@channel_max = opts[:channel_max] || 0
 			@heartbeat = opts[:heartbeat] || 0
+      @connect_timeout = opts[:connect_timeout] || CONNECT_TIMEOUT
 			@logger = nil
 			create_logger if @logging
 			@message_in = false
@@ -100,24 +104,30 @@ with the <tt>:immediate</tt> or <tt>:mandatory</tt> options.
 
 ==== RETURNS:
 
-<tt>:no_return</tt> if message was not returned before timeout .
+<tt>{:header => nil, :payload => :no_return, :return_details => nil}</tt> if message is
+not returned before timeout.
 <tt>{:header, :return_details, :payload}</tt> if message is returned. <tt>:return_details</tt> is
 a hash <tt>{:reply_code, :reply_text, :exchange, :routing_key}</tt>.
 
 =end
 
 		def returned_message(opts = {})
-			secs = opts[:timeout] || 0.1		
-			frame = next_frame(:timeout => secs)
-
-			if frame.is_a?(Symbol)
-				return :no_return if frame == :timed_out
+			
+			begin		
+				frame = next_frame(:timeout => opts[:timeout] || 0.1)
+			rescue Qrack::ClientTimeout
+				return {:header => nil, :payload => :no_return, :return_details => nil}
 			end
 
 			method = frame.payload
 			header = next_payload
-	    msg = 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 += next_payload
+			end
 
 			# Return the message and related info
 			{:header => header, :payload => msg, :return_details => method.arguments}
@@ -165,13 +175,22 @@ a hash <tt>{:reply_code, :reply_text, :exchange, :routing_key}</tt>.
 
       begin
         # Attempt to connect.
-        @socket = timeout(CONNECT_TIMEOUT) do
+        @socket = timeout(@connect_timeout, ConnectionTimeout) do
           TCPSocket.new(host, port)
         end
 
         if Socket.constants.include? 'TCP_NODELAY'
           @socket.setsockopt Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1
         end
+
+        if @ssl
+          require 'openssl' unless defined? OpenSSL::SSL
+          @socket = OpenSSL::SSL::SSLSocket.new(@socket)
+          @socket.sync_close = true
+          @socket.connect
+          @socket.post_connection_check(host) if @verify_ssl
+          @socket
+        end
       rescue => e
         @status = :not_connected
         raise Bunny::ServerDownError, e.message

data/lib/qrack/protocol/spec08.rb

@@ -12,6 +12,7 @@ module Qrack
     VERSION_MINOR = 0
     REVISION      = 0
     PORT          = 5672
+		SSL_PORT			= 5671
 
     RESPONSES = {
       200 => :REPLY_SUCCESS,

data/lib/qrack/protocol/spec09.rb

@@ -12,6 +12,7 @@ module Qrack
     VERSION_MINOR = 9
     REVISION      = 1
     PORT          = 5672
+		SSL_PORT			= 5671
 
     RESPONSES = {
       200 => :REPLY_SUCCESS,

data/lib/qrack/qrack08.rb

@@ -9,6 +9,7 @@ require 'transport/frame08'
 require 'qrack/client'
 require 'qrack/channel'
 require 'qrack/queue'
+require 'qrack/subscription'
 
 module Qrack
 	

data/lib/qrack/qrack09.rb

@@ -9,6 +9,7 @@ require 'transport/frame09'
 require 'qrack/client'
 require 'qrack/channel'
 require 'qrack/queue'
+require 'qrack/subscription'
 
 module Qrack
 	

data/lib/qrack/queue.rb

@@ -4,7 +4,7 @@ module Qrack
 	class Queue
 		
 		attr_reader :name, :client
-	  attr_accessor :delivery_tag
+	  attr_accessor :delivery_tag, :subscription
 	
 =begin rdoc
 

data/lib/qrack/subscription.rb

@@ -0,0 +1,102 @@
+module Qrack
+	# Subscription ancestor class
+	class Subscription
+		
+		attr_accessor :consumer_tag, :delivery_tag, :message_max, :timeout, :ack, :exclusive
+		attr_reader :client, :queue, :message_count
+	
+		def initialize(client, queue, opts = {})
+			@client = client
+			@queue = queue
+		
+			# Get timeout value
+			@timeout = opts[:timeout] || nil
+		
+			# Get maximum amount of messages to process
+			@message_max = opts[:message_max] || nil
+
+			# 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 to have to provide an acknowledgement?
+			@ack = opts[:ack] || nil
+			
+			# Does this consumer want exclusive use of the queue?
+			@exclusive = opts[:exclusive] || false
+		
+			# Initialize message counter
+			@message_count = 0
+			
+			# Give queue reference to this subscription
+			@queue.subscription = self
+			
+			# Store options
+			@opts = opts
+		
+		end
+		
+		def start(&blk)
+			
+			# Do not process any messages if zero message_max
+			if message_max == 0
+				return
+			end
+			
+			# Notify server about new consumer
+			setup_consumer
+
+			# Start subscription loop
+			loop do
+			
+				begin
+					method = client.next_method(:timeout => timeout)
+				rescue Qrack::ClientTimeout
+					queue.unsubscribe()
+					break
+				end
+				
+				# Increment message counter
+				@message_count += 1
+		
+				# get delivery tag to use for acknowledge
+				queue.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
+
+				# If block present, pass the message info to the block for processing		
+				blk.call({:header => header, :payload => msg, :delivery_details => method.arguments}) if !blk.nil?
+
+				# Exit loop if message_max condition met
+				if (!message_max.nil? and message_count == message_max)
+					# Stop consuming messages
+					queue.unsubscribe()				
+					# Acknowledge receipt of the final message
+					queue.ack() if @ack
+					# Quit the loop
+					break
+				end
+			
+				# Have to do the ack here because the ack triggers the release of messages from the server
+				# if you are using Client#qos prefetch and you will get extra messages sent through before
+				# the unsubscribe takes effect to stop messages being sent to this consumer unless the ack is
+				# deferred.
+				queue.ack() if @ack
+		
+			end
+		
+		end
+		
+	end
+	
+end

data/spec/spec_08/bunny_spec.rb

@@ -52,6 +52,12 @@ describe Bunny do
 		@b.queues.has_key?('test1').should be(true)
   end
 
+	# Current RabbitMQ has not implemented some functionality
+	it "should raise an error if setting of QoS fails" do
+		lambda { @b.qos(:global => true) }.should raise_error(Bunny::ForcedConnectionCloseError)
+		@b.status.should == :not_connected
+	end
+
 	it "should be able to set QoS" do
 		@b.qos.should == :qos_ok
 	end

data/spec/spec_08/connection_spec.rb

@@ -0,0 +1,12 @@
+# connection_spec.rb
+
+require File.expand_path(File.join(File.dirname(__FILE__), %w[.. .. lib bunny]))
+
+describe Bunny do
+	
+	it "should raise an error if the wrong user name or password is used" do
+		b = Bunny.new(:user => 'wrong')
+		lambda { b.start}.should raise_error(Bunny::ProtocolError)	
+	end
+	
+end

data/spec/spec_08/exchange_spec.rb

@@ -8,7 +8,7 @@
 
 require File.expand_path(File.join(File.dirname(__FILE__), %w[.. .. lib bunny]))
 
-describe Bunny do
+describe 'Exchange' do
 
 	before(:each) do
     @b = Bunny.new
@@ -16,7 +16,8 @@ describe Bunny do
 	end
 
 	it "should raise an error if instantiated as non-existent type" do
-		lambda { @b.exchange('bogus_ex', :type => :bogus) }.should raise_error(Bunny::ProtocolError)
+		lambda { @b.exchange('bogus_ex', :type => :bogus) }.should raise_error(Bunny::ForcedConnectionCloseError)
+		@b.status.should == :not_connected
 	end
 	
 	it "should allow a default direct exchange to be instantiated by specifying :type" do
@@ -124,13 +125,28 @@ describe Bunny do
   end
 	
 	it "should be able to return an undeliverable message" do
-		exch = @b.exchange('')
+		exch = @b.exchange('return_exch')
 		exch.publish('This message should be undeliverable', :immediate => true)
 		ret_msg = @b.returned_message
 		ret_msg.should be_an_instance_of(Hash)
 		ret_msg[:payload].should == 'This message should be undeliverable'
 	end
 	
+	it "should be able to return a message that exceeds maximum frame size" do
+		exch = @b.exchange('return_exch')
+		lg_msg = 'z' * 142000
+		exch.publish(lg_msg, :immediate => true)
+		ret_msg = @b.returned_message
+		ret_msg.should be_an_instance_of(Hash)
+		ret_msg[:payload].should == lg_msg
+	end
+	
+	it "should report an error if delete fails" do
+		exch = @b.exchange('direct_exchange')
+		lambda { exch.delete(:exchange => 'bogus_ex') }.should raise_error(Bunny::ForcedChannelCloseError)
+		@b.channel.active.should == false
+	end
+	
 	it "should be able to be deleted" do
 		exch = @b.exchange('direct_exchange')
 		res = exch.delete