bunny 0.5.1 → 0.5.2

data/lib/bunny/client09.rb

@@ -28,6 +28,9 @@ Sets up a Bunny::Client object ready for connection to a broker/server. _Client_
 * <tt>:logging => true or false (_default_)</tt> - If set to _true_, session information is sent
   to STDOUT if <tt>:logfile</tt> has not been specified. Otherwise, session information is written to
   <tt>:logfile</tt>.
+* <tt>:frame_max => maximum frame size in bytes (default = 131072)</tt>
+* <tt>:channel_max => maximum number of channels (default = 0 no maximum)</tt>
+* <tt>:heartbeat => number of seconds (default = 0 no heartbeat)</tt>
 
 =end
 
@@ -38,15 +41,21 @@ Sets up a Bunny::Client object ready for connection to a broker/server. _Client_
       @user   = opts[:user]  || 'guest'
       @pass   = opts[:pass]  || 'guest'
       @vhost  = opts[:vhost] || '/'
-			@frame_max = opts[:frame_max] || 131072
-			@channel_max = opts[:channel_max] || 5
 			@logfile = opts[:logfile] || nil
 			@logging = opts[:logging] || false
-      @status = :not_connected
+			@status = :not_connected
+			@frame_max = opts[:frame_max] || 131072
+			@channel_max = opts[:channel_max] || 5
+			@heartbeat = opts[:heartbeat] || 0
 			@logger = nil
 			create_logger if @logging
+			@channels = []
 			# Create channel 0
       @channel = Bunny::Channel09.new(self, true)
+			@exchanges = {}
+			@queues = {}
+			@heartbeat_in = false
+			@connecting = false
     end
 
 =begin rdoc
@@ -85,18 +94,6 @@ Exchange
 
 === DESCRIPTION:
 
-Returns hash of exchanges declared by Bunny.
-
-=end
-
-		def exchanges
-			@exchanges ||= {}
-		end
-
-=begin rdoc
-
-=== DESCRIPTION:
-
 Declares a queue to the broker/server. If the queue does not exist, a new one is created
 using the arguments passed in. If the queue already exists, a reference to it is created, provided
 that the arguments passed in do not conflict with the existing attributes of the queue. If an error
@@ -135,19 +132,16 @@ Queue
 
       return queues[name] if queues.has_key?(name)
 
-      queue = Bunny::Queue09.new(self, name, opts)
+      Bunny::Queue09.new(self, name, opts)
 	  end
-	
-=begin rdoc
-
-=== DESCRIPTION:
-
-Returns hash of queues declared by Bunny.
-
-=end
 		
-		def queues
-			@queues ||= {}
+		def send_heartbeat
+			# Create a new heartbeat frame
+			hb = Qrack::Transport09::Heartbeat.new('')			
+			# Channel 0 must be used
+			switch_channel(0) if @channel.number > 0			
+			# Send the heartbeat to server
+			send_frame(hb)
 		end
 
     def send_frame(*args)
@@ -161,10 +155,27 @@ Returns hash of queues declared by Bunny.
       nil
     end
 
-    def next_frame
-      frame = Qrack::Transport09::Frame.parse(buffer)
-			@logger.info("received") { frame } if @logging
-      frame
+    def next_frame(opts = {})
+      secs = opts[:timeout] || 0
+			
+			begin
+				Timeout::timeout(secs) do
+					@frame = Qrack::Transport09::Frame.parse(buffer)
+				end
+			rescue Timeout::Error
+				return :timed_out
+			end
+			
+			@logger.info("received") { @frame } if @logging
+						
+			raise Bunny::ConnectionError, 'No connection to server' if (@frame.nil? and !connecting?)
+
+			if @frame.is_a?(Qrack::Transport09::Heartbeat)
+				@heartbeat_in = true
+				next_frame
+			end
+			
+			@frame
     end
 
     def next_payload
@@ -173,6 +184,43 @@ Returns hash of queues declared by Bunny.
     end
 
 		alias next_method next_payload
+		
+=begin rdoc
+
+=== DESCRIPTION:
+
+Checks to see whether or not an undeliverable message has been returned as a result of a publish
+with the <tt>:immediate</tt> or <tt>:mandatory</tt> options.
+
+==== OPTIONS:
+
+* <tt>:timeout => number of seconds (default = 0.1) - The method will wait for a return
+  message until this timeout interval is reached.
+
+==== RETURNS:
+
+<tt>:no_return</tt> if message was 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
+			end
+
+			method = frame.payload
+			header = next_payload
+	    msg = next_payload
+	    raise Bunny::MessageError, 'unexpected length' if msg.length < header.size
+
+			# Return the message and related info
+			{:header => header, :payload => msg, :return_details => method.arguments}
+		end
 
 =begin rdoc
 
@@ -189,12 +237,9 @@ _Bunny_::_ProtocolError_ is raised. If successful, _Client_._status_ is set to <
 
     def close
 			# Close all active channels
-			channels.each_value do |c|
+			channels.each do |c|
 				c.close if c.open?
 			end
-			
-			# Set client channel to zero
-      self.channel = channels[0]
 
 			# Close connection to AMQP server
 			close_connection
@@ -227,6 +272,8 @@ _Bunny_::_ProtocolError_ is raised. If successful, _Client_._status_ is set to <
 =end
 		
 		def start_session
+			@connecting = true
+			
 			# Create/get socket
 			socket
 			
@@ -236,12 +283,14 @@ _Bunny_::_ProtocolError_ is raised. If successful, _Client_._status_ is set to <
 			# Open connection
 			open_connection
 
-			# Open a channel
-			self.channel = get_channel
-			channel.open
+			# Open another channel because channel zero is used for specific purposes
+			c = create_channel()
+			c.open
 
+			@connecting = false
+			
 			# return status
-			status
+			@status = :connected
     end
 
 		alias start start_session
@@ -250,7 +299,7 @@ _Bunny_::_ProtocolError_ is raised. If successful, _Client_._status_ is set to <
 
 === DESCRIPTION:
 
-Asks the broker to redeliver all unacknowledged messages on a specifieid channel. Zero or
+Asks the broker to redeliver all unacknowledged messages on a specified channel. Zero or
 more messages may be redelivered.
 
 ==== Options:
@@ -376,22 +425,35 @@ after a rollback.
 			create_logger if @logging
 		end
 		
-		def channels
-			@channels ||= {}
-		end
-		
-		def get_channel
-			channels.each_value do |c|
+		def create_channel
+			channels.each do |c|
 				return c if (!c.open? and c.number != 0)
 			end
 			# If no channel to re-use instantiate new one
 			Bunny::Channel09.new(self)
 		end
 		
+		def switch_channel(chann)
+			if (0...channels.size).include? chann
+				@channel = channels[chann]
+				chann
+			else
+				raise RuntimeError, "Invalid channel number - #{chann}"
+			end
+		end
+		
+		def connecting?
+			connecting
+		end
+		
 		def init_connection
 			write(Qrack::Protocol09::HEADER)
       write([0, Qrack::Protocol09::VERSION_MAJOR, Qrack::Protocol09::VERSION_MINOR, Qrack::Protocol09::REVISION].pack('C4'))
-      raise Bunny::ProtocolError, 'Connection initiation failed' unless next_method.is_a?(Qrack::Protocol09::Connection::Start)
+
+      frame = next_frame
+			if frame.nil? or !frame.payload.is_a?(Qrack::Protocol09::Connection::Start)
+				raise Bunny::ProtocolError, 'Connection initiation failed'
+			end
 		end
 		
 		def open_connection
@@ -404,12 +466,14 @@ after a rollback.
         )
       )
 
-      method = next_method
-      raise Bunny::ProtocolError, "Connection failed - user: #{@user}, pass: #{@pass}" if method.nil?
-
+      frame = next_frame
+			raise Bunny::ProtocolError, "Connection failed - user: #{@user}, pass: #{@pass}" if frame.nil?
+			
+			method = frame.payload
+			
       if method.is_a?(Qrack::Protocol09::Connection::Tune)
         send_frame(
-          Qrack::Protocol09::Connection::TuneOk.new( :channel_max => @channel_max, :frame_max => @frame_max, :heartbeat => 0)
+          Qrack::Protocol09::Connection::TuneOk.new( :channel_max => @channel_max, :frame_max => @frame_max, :heartbeat => @heartbeat)
         )
       end
 
@@ -421,6 +485,9 @@ after a rollback.
 		end
 		
 		def close_connection
+			# Set client channel to zero
+      switch_channel(0)
+
 			send_frame(
         Qrack::Protocol09::Connection::Close.new(:reply_code => 200, :reply_text => 'Goodbye', :class_id => 0, :method_id => 0)
       )
@@ -446,8 +513,6 @@ after a rollback.
       return @socket if @socket and (@status == :connected) and not @socket.closed?
 
       begin
-        @status = :not_connected
-   
         # Attempt to connect.
         @socket = timeout(CONNECT_TIMEOUT) do
           TCPSocket.new(host, port)
@@ -456,7 +521,6 @@ after a rollback.
         if Socket.constants.include? 'TCP_NODELAY'
           @socket.setsockopt Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1
         end
-        @status   = :connected
       rescue => e
         @status = :not_connected
         raise Bunny::ServerDownError, e.message

data/lib/bunny/queue08.rb

@@ -214,17 +214,21 @@ 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
+  messages until terminated (Ctrl-C or kill command) or this timeout interval is reached.
 
 ==== 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
 
 =end
 	
 		def subscribe(opts = {}, &blk)
 			consumer_tag = opts[:consumer_tag] || name
+			secs = opts[:timeout] || 0
 			
 			# ignore the :nowait option if passed, otherwise program will hang waiting for a
 			# response from the server causing an error.
@@ -247,13 +251,19 @@ If <tt>:header => false</tt> only message payload is returned.
 				"Error subscribing to queue #{name}" unless
 				client.next_method.is_a?(Qrack::Protocol::Basic::ConsumeOk)
 			
-			while true
-				method = client.next_method
-
-				break if method.is_a?(Qrack::Protocol::Basic::CancelOk)
+			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)
 			
 				# 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
@@ -287,6 +297,10 @@ the server will not send any more messages for that consumer.
 			opts.delete(:nowait)
 			
       client.send_frame( Qrack::Protocol::Basic::Cancel.new({ :consumer_tag => consumer_tag }.merge(opts)))
+
+			raise Bunny::ProtocolError,
+				"Error unsubscribing from queue #{name}" unless
+				client.next_method.is_a?(Qrack::Protocol::Basic::CancelOk)
 			
     end
 

data/lib/bunny/queue09.rb

@@ -216,17 +216,21 @@ 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
+  messages until terminated (Ctrl-C or kill command) or this timeout interval is reached.
 
 ==== 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
 
 =end
 	
 		def subscribe(opts = {}, &blk)
 			consumer_tag = opts[:consumer_tag] || name
+			secs = opts[:timeout] || 0
 			
 			# ignore the :nowait option if passed, otherwise program will hang waiting for a
 			# response from the server causing an error.
@@ -250,13 +254,19 @@ If <tt>:header => false</tt> only message payload is returned.
 				"Error subscribing to queue #{name}" unless
 				client.next_method.is_a?(Qrack::Protocol09::Basic::ConsumeOk)
 			
-			while true
-				method = client.next_method
-
-				break if method.is_a?(Qrack::Protocol09::Basic::CancelOk)
+			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::Protocol09::Basic::CancelOk)
 			
 				# 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
@@ -290,6 +300,10 @@ the server will not send any more messages for that consumer.
 			opts.delete(:nowait)
 			
       client.send_frame( Qrack::Protocol09::Basic::Cancel.new({ :consumer_tag => consumer_tag }.merge(opts)))
+
+			raise Bunny::ProtocolError,
+				"Error unsubscribing from queue #{name}" unless
+				client.next_method.is_a?(Qrack::Protocol09::Basic::CancelOk)
 			
     end
 

data/lib/qrack/client.rb

@@ -5,8 +5,8 @@ module Qrack
 		CONNECT_TIMEOUT = 1.0
     RETRY_DELAY     = 10.0
 
-    attr_reader   :status, :host, :vhost, :port, :logging, :spec
-    attr_accessor :channel, :logfile, :exchanges, :queues, :channels
+    attr_reader   :status, :host, :vhost, :port, :logging, :spec, :heartbeat
+    attr_accessor :channel, :logfile, :exchanges, :queues, :channels, :heartbeat_in, :connecting
 
 	end
 end

data/spec/spec_08/bunny_spec.rb

@@ -19,18 +19,37 @@ describe Bunny do
     @b.status.should == :connected
   end
 
+	it "should be able to create and open a new channel" do
+		c = @b.create_channel
+		c.number.should == 2
+		c.should be_an_instance_of(Bunny::Channel)
+		@b.channels.size.should == 3
+		c.open.should == :open_ok
+		@b.channel.number.should == 2 
+	end
+	
+	it "should be able to switch between channels" do
+		@b.channel.number.should == 1
+		@b.switch_channel(0)
+		@b.channel.number.should == 0
+	end
+	
+	it "should raise an error if trying to switch to a non-existent channel" do
+		lambda { @b.switch_channel(5)}.should raise_error(RuntimeError)
+	end
+
 	it "should be able to create an exchange" do
 		exch = @b.exchange('test_exchange')
-		exch.should be_an_instance_of Bunny::Exchange
+		exch.should be_an_instance_of(Bunny::Exchange)
 		exch.name.should == 'test_exchange'
-		@b.exchanges.has_key?('test_exchange').should be true
+		@b.exchanges.has_key?('test_exchange').should be(true)
 	end
 
 	it "should be able to create a queue" do
 		q = @b.queue('test1')
-		q.should be_an_instance_of Bunny::Queue
+		q.should be_an_instance_of(Bunny::Queue)
 		q.name.should == 'test1'
-		@b.queues.has_key?('test1').should be true
+		@b.queues.has_key?('test1').should be(true)
   end
 
 	it "should be able to set QoS" do