bunny 0.6.3.rc2 → 0.7

data/lib/qrack/client.rb

@@ -1,166 +1,161 @@
+# encoding: utf-8
+
+require "qrack/amq-client-url"
+
 module Qrack
-	
-	class ClientTimeout < Timeout::Error; end
+
+  class ClientTimeout < Timeout::Error; end
   class ConnectionTimeout < Timeout::Error; end
-	
-	# Client ancestor class
-	class Client
-		
-		CONNECT_TIMEOUT = 5.0
+
+  # Client ancestor class
+  class Client
+
+    CONNECT_TIMEOUT = 5.0
     RETRY_DELAY     = 10.0
 
     attr_reader   :status, :host, :vhost, :port, :logging, :spec, :heartbeat
-    attr_accessor :channel, :logfile, :exchanges, :queues, :channels, :message_in, :message_out,
- 									:connecting
+    attr_accessor :channel, :logfile, :exchanges, :queues, :channels, :message_in, :message_out, :connecting
+
 
-		def initialize(opts = {})
-			@host = opts[:host] || 'localhost'
+    def initialize(connection_string_or_opts = Hash.new, opts = Hash.new)
+      opts = case connection_string_or_opts
+      when String then
+        AMQ::Client::Settings.parse_amqp_url(connection_string_or_opts)
+      when Hash then
+        connection_string_or_opts
+      else
+        Hash.new
+      end.merge(opts)
+
+      @host   = opts[:host] || 'localhost'
       @user   = opts[:user]  || 'guest'
       @pass   = opts[:pass]  || 'guest'
       @vhost  = opts[:vhost] || '/'
-			@logfile = opts[:logfile] || nil
-			@logging = opts[:logging] || false
-			@ssl = opts[:ssl] || false
+      @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
+      @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
-			@message_out = false
-			@connecting = false
-			@channels ||= []
-			# Create channel 0
+      @read_write_timeout = opts[:socket_timeout]
+      @read_write_timeout = nil if @read_write_timeout == 0
+      @disconnect_timeout = @read_write_timeout || @connect_timeout
+      @logger = nil
+      create_logger if @logging
+      @message_in = false
+      @message_out = false
+      @connecting = false
+      @channels ||= []
+      # Create channel 0
       @channel = create_channel()
-			@exchanges ||= {}
-			@queues ||= {}
-		end
-		
-=begin rdoc
-
-=== DESCRIPTION:
-
-Closes all active communication channels and connection. If an error occurs a
-_Bunny_::_ProtocolError_ is raised. If successful, _Client_._status_ is set to <tt>:not_connected</tt>.
-
-==== RETURNS:
-
-<tt>:not_connected</tt> if successful.
-
-=end
-
-		def close
-			# Close all active channels
-			channels.each do |c|
-				c.close if c.open?
-			end
-
-			# Close connection to AMQP server
-			close_connection
-
-			# Clear the channels
-			@channels = []
-
-			# Create channel 0
-			@channel = create_channel()
-
-			# Close TCP Socket
-			close_socket
-		end
-
-		alias stop close
-		
-		def connected?
-			status == :connected
-		end
-		
-		def connecting?
-			connecting
-		end
-		
-		def logging=(bool)
-			@logging = bool
-			create_logger if @logging
-		end
-		
+      @exchanges ||= {}
+      @queues ||= {}
+    end
+
+
+    # Closes all active communication channels and connection. If an error occurs a @Bunny::ProtocolError@ is raised. If successful, @Client.status@ is set to @:not_connected@.
+
+    # @return [Symbol] @:not_connected@ if successful.
+    def close
+      return if @socket.nil? || @socket.closed?
+
+      # Close all active channels
+      channels.each do |c|
+        Bunny::Timer::timeout(@disconnect_timeout) { c.close } if c.open?
+      end
+
+      # Close connection to AMQP server
+      Bunny::Timer::timeout(@disconnect_timeout) { close_connection }
+
+    rescue Exception
+      # http://cheezburger.com/Asset/View/4033311488
+    ensure
+      # Clear the channels
+      @channels = []
+
+      # Create channel 0
+      @channel = create_channel()
+
+      # Close TCP Socket
+      close_socket
+    end
+
+    alias stop close
+
+    def connected?
+      status == :connected
+    end
+
+    def connecting?
+      connecting
+    end
+
+    def logging=(bool)
+      @logging = bool
+      create_logger if @logging
+    end
+
     def next_payload(options = {})
-      next_frame(options).payload
+      res = next_frame(options)
+      res.payload if res
     end
 
-		alias next_method next_payload
+    alias next_method next_payload
 
     def read(*args)
-      begin
-        send_command(:read, *args)
+      send_command(:read, *args)
       # Got a SIGINT while waiting; give any traps a chance to run
-      rescue Errno::EINTR
-        retry
+    rescue Errno::EINTR
+      retry
+    end
+
+  # 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.
+
+  # @param [Hash] opts Options.
+  # @option opts [Numeric] :timeout (0.1) The method will wait for a return message until this timeout interval is reached.
+  # @return [Hash] @{:header => nil, :payload => :no_return, :return_details => nil}@ if message is not returned before timeout. @{:header, :return_details, :payload}@ if message is returned. @:return_details@ is a hash @{:reply_code, :reply_text, :exchange, :routing_key}@.
+    def returned_message(opts = {})
+
+      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
+
+      # 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}
+    end
+
+    def switch_channel(chann)
+      if (0...channels.size).include? chann
+        @channel = channels[chann]
+        chann
+      else
+        raise RuntimeError, "Invalid channel number - #{chann}"
       end
-        
     end
 
-=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>{: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 = {})
-			
-			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
-	
-			# 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}
-		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 write(*args)
+    def write(*args)
       send_command(:write, *args)
     end
-		
-		private
-		
-		def close_socket(reason=nil)
+
+    private
+
+    def close_socket(reason=nil)
       # Close the socket. The server is not considered dead.
       @socket.close if @socket and not @socket.closed?
       @socket   = nil
@@ -168,16 +163,22 @@ a hash <tt>{:reply_code, :reply_text, :exchange, :routing_key}</tt>.
     end
 
     def create_logger
-			@logfile ? @logger = Logger.new("#{logfile}") : @logger = Logger.new(STDOUT)
-			@logger.level = Logger::INFO
-			@logger.datetime_format = "%Y-%m-%d %H:%M:%S"
+      @logfile ? @logger = Logger.new("#{logfile}") : @logger = Logger.new(STDOUT)
+      @logger.level = Logger::INFO
+      @logger.datetime_format = "%Y-%m-%d %H:%M:%S"
     end
-		
-		def send_command(cmd, *args)
+
+    def send_command(cmd, *args)
       begin
-				raise Bunny::ConnectionError, 'No connection - socket has not been created' if !@socket
-        @socket.__send__(cmd, *args)
-      rescue Errno::EPIPE, IOError => e
+        raise Bunny::ConnectionError, 'No connection - socket has not been created' if !@socket
+        if @read_write_timeout
+          Bunny::Timer::timeout(@read_write_timeout, Qrack::ClientTimeout) do
+            @socket.__send__(cmd, *args)
+          end
+        else
+          @socket.__send__(cmd, *args)
+        end
+      rescue Errno::EPIPE, Errno::EAGAIN, Qrack::ClientTimeout, IOError => e
         # Ensure we close the socket when we are down to prevent further
         # attempts to write to a closed socket
         close_socket
@@ -190,7 +191,7 @@ a hash <tt>{:reply_code, :reply_text, :exchange, :routing_key}</tt>.
 
       begin
         # Attempt to connect.
-        @socket = timeout(@connect_timeout, ConnectionTimeout) do
+        @socket = Bunny::Timer::timeout(@connect_timeout, ConnectionTimeout) do
           TCPSocket.new(host, port)
         end
 
@@ -213,7 +214,7 @@ a hash <tt>{:reply_code, :reply_text, :exchange, :routing_key}</tt>.
 
       @socket
     end
-		
-	end
-	
+
+  end
+
 end

data/lib/qrack/errors.rb

@@ -0,0 +1,5 @@
+module Qrack
+  # Errors
+  class BufferOverflowError < StandardError; end
+  class InvalidTypeError < StandardError; end
+end

data/lib/qrack/protocol/protocol08.rb

@@ -1,132 +1,134 @@
+# encoding: utf-8
+
 module Qrack
-	module Protocol
-	  #:stopdoc:
-	  class Class::Method
-	    def initialize *args
-	      opts = args.pop if args.last.is_a? Hash
-	      opts ||= {}
-      
-	      if args.size == 1 and args.first.is_a? Transport::Buffer
-	        buf = args.shift
-	      else
-	        buf = nil
-	      end
-
-	      self.class.arguments.each do |type, name|
-	        val = buf ? buf.read(type) :
-	                    args.shift || opts[name] || opts[name.to_s]
-	        instance_variable_set("@#{name}", val)
-	      end
-	    end
-
-	    def arguments
-	      self.class.arguments.inject({}) do |hash, (type, name)|
-	        hash.update name => instance_variable_get("@#{name}")
-	      end
-	    end
-
-	    def to_binary
-	      buf = Transport::Buffer.new
-	      buf.write :short, self.class.parent.id
-	      buf.write :short, self.class.id
-
-	      bits = []
-
-	      self.class.arguments.each do |type, name|
-	        val = instance_variable_get("@#{name}")
-	        if type == :bit
-	          bits << (val || false)
-	        else
-	          unless bits.empty?
-	            buf.write :bit, bits
-	            bits = []
-	          end
-	          buf.write type, val
-	        end
-	      end
-
-	      buf.write :bit, bits unless bits.empty?
-	      buf.rewind
-
-	      buf
-	    end
-    
-	    def to_s
-	      to_binary.to_s
-	    end
-    
-	    def to_frame channel = 0
-	      Transport::Method.new(self, channel)
-	    end
-	  end
-
-	  class Header
-	    def initialize *args
-	      opts = args.pop if args.last.is_a? Hash
-	      opts ||= {}
-      
-	      first = args.shift
-      
-	      if first.is_a? ::Class and first.ancestors.include? Protocol::Class
-	        @klass = first
-	        @size = args.shift || 0
-	        @weight = args.shift || 0
-	        @properties = opts
-
-	      elsif first.is_a? Transport::Buffer or first.is_a? String
-	        buf = first
-	        buf = Transport::Buffer.new(buf) unless buf.is_a? Transport::Buffer
-        
-	        @klass = Protocol.classes[buf.read(:short)]
-	        @weight = buf.read(:short)
-	        @size = buf.read(:longlong)
-
-	        props = buf.read(:properties, *klass.properties.map{|type,_| type })
-	        @properties = Hash[*klass.properties.map{|_,name| name }.zip(props).reject{|k,v| v.nil? }.flatten]
-
-	      else
-	        raise ArgumentError, 'Invalid argument'
-	      end
-      
-	    end
-	    attr_accessor :klass, :size, :weight, :properties
-    
-	    def to_binary
-	      buf = Transport::Buffer.new
-	      buf.write :short, klass.id
-	      buf.write :short, weight # XXX rabbitmq only supports weight == 0
-	      buf.write :longlong, size
-	      buf.write :properties, (klass.properties.map do |type, name|
-	                               [ type, properties[name] || properties[name.to_s] ]
-	                             end)
-	      buf.rewind
-	      buf
-	    end
-    
-	    def to_s
-	      to_binary.to_s
-	    end
-
-	    def to_frame channel = 0
-	      Transport::Header.new(self, channel)
-	    end
-
-	    def == header
-	      [ :klass, :size, :weight, :properties ].inject(true) do |eql, field|
-	        eql and __send__(field) == header.__send__(field)
-	      end
-	    end
-
-	    def method_missing meth, *args, &blk
-	      @properties.has_key?(meth) || @klass.properties.find{|_,name| name == meth } ? @properties[meth] : super
-	    end
-	  end
-
-	  def self.parse buf
-	    buf = Transport::Buffer.new(buf) unless buf.is_a? Transport::Buffer
-	    class_id, method_id = buf.read(:short, :short)
-	    classes[class_id].methods[method_id].new(buf)
-	  end
-
-	end
+  module Protocol
+    #:stopdoc:
+    class Class::Method
+      def initialize *args
+        opts = args.pop if args.last.is_a? Hash
+        opts ||= {}
+
+        if args.size == 1 and args.first.is_a? Transport::Buffer
+          buf = args.shift
+        else
+          buf = nil
+        end
+
+        self.class.arguments.each do |type, name|
+          val = buf ? buf.read(type) :
+            args.shift || opts[name] || opts[name.to_s]
+          instance_variable_set("@#{name}", val)
+        end
+      end
+
+      def arguments
+        self.class.arguments.inject({}) do |hash, (type, name)|
+          hash.update name => instance_variable_get("@#{name}")
+        end
+      end
+
+      def to_binary
+        buf = Transport::Buffer.new
+        buf.write :short, self.class.parent.id
+        buf.write :short, self.class.id
+
+        bits = []
+
+        self.class.arguments.each do |type, name|
+          val = instance_variable_get("@#{name}")
+          if type == :bit
+            bits << (val || false)
+          else
+            unless bits.empty?
+              buf.write :bit, bits
+              bits = []
+            end
+            buf.write type, val
+          end
+        end
+
+        buf.write :bit, bits unless bits.empty?
+        buf.rewind
+
+        buf
+      end
+
+      def to_s
+        to_binary.to_s
+      end
+
+      def to_frame channel = 0
+        Transport::Method.new(self, channel)
+      end
+    end
+
+    class Header
+      def initialize *args
+        opts = args.pop if args.last.is_a? Hash
+        opts ||= {}
+
+        first = args.shift
+
+        if first.is_a? ::Class and first.ancestors.include? Protocol::Class
+          @klass = first
+          @size = args.shift || 0
+          @weight = args.shift || 0
+          @properties = opts
+
+        elsif first.is_a? Transport::Buffer or first.is_a? String
+          buf = first
+          buf = Transport::Buffer.new(buf) unless buf.is_a? Transport::Buffer
+
+          @klass = Protocol.classes[buf.read(:short)]
+          @weight = buf.read(:short)
+          @size = buf.read(:longlong)
+
+          props = buf.read(:properties, *klass.properties.map{|type,_| type })
+          @properties = Hash[*klass.properties.map{|_,name| name }.zip(props).reject{|k,v| v.nil? }.flatten]
+
+        else
+          raise ArgumentError, 'Invalid argument'
+        end
+
+      end
+      attr_accessor :klass, :size, :weight, :properties
+
+      def to_binary
+        buf = Transport::Buffer.new
+        buf.write :short, klass.id
+        buf.write :short, weight # XXX rabbitmq only supports weight == 0
+        buf.write :longlong, size
+        buf.write :properties, (klass.properties.map do |type, name|
+                                  [ type, properties[name] || properties[name.to_s] ]
+                                end)
+        buf.rewind
+        buf
+      end
+
+      def to_s
+        to_binary.to_s
+      end
+
+      def to_frame channel = 0
+        Transport::Header.new(self, channel)
+      end
+
+      def == header
+        [ :klass, :size, :weight, :properties ].inject(true) do |eql, field|
+          eql and __send__(field) == header.__send__(field)
+        end
+      end
+
+      def method_missing meth, *args, &blk
+        @properties.has_key?(meth) || @klass.properties.find{|_,name| name == meth } ? @properties[meth] : super
+      end
+    end
+
+    def self.parse buf
+      buf = Transport::Buffer.new(buf) unless buf.is_a? Transport::Buffer
+      class_id, method_id = buf.read(:short, :short)
+      classes[class_id].methods[method_id].new(buf)
+    end
+
+  end
 end