bunny 0.5.3 → 0.6.0

data/lib/bunny/client09.rb

@@ -20,10 +20,15 @@ Sets up a Bunny::Client object ready for connection to a broker/server. _Client_
 ==== OPTIONS:
 
 * <tt>:host => '_hostname_' (default = 'localhost')</tt>
-* <tt>:port => _portno_ (default = 5672)</tt>
+* <tt>:port => _portno_ (default = 5672 or 5671 if :ssl set to true)</tt>
 * <tt>:vhost => '_vhostname_' (default = '/')</tt>
 * <tt>:user => '_username_' (default = 'guest')</tt>
 * <tt>:pass => '_password_' (default = 'guest')</tt>
+* <tt>:ssl => true or false (default = false)</tt> - If set to _true_, ssl
+  encryption will be used and port will default to 5671.
+* <tt>:verify_ssl => true or false (default = true)</tt> - If ssl is enabled,
+  this will cause OpenSSL to validate the server certificate unless this
+  parameter is set to _false_.
 * <tt>:logfile => '_logfilepath_' (default = nil)</tt>
 * <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
@@ -31,15 +36,48 @@ Sets up a Bunny::Client object ready for connection to a broker/server. _Client_
 * <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>
+* <tt>:connect_timeout => number of seconds before Qrack::ConnectionTimeout is raised (default = 5)</tt>
 
 =end
 
     def initialize(opts = {})
 			super
 			@spec = '0-9-1'
-			@port = opts[:port] || Qrack::Protocol09::PORT
+			@port = opts[:port] || (opts[:ssl] ? Qrack::Protocol09::SSL_PORT : Qrack::Protocol09::PORT)
     end
 
+=begin rdoc
+
+=== DESCRIPTION:
+
+Checks response from AMQP methods and takes appropriate action
+
+=end
+
+		def check_response(received_method, expected_method, err_msg, err_class = Bunny::ProtocolError)
+			case
+				when received_method.is_a?(Qrack::Protocol09::Connection::Close)
+					# Clean up the socket
+					close_socket
+
+					raise Bunny::ForcedConnectionCloseError,
+						"Error Reply Code: #{received_method.reply_code}\nError Reply Text: #{received_method.reply_text}"
+
+				when received_method.is_a?(Qrack::Protocol09::Channel::Close)
+					# Clean up the channel
+					channel.active = false
+
+					raise Bunny::ForcedChannelCloseError,
+						"Error Reply Code: #{received_method.reply_code}\nError Reply Text: #{received_method.reply_text}"
+
+				when !received_method.is_a?(expected_method)
+					raise err_class, err_msg
+
+				else
+					:response_ok
+			end
+		end
+
 		def close_connection
 			# Set client channel to zero
       switch_channel(0)
@@ -47,7 +85,11 @@ Sets up a Bunny::Client object ready for connection to a broker/server. _Client_
 			send_frame(
         Qrack::Protocol09::Connection::Close.new(:reply_code => 200, :reply_text => 'Goodbye', :class_id => 0, :method_id => 0)
       )
-      raise Bunny::ProtocolError, "Error closing connection" unless next_method.is_a?(Qrack::Protocol09::Connection::CloseOk)
+
+      method = next_method
+			
+			check_response(method, Qrack::Protocol09::Connection::CloseOk, "Error closing connection")
+			
 		end
 
 		def create_channel
@@ -86,8 +128,7 @@ Exchange
 =end
 
 		def exchange(name, opts = {})
-			return exchanges[name] if exchanges.has_key?(name)
-			exchanges[name] ||= Bunny::Exchange09.new(self, name, opts)
+      exchanges[name] || Bunny::Exchange09.new(self, name, opts)
 		end
 		
 		def init_connection
@@ -135,6 +176,34 @@ Exchange
 			
     end
 
+		def open_connection
+			send_frame(
+        Qrack::Protocol09::Connection::StartOk.new(
+          :client_properties => {:platform => 'Ruby', :product => 'Bunny', :information => 'http://github.com/celldee/bunny', :version => VERSION},
+          :mechanism => 'PLAIN',
+					:response => "\0" + @user + "\0" + @pass,
+          :locale => 'en_US'
+        )
+      )
+
+      frame = next_frame
+			raise Bunny::ProtocolError, "Connection failed - user: #{@user}" 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 => @heartbeat)
+        )
+      end
+
+      send_frame(
+        Qrack::Protocol09::Connection::Open.new(:virtual_host => @vhost, :reserved_1 => 0, :reserved_2 => false)
+      )
+
+      raise Bunny::ProtocolError, 'Cannot open connection' unless next_method.is_a?(Qrack::Protocol09::Connection::OpenOk)
+		end
+
 =begin rdoc
 
 === DESCRIPTION:
@@ -173,9 +242,9 @@ true, they are applied to the entire connection.
         Qrack::Protocol09::Basic::Qos.new({ :prefetch_size => 0, :prefetch_count => 1, :global => false }.merge(opts))
       )
 
-      raise Bunny::ProtocolError,
-        "Error specifying Quality of Service" unless
- 				next_method.is_a?(Qrack::Protocol09::Basic::QosOk)
+      method = next_method
+			
+			check_response(method, Qrack::Protocol09::Basic::QosOk, "Error specifying Quality of Service")
 
       # return confirmation
       :qos_ok
@@ -221,9 +290,8 @@ Queue
         name = nil
       end
 
-      return queues[name] if queues.has_key?(name)
-
-      Bunny::Queue09.new(self, name, opts)
+      # Queue is responsible for placing itself in the list of queues
+      queues[name] || Bunny::Queue09.new(self, name, opts)
 	  end
 	
 =begin rdoc
@@ -326,9 +394,9 @@ after a commit.
 		def tx_commit
 			send_frame(Qrack::Protocol09::Tx::Commit.new())
 
-			raise Bunny::ProtocolError,
-        "Error commiting transaction" unless
- 				next_method.is_a?(Qrack::Protocol09::Tx::CommitOk)
+			method = next_method
+			
+			check_response(method, Qrack::Protocol09::Tx::CommitOk, "Error commiting transaction")
 
 			# return confirmation
 			:commit_ok
@@ -350,9 +418,9 @@ after a rollback.
 		def tx_rollback
 			send_frame(Qrack::Protocol09::Tx::Rollback.new())
 
-			raise Bunny::ProtocolError,
-        "Error rolling back transaction" unless
- 				next_method.is_a?(Qrack::Protocol09::Tx::RollbackOk)
+			method = next_method
+			
+			check_response(method, Qrack::Protocol09::Tx::RollbackOk, "Error rolling back transaction")
 
 			# return confirmation
 			:rollback_ok
@@ -374,41 +442,13 @@ using the Commit or Rollback methods.
 		def tx_select
 			send_frame(Qrack::Protocol09::Tx::Select.new())
 			
-			raise Bunny::ProtocolError,
-        "Error initiating transactions for current channel" unless
- 				next_method.is_a?(Qrack::Protocol09::Tx::SelectOk)
+			method = next_method
+			
+			check_response(method, Qrack::Protocol::Tx::SelectOk, "Error initiating transactions for current channel")
 
 			# return confirmation
 			:select_ok
 		end
-		
-		def open_connection
-			send_frame(
-        Qrack::Protocol09::Connection::StartOk.new(
-          :client_properties => {:platform => 'Ruby', :product => 'Bunny', :information => 'http://github.com/celldee/bunny', :version => VERSION},
-          :mechanism => 'PLAIN',
-					:response => "\0" + @user + "\0" + @pass,
-          :locale => 'en_US'
-        )
-      )
-
-      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 => @heartbeat)
-        )
-      end
-
-      send_frame(
-        Qrack::Protocol09::Connection::Open.new(:virtual_host => @vhost, :reserved_1 => 0, :reserved_2 => false)
-      )
-
-      raise Bunny::ProtocolError, 'Cannot open connection' unless next_method.is_a?(Qrack::Protocol09::Connection::OpenOk)
-		end
 
   private
 

data/lib/bunny/exchange08.rb

@@ -63,9 +63,11 @@ specification that applies to your target broker/server.
           )
         )
 
-        raise Bunny::ProtocolError,
-          "Error declaring exchange #{name}: type = #{type}" unless
-          client.next_method.is_a?(Qrack::Protocol::Exchange::DeclareOk)
+				method = client.next_method
+
+				client.check_response(method, Qrack::Protocol::Exchange::DeclareOk,
+				 	"Error declaring exchange #{name}: type = #{type}")
+
       end
     end
 
@@ -73,6 +75,45 @@ specification that applies to your target broker/server.
 
 === DESCRIPTION:
 
+Requests that an exchange is deleted from broker/server. Removes reference from exchanges
+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 exchange if it has no queue bindings. If the exchange has queue bindings the
+  server does not delete it but raises a channel exception instead.
+* <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::Exchange::Delete.new({ :exchange => name, :nowait => false }.merge(opts))
+      )
+
+			method = client.next_method
+
+			client.check_response(method, Qrack::Protocol::Exchange::DeleteOk,
+			 	"Error deleting exchange #{name}")
+
+      client.exchanges.delete(name)
+
+      # return confirmation
+      :delete_ok
+    end
+
+=begin rdoc
+
+=== DESCRIPTION:
+
 Publishes a message to a specific exchange. The message will be routed to queues as defined
 by the exchange configuration and distributed to any active consumers when the transaction,
 if any, is committed.
@@ -103,15 +144,24 @@ nil
       opts = opts.dup
       out = []
 
+			# Set up options
+			routing_key = opts.delete(:key) || key
+			mandatory = opts.delete(:mandatory)
+			immediate = opts.delete(:immediate)
+			delivery_mode = opts.delete(:persistent) ? 2 : 1
+
       out << Qrack::Protocol::Basic::Publish.new(
-        { :exchange => name, :routing_key => opts.delete(:key) || key }.merge(opts)
+        { :exchange => name,
+					:routing_key => routing_key,
+					:mandatory => mandatory,
+					:immediate => immediate }
       )
       data = data.to_s
       out << Qrack::Protocol::Header.new(
         Qrack::Protocol::Basic,
         data.length, {
           :content_type  => 'application/octet-stream',
-          :delivery_mode => (opts.delete(:persistent) ? 2 : 1),
+          :delivery_mode => delivery_mode,
           :priority      => 0 
         }.merge(opts)
       )
@@ -120,44 +170,6 @@ nil
       client.send_frame(*out)
     end
 
-=begin rdoc
-
-=== DESCRIPTION:
-
-Requests that an exchange is deleted from broker/server. Removes reference from exchanges
-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 exchange if it has no queue bindings. If the exchange has queue bindings the
-  server does not delete it but raises a channel exception instead.
-* <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::Exchange::Delete.new({ :exchange => name, :nowait => false }.merge(opts))
-      )
-
-      raise Bunny::ProtocolError,
-        "Error deleting exchange #{name}" unless
-        client.next_method.is_a?(Qrack::Protocol::Exchange::DeleteOk)
-
-      client.exchanges.delete(name)
-      
-      # return confirmation
-      :delete_ok
-    end
-
   end
   
 end

data/lib/bunny/exchange09.rb

@@ -64,9 +64,11 @@ specification that applies to your target broker/server.
           )
         )
 
-        raise Bunny::ProtocolError,
-          "Error declaring exchange #{name}: type = #{type}" unless
-          client.next_method.is_a?(Qrack::Protocol09::Exchange::DeclareOk)
+        method = client.next_method
+
+				client.check_response(method, Qrack::Protocol09::Exchange::DeclareOk,
+				 	"Error declaring exchange #{name}: type = #{type}")
+				
       end
     end
 
@@ -74,6 +76,45 @@ specification that applies to your target broker/server.
 
 === DESCRIPTION:
 
+Requests that an exchange is deleted from broker/server. Removes reference from exchanges
+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 exchange if it has no queue bindings. If the exchange has queue bindings the
+  server does not delete it but raises a channel exception instead.
+* <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::Protocol09::Exchange::Delete.new({ :exchange => name, :nowait => false, :reserved_1 => 0 }.merge(opts))
+      )
+
+      method = client.next_method
+
+			client.check_response(method, Qrack::Protocol09::Exchange::DeleteOk,
+			 	"Error deleting exchange #{name}")
+
+      client.exchanges.delete(name)
+
+      # return confirmation
+      :delete_ok
+    end
+
+=begin rdoc
+
+=== DESCRIPTION:
+
 Publishes a message to a specific exchange. The message will be routed to queues as defined
 by the exchange configuration and distributed to any active consumers when the transaction,
 if any, is committed.
@@ -104,61 +145,33 @@ nil
       opts = opts.dup
       out = []
 
-      out << Qrack::Protocol09::Basic::Publish.new(
-        { :exchange => name, :routing_key => opts.delete(:key) || key, :reserved_1 => 0 }.merge(opts)
-      )
-      data = data.to_s
-      out << Qrack::Protocol09::Header.new(
-        Qrack::Protocol09::Basic,
-        data.length, {
-          :content_type  => 'application/octet-stream',
-          :delivery_mode => (opts.delete(:persistent) ? 2 : 1),
-          :priority      => 0 
-        }.merge(opts)
-      )
-      out << Qrack::Transport09::Body.new(data)
+			# Set up options
+			routing_key = opts.delete(:key) || key
+			mandatory = opts.delete(:mandatory)
+			immediate = opts.delete(:immediate)
+			delivery_mode = opts.delete(:persistent) ? 2 : 1
+
+			out << Qrack::Protocol09::Basic::Publish.new(
+			  { :exchange => name,
+					:routing_key => routing_key,
+					:mandatory => mandatory,
+					:immediate => immediate,
+					:reserved_1 => 0 }
+			)
+			data = data.to_s
+			out << Qrack::Protocol09::Header.new(
+			  Qrack::Protocol09::Basic,
+			  data.length, {
+			    :content_type  => 'application/octet-stream',
+			    :delivery_mode => delivery_mode,
+			    :priority      => 0 
+			  }.merge(opts)
+			)
+			out << Qrack::Transport09::Body.new(data)
 
       client.send_frame(*out)
     end
 
-=begin rdoc
-
-=== DESCRIPTION:
-
-Requests that an exchange is deleted from broker/server. Removes reference from exchanges
-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 exchange if it has no queue bindings. If the exchange has queue bindings the
-  server does not delete it but raises a channel exception instead.
-* <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::Protocol09::Exchange::Delete.new({ :exchange => name, :nowait => false, :reserved_1 => 0 }.merge(opts))
-      )
-
-      raise Bunny::ProtocolError,
-        "Error deleting exchange #{name}" unless
-        client.next_method.is_a?(Qrack::Protocol09::Exchange::DeleteOk)
-
-      client.exchanges.delete(name)
-      
-      # return confirmation
-      :delete_ok
-    end
-
   end
   
 end