right_aws 1.10.0 → 2.0.0

data/lib/awsbase/right_awsbase.rb

@@ -23,7 +23,8 @@
 
 # Test
 module RightAws
-  require 'md5'
+#  require 'md5'
+  require 'digest/md5'
   require 'pp'
   
   class AwsUtils #:nodoc:
@@ -32,6 +33,13 @@ module RightAws
     if OpenSSL::OPENSSL_VERSION_NUMBER > 0x00908000
       @@digest256 = OpenSSL::Digest::Digest.new("sha256") rescue nil # Some installation may not support sha256
     end
+
+    def self.utc_iso8601(time)
+      if    time.is_a?(Fixnum) then time = Time::at(time)
+      elsif time.is_a?(String) then time = Time::parse(time)
+      end
+      time.utc.strftime("%Y-%m-%dT%H:%M:%S.000Z")
+    end
     
     def self.sign(aws_secret_access_key, auth_string)
       Base64.encode64(OpenSSL::HMAC.digest(@@digest1, aws_secret_access_key, auth_string)).strip
@@ -47,7 +55,7 @@ module RightAws
 
     # Set a timestamp and a signature version
     def self.fix_service_params(service_hash, signature)
-      service_hash["Timestamp"] ||= Time.now.utc.strftime("%Y-%m-%dT%H:%M:%S.000Z") unless service_hash["Expires"]
+      service_hash["Timestamp"] ||= utc_iso8601(Time.now) unless service_hash["Expires"]
       service_hash["SignatureVersion"] = signature
       service_hash
     end
@@ -123,6 +131,11 @@ module RightAws
       $1
     end
 
+    def self.split_items_and_params(array)
+      items  = Array(array).flatten.compact
+      params = items.last.kind_of?(Hash) ? items.pop : {}
+      [items, params]
+    end
   end
 
   class AwsBenchmarkingBlock #:nodoc:
@@ -145,15 +158,16 @@ module RightAws
     # Text, if found in an error message returned by AWS, indicates that this may be a transient
     # error. Transient errors are automatically retried with exponential back-off.
     AMAZON_PROBLEMS = [ 'internal service error', 
-                      'is currently unavailable', 
-                      'no response from', 
-                      'Please try again',
-                      'InternalError',
-                      'ServiceUnavailable', #from SQS docs
-                      'Unavailable',
-                      'This application is not currently available',
-                      'InsufficientInstanceCapacity'
-                    ]
+                        'is currently unavailable',
+                        'no response from',
+                        'Please try again',
+                        'InternalError',
+                        'Internal Server Error',
+                        'ServiceUnavailable', #from SQS docs
+                        'Unavailable',
+                        'This application is not currently available',
+                        'InsufficientInstanceCapacity'
+                      ]
     @@amazon_problems = AMAZON_PROBLEMS
       # Returns a list of Amazon service responses which are known to be transient problems. 
       # We have to re-request if we get any of them, because the problem will probably disappear. 
@@ -183,6 +197,8 @@ module RightAws
 
       # Current aws_access_key_id
     attr_reader :aws_access_key_id
+      # Current aws_secret_access_key
+    attr_reader :aws_secret_access_key
       # Last HTTP request object
     attr_reader :last_request
       # Last HTTP response object
@@ -204,6 +220,9 @@ module RightAws
 
     def init(service_info, aws_access_key_id, aws_secret_access_key, params={}) #:nodoc:
       @params = params
+      # If one defines EC2_URL he may forget to use a single slash as an "empty service" path.
+      # Amazon does not like this therefore add this bad boy if he is missing...
+      service_info[:default_service] = '/' if service_info[:default_service].blank?
       raise AwsError.new("AWS access keys are required to operate on #{service_info[:name]}") \
         if aws_access_key_id.blank? || aws_secret_access_key.blank?
       @aws_access_key_id     = aws_access_key_id
@@ -213,6 +232,8 @@ module RightAws
         @params[:server]   = URI.parse(@params[:endpoint_url]).host
         @params[:port]     = URI.parse(@params[:endpoint_url]).port
         @params[:service]  = URI.parse(@params[:endpoint_url]).path
+        # make sure the 'service' path is not empty
+        @params[:service]  = service_info[:default_service] if @params[:service].blank?
         @params[:protocol] = URI.parse(@params[:endpoint_url]).scheme
         @params[:region]   = nil
       else
@@ -222,11 +243,15 @@ module RightAws
         @params[:service]  ||= service_info[:default_service]
         @params[:protocol] ||= service_info[:default_protocol]
       end
-      @params[:multi_thread] ||= defined?(AWS_DAEMON)
+#      @params[:multi_thread] ||= defined?(AWS_DAEMON)
+      @params[:connections] ||= :shared # || :dedicated
+      @params[:max_connections] ||= 10
+      @params[:connection_lifetime] ||= 20*60
+      @params[:api_version]  ||= service_info[:default_api_version]
       @logger = @params[:logger]
       @logger = RAILS_DEFAULT_LOGGER if !@logger && defined?(RAILS_DEFAULT_LOGGER)
       @logger = Logger.new(STDOUT)   if !@logger
-      @logger.info "New #{self.class.name} using #{@params[:multi_thread] ? 'multi' : 'single'}-threaded mode"
+      @logger.info "New #{self.class.name} using #{@params[:connections]} connections mode"
       @error_handler = nil
       @cache = {}
       @signature_version = (params[:signature_version] || DEFAULT_SIGNATURE_VERSION).to_s
@@ -256,7 +281,8 @@ module RightAws
       if caching?
         function = function.to_sym
         # get rid of requestId (this bad boy was added for API 2008-08-08+ and it is uniq for every response)
-        response = response.sub(%r{<requestId>.+?</requestId>}, '')
+        # feb 04, 2009 (load balancer uses 'RequestId' hence use 'i' modifier to hit it also)
+        response = response.sub(%r{<requestId>.+?</requestId>}i, '')
         response_md5 = MD5.md5(response).to_s
         # check for changes
         unless @cache[function] && @cache[function][:response_md5] == response_md5
@@ -289,16 +315,85 @@ module RightAws
       AwsError::on_aws_exception(self, options)
     end
     
-      # Return +true+ if this instance works in multi_thread mode and +false+ otherwise.
-    def multi_thread
-      @params[:multi_thread]
+#      # Return +true+ if this instance works in multi_thread mode and +false+ otherwise.
+#    def multi_thread
+#      @params[:multi_thread]
+#    end
+
+    # ACF, AMS, EC2, LBS and SDB uses this guy
+    # SQS and S3 use their own methods
+    def generate_request_impl(verb, action, options={}) #:nodoc:
+      # Form a valid http verb: 'GET' or 'POST' (all the other are not supported now)
+      http_verb = verb.to_s.upcase
+      # remove empty keys from request options
+      options.delete_if { |key, value| value.nil? }
+      # prepare service data
+      service_hash = {"Action"         => action,
+                      "AWSAccessKeyId" => @aws_access_key_id,
+                      "Version"        => @params[:api_version] }
+      service_hash.merge!(options)
+      # Sign request options
+      service_params = signed_service_params(@aws_secret_access_key, service_hash, http_verb, @params[:server], @params[:service])
+      # Use POST if the length of the query string is too large
+      # see http://docs.amazonwebservices.com/AmazonSimpleDB/2007-11-07/DeveloperGuide/MakingRESTRequests.html
+      if http_verb != 'POST' && service_params.size > 2000
+        http_verb = 'POST'
+        if signature_version == '2'
+          service_params = signed_service_params(@aws_secret_access_key, service_hash, http_verb, @params[:server], @params[:service])
+        end
+      end
+      # create a request
+      case http_verb
+      when 'GET'
+        request = Net::HTTP::Get.new("#{@params[:service]}?#{service_params}")
+      when 'POST'
+        request      = Net::HTTP::Post.new(@params[:service])
+        request.body = service_params
+        request['Content-Type'] = 'application/x-www-form-urlencoded; charset=utf-8'
+      else
+        raise "Unsupported HTTP verb #{verb.inspect}!"
+      end
+      # prepare output hash
+      { :request  => request,
+        :server   => @params[:server],
+        :port     => @params[:port],
+        :protocol => @params[:protocol] }
+    end
+
+    def get_connection(aws_service, request) #:nodoc
+      server_url = "#{request[:protocol]}://#{request[:server]}:#{request[:port]}}"
+      #
+      case @params[:connections].to_s
+      when 'dedicated'
+        @connections_storage ||= {}
+      else # 'dedicated'
+        @connections_storage = (Thread.current[aws_service] ||= {})
+      end
+      #
+      @connections_storage[server_url] ||= {}
+      @connections_storage[server_url][:last_used_at] = Time.now
+      @connections_storage[server_url][:connection] ||= Rightscale::HttpConnection.new(:exception => RightAws::AwsError, :logger => @logger)
+      # keep X most recent connections (but were used not far than Y minutes ago)
+      connections = 0
+      @connections_storage.to_a.sort{|i1, i2| i2[1][:last_used_at] <=> i1[1][:last_used_at]}.to_a.each do |i|
+        if i[0] != server_url && (@params[:max_connections] <= connections  || i[1][:last_used_at] < Time.now - @params[:connection_lifetime])
+          # delete the connection from the list
+          @connections_storage.delete(i[0])
+          # then finish it
+          i[1][:connection].finish((@params[:max_connections] <= connections) ? "out-of-limit" : "out-of-date") rescue nil
+        else
+          connections += 1
+        end
+      end
+      @connections_storage[server_url][:connection]
     end
 
-    def request_info_impl(connection, benchblock, request, parser, &block) #:nodoc:
-      @connection    = connection
+    # All services uses this guy.
+    def request_info_impl(aws_service, benchblock, request, parser, &block) #:nodoc:
+      @connection    = get_connection(aws_service, request)
       @last_request  = request[:request]
       @last_response = nil
-      response=nil
+      response = nil
       blockexception = nil
 
       if(block != nil)
@@ -382,7 +477,73 @@ module RightAws
 
     # Returns Amazons request ID for the latest request
     def last_request_id
-      @last_response && @last_response.body.to_s[%r{<requestId>(.+?)</requestId>}] && $1
+      @last_response && @last_response.body.to_s[%r{<requestId>(.+?)</requestId>}i] && $1
+    end
+
+    # Format array of items into Amazons handy hash ('?' is a place holder):
+    #
+    #  amazonize_list('Item', ['a', 'b', 'c']) =>
+    #    { 'Item.1' => 'a', 'Item.2' => 'b', 'Item.3' => 'c' }
+    #
+    #  amazonize_list('Item.?.instance', ['a', 'c']) #=>
+    #    { 'Item.1.instance' => 'a', 'Item.2.instance' => 'c' }
+    #
+    #  amazonize_list(['Item.?.Name', 'Item.?.Value'], {'A' => 'a', 'B' => 'b'}) #=>
+    #    { 'Item.1.Name' => 'A', 'Item.1.Value' => 'a',
+    #      'Item.2.Name' => 'B', 'Item.2.Value' => 'b'  }
+    #
+    #  amazonize_list(['Item.?.Name', 'Item.?.Value'], [['A','a'], ['B','b']]) #=>
+    #    { 'Item.1.Name' => 'A', 'Item.1.Value' => 'a',
+    #      'Item.2.Name' => 'B', 'Item.2.Value' => 'b'  }
+    #
+    #  amazonize_list(['Filter.?.Key', 'Filter.?.Value.?'], {'A' => ['aa','ab'], 'B' => ['ba','bb']}) #=>
+    #  amazonize_list(['Filter.?.Key', 'Filter.?.Value.?'], [['A',['aa','ab']], ['B',['ba','bb']]])   #=>
+    #    {"Filter.1.Key"=>"A",
+    #     "Filter.1.Value.1"=>"aa",
+    #     "Filter.1.Value.2"=>"ab",
+    #     "Filter.2.Key"=>"B",
+    #     "Filter.2.Value.1"=>"ba",
+    #     "Filter.2.Value.2"=>"bb"}
+    def amazonize_list(masks, list) #:nodoc:
+      groups = {}
+      Array(list).each_with_index do |list_item, i|
+        Array(masks).each_with_index do |mask, mask_idx|
+          key = mask[/\?/] ? mask.dup : mask.dup + '.?'
+          key.sub!('?', (i+1).to_s)
+          value = Array(list_item)[mask_idx]
+          if value.is_a?(Array)
+            groups.merge!(amazonize_list(key, value))
+          else
+            groups[key] = value
+          end
+        end
+      end
+      groups
+    end
+
+    BLOCK_DEVICE_KEY_MAPPING = {                                                           # :nodoc:
+      :device_name               => 'DeviceName',
+      :virtual_name              => 'VirtualName',
+      :no_device                 => 'NoDevice',
+      :ebs_snapshot_id           => 'Ebs.SnapshotId',
+      :ebs_volume_size           => 'Ebs.VolumeSize',
+      :ebs_delete_on_termination => 'Ebs.DeleteOnTermination' }
+
+    def amazonize_block_device_mappings(block_device_mappings, key = 'BlockDeviceMapping') # :nodoc:
+      result = {}
+      unless block_device_mappings.blank?
+        block_device_mappings = [block_device_mappings] unless block_device_mappings.is_a?(Array)
+        block_device_mappings.each_with_index do |b, idx|
+          BLOCK_DEVICE_KEY_MAPPING.each do |local_name, remote_name|
+            value = b[local_name]
+            case local_name
+            when :no_device then value = value ? '' : nil   # allow to pass :no_device as boolean
+            end
+            result["#{key}.#{idx+1}.#{remote_name}"] = value unless value.nil?
+          end
+        end
+      end
+      result
     end
 
   end
@@ -518,7 +679,7 @@ module RightAws
       last_errors_text = ''
       response         = @aws.last_response
       # log error
-      request_text_data = "#{request[:server]}:#{request[:port]}#{request[:request].path}"
+      request_text_data = "#{request[:protocol]}://#{request[:server]}:#{request[:port]}#{request[:request].path}"
       # is this a redirect?
       # yes!
       if response.is_a?(Net::HTTPRedirection)
@@ -528,33 +689,36 @@ module RightAws
         @aws.logger.warn("##### #{@aws.class.name} returned an error: #{response.code} #{response.message}\n#{response.body} #####")
         @aws.logger.warn("##### #{@aws.class.name} request: #{request_text_data} ####")
       end
-        # Check response body: if it is an Amazon XML document or not:
-      if redirect_detected || (response.body && response.body[/<\?xml/])   # ... it is a xml document
+
+      # Extract error/redirection message from the response body
+      # Amazon claims that a redirection must have a body but somethimes it is nil....
+      if response.body && response.body[/^(<\?xml|<ErrorResponse)/]
+        error_parser = RightErrorResponseParser.new
         @aws.class.bench_xml.add! do
-          error_parser = RightErrorResponseParser.new
-          error_parser.parse(response)
-          @aws.last_errors     = error_parser.errors
-          @aws.last_request_id = error_parser.requestID
-          last_errors_text     = @aws.last_errors.flatten.join("\n")
-          # on redirect :
-          if redirect_detected
-            location = response['location']
-            # ... log information and ...
-            @aws.logger.info("##### #{@aws.class.name} redirect requested: #{response.code} #{response.message} #####")
-            @aws.logger.info("##### New location: #{location} #####")
-            # ... fix the connection data
-            request[:server]   = URI.parse(location).host
-            request[:protocol] = URI.parse(location).scheme
-            request[:port]     = URI.parse(location).port
-          end
+          error_parser.parse(response.body)
         end
-      else                               # ... it is not a xml document(probably just a html page?)
+        @aws.last_errors     = error_parser.errors
+        @aws.last_request_id = error_parser.requestID
+        last_errors_text     = @aws.last_errors.flatten.join("\n")
+      else
         @aws.last_errors     = [[response.code, "#{response.message} (#{request_text_data})"]]
         @aws.last_request_id = '-undefined-'
         last_errors_text     = response.message
       end
-        # now - check the error
-      unless redirect_detected
+      
+      # Ok, it is a redirect, find the new destination location
+      if redirect_detected
+        location = response['location']
+        # ... log information and ...
+        @aws.logger.info("##### #{@aws.class.name} redirect requested: #{response.code} #{response.message} #####")
+        @aws.logger.info("      Old location: #{request_text_data}")
+        @aws.logger.info("      New location: #{location}")
+        # ... fix the connection data
+        request[:server]   = URI.parse(location).host
+        request[:protocol] = URI.parse(location).scheme
+        request[:port]     = URI.parse(location).port
+      else
+        # Not a redirect but an error: try to find the error in our list
         @errors_list.each do |error_to_find|
           if last_errors_text[/#{error_to_find}/i]
             error_found = true
@@ -564,6 +728,7 @@ module RightAws
           end
         end
       end
+      
         # check the time has gone from the first error come
       if redirect_detected || error_found
         # Close the connection to the server and recreate a new one. 
@@ -627,7 +792,7 @@ module RightAws
       @right_aws_parser.tag_start(name, attr_hash) 
     end   
     def on_characters(chars) 
-      @right_aws_parser.text(chars) 
+      @right_aws_parser.text(chars)
     end 
     def on_end_element(name) 
       @right_aws_parser.tag_end(name) 
@@ -656,25 +821,30 @@ module RightAws
     attr_accessor :result
     attr_reader   :xmlpath
     attr_accessor :xml_lib
+    attr_reader   :full_tag_name
+    attr_reader   :tag
     
     def initialize(params={})
       @xmlpath = ''
+      @full_tag_name = ''
       @result  = false
       @text    = ''
+      @tag     = ''
       @xml_lib = params[:xml_lib] || @@xml_lib
       @logger  = params[:logger]
       reset
     end
     def tag_start(name, attributes)
       @text = ''
+      @tag  = name
+      @full_tag_name += @full_tag_name.empty? ? name : "/#{name}"
       tagstart(name, attributes)
-      @xmlpath += @xmlpath.empty? ? name : "/#{name}"
+      @xmlpath = @full_tag_name
     end
     def tag_end(name)
-      if @xmlpath =~ /^(.*?)\/?#{name}$/
-        @xmlpath = $1
-      end
+      @xmlpath = @full_tag_name[/^(.*?)\/?#{name}$/] && $1
       tagend(name)
+      @full_tag_name = @xmlpath
     end
     def text(text)
       @text += text
@@ -711,14 +881,19 @@ module RightAws
         # Parse the xml text
       case @xml_lib
       when 'libxml'  
-        xml        = XML::SaxParser.new 
-        xml.string = xml_text 
+        if XML::Parser::VERSION >= '0.9.9'
+          # avoid warning on every usage
+          xml        = XML::SaxParser.string(xml_text)
+        else
+          xml        = XML::SaxParser.new 
+          xml.string = xml_text 
+        end
         # check libxml-ruby version 
         if XML::Parser::VERSION >= '0.5.1.0'
           xml.callbacks = RightSaxParserCallback.new(self) 
         else 
           xml.on_start_element{|name, attr_hash| self.tag_start(name, attr_hash)} 
-          xml.on_characters{   |text|            self.text(text)} 
+          xml.on_characters{   |text|            self.text(text)}
           xml.on_end_element{  |name|            self.tag_end(name)} 
         end 
         xml.parse
@@ -793,5 +968,11 @@ module RightAws
     end
   end
 
+  class RightBoolResponseParser < RightAWSParser #:nodoc:
+    def tagend(name)
+      @result = (@text=='true') if name == 'return'
+    end
+  end
+
 end
 

data/lib/awsbase/support.rb

@@ -47,6 +47,10 @@ unless defined? ActiveSupport::CoreExtensions
       Object.module_eval("::#{$1}", __FILE__, __LINE__)
     end
 
+    def camelize()
+      self.dup.split(/_/).map{ |word| word.capitalize }.join('')
+    end
+
   end
 
 

data/lib/ec2/right_ec2.rb

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2007-2008 RightScale Inc
+# Copyright (c) 2007-2009 RightScale Inc
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -68,7 +68,7 @@ module RightAws
     include RightAwsBaseInterface
     
     # Amazon EC2 API version being used
-    API_VERSION       = "2008-12-01"
+    API_VERSION       = "2009-11-30"
     DEFAULT_HOST      = "ec2.amazonaws.com"
     DEFAULT_PATH      = '/'
     DEFAULT_PROTOCOL  = 'https'
@@ -81,7 +81,7 @@ module RightAws
     # Amazon EC2 Instance Types : http://www.amazon.com/b?ie=UTF8&node=370375011
     # Default EC2 instance type (platform) 
     DEFAULT_INSTANCE_TYPE   =  'm1.small' 
-    INSTANCE_TYPES          = ['m1.small','c1.medium','m1.large','m1.xlarge','c1.xlarge']
+    INSTANCE_TYPES          = ['m1.small','c1.medium','m1.large','m1.xlarge','c1.xlarge', 'm2.xlarge', 'm2.2xlarge', 'm2.4xlarge']
     
     @@bench = AwsBenchmarkingBlock.new
     def self.bench_xml
@@ -107,753 +107,36 @@ module RightAws
     # * <tt>:protocol</tt>: 'http' or 'https', default: DEFAULT_PROTOCOL
     # * <tt>:multi_thread</tt>: true=HTTP connection per thread, false=per process
     # * <tt>:logger</tt>: for log messages, default: RAILS_DEFAULT_LOGGER else STDOUT
-    # * <tt>:signature_version</tt>:  The signature version : '0' or '1'(default)
+    # * <tt>:signature_version</tt>:  The signature version : '0','1' or '2'(default)
     # * <tt>:cache</tt>: true/false: caching for: ec2_describe_images, describe_instances,
     # describe_images_by_owner, describe_images_by_executable_by, describe_availability_zones,
     # describe_security_groups, describe_key_pairs, describe_addresses, 
     # describe_volumes, describe_snapshots methods, default: false.
     #
     def initialize(aws_access_key_id=nil, aws_secret_access_key=nil, params={})
-      init({ :name             => 'EC2', 
-             :default_host     => ENV['EC2_URL'] ? URI.parse(ENV['EC2_URL']).host   : DEFAULT_HOST, 
-             :default_port     => ENV['EC2_URL'] ? URI.parse(ENV['EC2_URL']).port   : DEFAULT_PORT,
-             :default_service  => ENV['EC2_URL'] ? URI.parse(ENV['EC2_URL']).path   : DEFAULT_PATH,             
-             :default_protocol => ENV['EC2_URL'] ? URI.parse(ENV['EC2_URL']).scheme : DEFAULT_PROTOCOL }, 
+      init({ :name                => 'EC2',
+             :default_host        => ENV['EC2_URL'] ? URI.parse(ENV['EC2_URL']).host   : DEFAULT_HOST,
+             :default_port        => ENV['EC2_URL'] ? URI.parse(ENV['EC2_URL']).port   : DEFAULT_PORT,
+             :default_service     => ENV['EC2_URL'] ? URI.parse(ENV['EC2_URL']).path   : DEFAULT_PATH,
+             :default_protocol    => ENV['EC2_URL'] ? URI.parse(ENV['EC2_URL']).scheme : DEFAULT_PROTOCOL,
+             :default_api_version => @@api },
            aws_access_key_id    || ENV['AWS_ACCESS_KEY_ID'] , 
            aws_secret_access_key|| ENV['AWS_SECRET_ACCESS_KEY'],
            params)
-      # EC2 doesn't really define any transient errors to retry, and in fact,
-      # when they return a 503 it is usually for 'request limit exceeded' which
-      # we most certainly should not retry.  So let's pare down the list of
-      # retryable errors to InternalError only (see RightAwsBase for the default
-      # list)
-      amazon_problems = ['InternalError']
+      # Eucalyptus supports some yummy features but Amazon does not
+      if @params[:eucalyptus]
+        @params[:port_based_group_ingress] = true unless @params.has_key?(:port_based_group_ingress)
+      end
     end
 
-
     def generate_request(action, params={}) #:nodoc:
-      service_hash = {"Action"         => action,
-                      "AWSAccessKeyId" => @aws_access_key_id,
-                      "Version"        => @@api }
-      service_hash.update(params)
-      service_params = signed_service_params(@aws_secret_access_key, service_hash, :get, @params[:server], @params[:service])
-      
-      # use POST method if the length of the query string is too large
-      if service_params.size > 2000
-        if signature_version == '2'
-          # resign the request because HTTP verb is included into signature
-          service_params = signed_service_params(@aws_secret_access_key, service_hash, :post, @params[:server], @params[:service])
-        end
-        request      = Net::HTTP::Post.new(service)
-        request.body = service_params
-        request['Content-Type'] = 'application/x-www-form-urlencoded'
-      else
-        request        = Net::HTTP::Get.new("#{@params[:service]}?#{service_params}")
-      end
-        # prepare output hash
-      { :request  => request, 
-        :server   => @params[:server],
-        :port     => @params[:port],
-        :protocol => @params[:protocol] }
+      generate_request_impl(:get, action, params )
     end
 
       # Sends request to Amazon and parses the response
       # Raises AwsError if any banana happened
     def request_info(request, parser)  #:nodoc:
-      thread = @params[:multi_thread] ? Thread.current : Thread.main
-      thread[:ec2_connection] ||= Rightscale::HttpConnection.new(:exception => AwsError, :logger => @logger)
-      request_info_impl(thread[:ec2_connection], @@bench, request, parser)
-    end
-
-    def hash_params(prefix, list) #:nodoc:
-      groups = {}
-      list.each_index{|i| groups.update("#{prefix}.#{i+1}"=>list[i])} if list
-      return groups
-    end
-
-  #-----------------------------------------------------------------
-  #      Images
-  #-----------------------------------------------------------------
-
-    # params: 
-    #   { 'ImageId'      => ['id1', ..., 'idN'],
-    #     'Owner'        => ['self', ..., 'userN'],
-    #     'ExecutableBy' => ['self', 'all', ..., 'userN']
-    #   } 
-    def ec2_describe_images(params={}, image_type=nil, cache_for=nil) #:nodoc:
-      request_hash = {}
-      params.each do |list_by, list|
-        request_hash.merge! hash_params(list_by, list.to_a)
-      end
-      request_hash['ImageType'] = image_type if image_type
-      link = generate_request("DescribeImages", request_hash)
-      request_cache_or_info cache_for, link,  QEc2DescribeImagesParser, @@bench, cache_for
-    rescue Exception
-      on_exception
-    end
-
-      # Retrieve a list of images. Returns array of hashes describing the images or an exception:
-      # +image_type+ = 'machine' || 'kernel' || 'ramdisk' 
-      # 
-      #  ec2.describe_images #=>
-      #    [{:aws_owner => "522821470517",
-      #      :aws_id => "ami-e4b6538d",
-      #      :aws_state => "available",
-      #      :aws_location => "marcins_cool_public_images/ubuntu-6.10.manifest.xml",
-      #      :aws_is_public => true,
-      #      :aws_architecture => "i386",
-      #      :aws_image_type => "machine"},
-      #     {...},
-      #     {...} ]
-      #
-      # If +list+ param is set, then retrieve information about the listed images only:
-      #
-      #  ec2.describe_images(['ami-e4b6538d']) #=>
-      #    [{:aws_owner => "522821470517",
-      #      :aws_id => "ami-e4b6538d",
-      #      :aws_state => "available",
-      #      :aws_location => "marcins_cool_public_images/ubuntu-6.10.manifest.xml",
-      #      :aws_is_public => true,
-      #      :aws_architecture => "i386",
-      #      :aws_image_type => "machine"}]
-      #
-    def describe_images(list=[], image_type=nil)
-      list = list.to_a
-      cache_for = list.empty? && !image_type ? :describe_images : nil
-      ec2_describe_images({ 'ImageId' => list }, image_type, cache_for)
-    end
-
-      #
-      #  Example:
-      #
-      #   ec2.describe_images_by_owner('522821470517')
-      #   ec2.describe_images_by_owner('self')
-      #
-    def describe_images_by_owner(list=['self'], image_type=nil)
-      list = list.to_a
-      cache_for = list==['self'] && !image_type ? :describe_images_by_owner : nil
-      ec2_describe_images({ 'Owner' => list }, image_type, cache_for)
-    end
-
-      #
-      #  Example:
-      #
-      #   ec2.describe_images_by_executable_by('522821470517')
-      #   ec2.describe_images_by_executable_by('self')
-      #   ec2.describe_images_by_executable_by('all')
-      #
-    def describe_images_by_executable_by(list=['self'], image_type=nil)
-      list = list.to_a
-      cache_for = list==['self'] && !image_type ? :describe_images_by_executable_by : nil
-      ec2_describe_images({ 'ExecutableBy' => list }, image_type, cache_for)
-    end
-
-
-      # Register new image at Amazon. 
-      # Returns new image id or an exception.
-      #
-      #  ec2.register_image('bucket/key/manifest') #=> 'ami-e444444d'
-      #
-    def register_image(image_location)
-      link = generate_request("RegisterImage", 
-                              'ImageLocation' => image_location.to_s)
-      request_info(link, QEc2RegisterImageParser.new(:logger => @logger))
-    rescue Exception
-      on_exception
-    end
-    
-      # Deregister image at Amazon. Returns +true+ or an exception.
-      #
-      #  ec2.deregister_image('ami-e444444d') #=> true
-      #
-    def deregister_image(image_id)
-      link = generate_request("DeregisterImage", 
-                              'ImageId' => image_id.to_s)
-      request_info(link, RightBoolResponseParser.new(:logger => @logger))
-    rescue Exception
-      on_exception
-    end
-
-
-      # Describe image attributes. Currently 'launchPermission', 'productCodes', 'kernel', 'ramdisk' and 'blockDeviceMapping'  are supported.
-      #
-      #  ec2.describe_image_attribute('ami-e444444d') #=> {:groups=>["all"], :users=>["000000000777"]}
-      #
-    def describe_image_attribute(image_id, attribute='launchPermission')
-      link = generate_request("DescribeImageAttribute", 
-                              'ImageId'   => image_id,
-                              'Attribute' => attribute)
-      request_info(link, QEc2DescribeImageAttributeParser.new(:logger => @logger))
-    rescue Exception
-      on_exception
-    end
-    
-      # Reset image attribute. Currently, only 'launchPermission' is supported. Returns +true+ or an exception.
-      #
-      #  ec2.reset_image_attribute('ami-e444444d') #=> true
-      #
-    def reset_image_attribute(image_id, attribute='launchPermission')
-      link = generate_request("ResetImageAttribute", 
-                              'ImageId'   => image_id,
-                              'Attribute' => attribute)
-      request_info(link, RightBoolResponseParser.new(:logger => @logger))
-    rescue Exception
-      on_exception
-    end
-
-      # Modify an image's attributes. It is recommended that you use
-      # modify_image_launch_perm_add_users, modify_image_launch_perm_remove_users, etc.
-      # instead of modify_image_attribute because the signature of 
-      # modify_image_attribute may change with EC2 service changes.
-      #
-      #  attribute      : currently, only 'launchPermission' is supported.
-      #  operation_type : currently, only 'add' & 'remove' are supported.
-      #  vars: 
-      #    :user_group  : currently, only 'all' is supported.  
-      #    :user_id
-      #    :product_code
-    def modify_image_attribute(image_id, attribute, operation_type = nil, vars = {})
-      params =  {'ImageId'   => image_id,
-                 'Attribute' => attribute}
-      params['OperationType'] = operation_type if operation_type
-      params.update(hash_params('UserId',      vars[:user_id].to_a))    if vars[:user_id]
-      params.update(hash_params('UserGroup',   vars[:user_group].to_a)) if vars[:user_group]
-      params.update(hash_params('ProductCode', vars[:product_code]))    if vars[:product_code]
-      link = generate_request("ModifyImageAttribute", params)
-      request_info(link, RightBoolResponseParser.new(:logger => @logger))
-    rescue Exception
-      on_exception
-    end
-
-      # Grant image launch permissions to users.
-      # Parameter +userId+ is a list of user AWS account ids.
-      # Returns +true+ or an exception.
-      #
-      #  ec2.modify_image_launch_perm_add_users('ami-e444444d',['000000000777','000000000778']) #=> true
-    def modify_image_launch_perm_add_users(image_id, user_id=[])
-      modify_image_attribute(image_id, 'launchPermission', 'add', :user_id => user_id.to_a)
-    end
-
-      # Revokes image launch permissions for users. +userId+ is a list of users AWS accounts ids. Returns +true+ or an exception.
-      #
-      #  ec2.modify_image_launch_perm_remove_users('ami-e444444d',['000000000777','000000000778']) #=> true
-      #
-    def modify_image_launch_perm_remove_users(image_id, user_id=[])
-      modify_image_attribute(image_id, 'launchPermission', 'remove', :user_id => user_id.to_a)
-    end
-
-      # Add image launch permissions for users groups (currently only 'all' is supported, which gives public launch permissions). 
-      # Returns +true+ or an exception.
-      #
-      #  ec2.modify_image_launch_perm_add_groups('ami-e444444d') #=> true
-      #
-    def modify_image_launch_perm_add_groups(image_id, user_group=['all'])
-      modify_image_attribute(image_id, 'launchPermission', 'add', :user_group => user_group.to_a)
-    end
-    
-      # Remove image launch permissions for users groups (currently only 'all' is supported, which gives public launch permissions). 
-      #
-      #  ec2.modify_image_launch_perm_remove_groups('ami-e444444d') #=> true
-      #
-    def modify_image_launch_perm_remove_groups(image_id, user_group=['all'])
-      modify_image_attribute(image_id, 'launchPermission', 'remove', :user_group => user_group.to_a)
-    end
-    
-      # Add product code to image
-      #
-      #  ec2.modify_image_product_code('ami-e444444d','0ABCDEF') #=> true
-      #
-    def modify_image_product_code(image_id, product_code=[])
-      modify_image_attribute(image_id, 'productCodes', nil, :product_code => product_code.to_a)
-    end
-
-  #-----------------------------------------------------------------
-  #      Instances
-  #-----------------------------------------------------------------
-    
-    def get_desc_instances(instances)  # :nodoc:
-      result = []
-      instances.each do |reservation|
-        reservation[:instances_set].each do |instance|
-          # Parse and remove timestamp from the reason string. The timestamp is of
-          # the request, not when EC2 took action, thus confusing & useless...
-          instance[:aws_reason]         = instance[:aws_reason].sub(/\(\d[^)]*GMT\) */, '')
-          instance[:aws_owner]          = reservation[:aws_owner]
-          instance[:aws_reservation_id] = reservation[:aws_reservation_id]
-          instance[:aws_groups]         = reservation[:aws_groups]
-          result << instance
-        end
-      end
-      result
-    rescue Exception
-      on_exception
-    end
-    
-      # Retrieve information about EC2 instances. If +list+ is omitted then returns the
-      # list of all instances.
-      #
-      #  ec2.describe_instances #=> 
-      #    [{:aws_image_id       => "ami-e444444d",
-      #      :aws_reason         => "",
-      #      :aws_state_code     => "16",
-      #      :aws_owner          => "000000000888",
-      #      :aws_instance_id    => "i-123f1234",
-      #      :aws_reservation_id => "r-aabbccdd",
-      #      :aws_state          => "running",
-      #      :dns_name           => "domU-12-34-67-89-01-C9.usma2.compute.amazonaws.com",
-      #      :ssh_key_name       => "staging",
-      #      :aws_groups         => ["default"],
-      #      :private_dns_name   => "domU-12-34-67-89-01-C9.usma2.compute.amazonaws.com",
-      #      :aws_instance_type  => "m1.small",
-      #      :aws_launch_time    => "2008-1-1T00:00:00.000Z"},
-      #      :aws_availability_zone => "us-east-1b",
-      #      :aws_kernel_id      => "aki-ba3adfd3",
-      #      :aws_ramdisk_id     => "ari-badbad00",
-      #       ..., {...}]
-      #
-    def describe_instances(list=[])
-      link = generate_request("DescribeInstances", hash_params('InstanceId',list.to_a))
-      request_cache_or_info(:describe_instances, link,  QEc2DescribeInstancesParser, @@bench, list.blank?) do |parser|
-        get_desc_instances(parser.result)
-      end
-    rescue Exception
-      on_exception
-    end
-    
-      # Return the product code attached to instance or +nil+ otherwise.
-      #
-      #  ec2.confirm_product_instance('ami-e444444d','12345678') #=> nil
-      #  ec2.confirm_product_instance('ami-e444444d','00001111') #=> "000000000888"
-      #
-    def confirm_product_instance(instance, product_code)
-      link = generate_request("ConfirmProductInstance", { 'ProductCode' => product_code,
-                                'InstanceId'  => instance })
-      request_info(link, QEc2ConfirmProductInstanceParser.new(:logger => @logger))
-    end
-    
-      # Launch new EC2 instances. Returns a list of launched instances or an exception.
-      #
-      #  ec2.run_instances('ami-e444444d',1,1,['my_awesome_group'],'my_awesome_key', 'Woohoo!!!', 'public') #=>
-      #   [{:aws_image_id       => "ami-e444444d",
-      #     :aws_reason         => "",
-      #     :aws_state_code     => "0",
-      #     :aws_owner          => "000000000888",
-      #     :aws_instance_id    => "i-123f1234",
-      #     :aws_reservation_id => "r-aabbccdd",
-      #     :aws_state          => "pending",
-      #     :dns_name           => "",
-      #     :ssh_key_name       => "my_awesome_key",
-      #     :aws_groups         => ["my_awesome_group"],
-      #     :private_dns_name   => "",
-      #     :aws_instance_type  => "m1.small",
-      #     :aws_launch_time    => "2008-1-1T00:00:00.000Z"
-      #     :aws_ramdisk_id     => "ari-8605e0ef"
-      #     :aws_kernel_id      => "aki-9905e0f0",
-      #     :ami_launch_index   => "0",
-      #     :aws_availability_zone => "us-east-1b"
-      #     }]
-      #
-    def run_instances(image_id, min_count, max_count, group_ids, key_name, user_data='',  
-                      addressing_type = nil, instance_type = nil,
-                      kernel_id = nil, ramdisk_id = nil, availability_zone = nil, 
-                      block_device_mappings = nil) 
- 	    launch_instances(image_id, { :min_count       => min_count, 
- 	                                 :max_count       => max_count, 
- 	                                 :user_data       => user_data, 
-                                   :group_ids       => group_ids, 
-                                   :key_name        => key_name, 
-                                   :instance_type   => instance_type, 
-                                   :addressing_type => addressing_type,
-                                   :kernel_id       => kernel_id,
-                                   :ramdisk_id      => ramdisk_id,
-                                   :availability_zone     => availability_zone,
-                                   :block_device_mappings => block_device_mappings
-                                 }) 
-    end
-    
-     
-      # Launch new EC2 instances. Returns a list of launched instances or an exception. 
-      #
-      # +lparams+ keys (default values in parenthesis):
-      #  :min_count              fixnum, (1)
-      #  :max_count              fixnum, (1)
-      #  :group_ids              array or string ([] == 'default')
-      #  :instance_type          string (DEFAULT_INSTACE_TYPE)
-      #  :addressing_type        string (DEFAULT_ADDRESSING_TYPE 
-      #  :key_name               string
-      #  :kernel_id              string
-      #  :ramdisk_id             string 
-      #  :availability_zone      string
-      #  :block_device_mappings  string
-      #  :user_data              string
-      # 
-      #  ec2.launch_instances('ami-e444444d', :group_ids => 'my_awesome_group', 
-      #                                       :user_data => "Woohoo!!!", 
-      #                                       :addressing_type => "public", 
-      #                                       :key_name => "my_awesome_key", 
-      #                                       :availability_zone => "us-east-1c") #=> 
-      #   [{:aws_image_id       => "ami-e444444d", 
-      #     :aws_reason         => "", 
-      #     :aws_state_code     => "0", 
-      #     :aws_owner          => "000000000888", 
-      #     :aws_instance_id    => "i-123f1234", 
-      #     :aws_reservation_id => "r-aabbccdd", 
-      #     :aws_state          => "pending", 
-      #     :dns_name           => "", 
-      #     :ssh_key_name       => "my_awesome_key", 
-      #     :aws_groups         => ["my_awesome_group"], 
-      #     :private_dns_name   => "", 
-      #     :aws_instance_type  => "m1.small",
-      #     :aws_launch_time    => "2008-1-1T00:00:00.000Z",
-      #     :aws_ramdisk_id     => "ari-8605e0ef"
-      #     :aws_kernel_id      => "aki-9905e0f0",
-      #     :ami_launch_index   => "0",
-      #     :aws_availability_zone => "us-east-1c"
-      #     }] 
-      #     
-    def launch_instances(image_id, lparams={}) 
-      @logger.info("Launching instance of image #{image_id} for #{@aws_access_key_id}, " + 
-                   "key: #{lparams[:key_name]}, groups: #{(lparams[:group_ids]).to_a.join(',')}")
-      # careful: keyName and securityGroups may be nil
-      params = hash_params('SecurityGroup', lparams[:group_ids].to_a)
-      params.update( {'ImageId'        => image_id,
-                      'MinCount'       => (lparams[:min_count] || 1).to_s, 
-                      'MaxCount'       => (lparams[:max_count] || 1).to_s, 
-                      'AddressingType' => lparams[:addressing_type] || DEFAULT_ADDRESSING_TYPE, 
-                      'InstanceType'   => lparams[:instance_type]   || DEFAULT_INSTANCE_TYPE })
-      # optional params
-      params['KeyName']                    = lparams[:key_name]              unless lparams[:key_name].blank? 
-      params['KernelId']                   = lparams[:kernel_id]             unless lparams[:kernel_id].blank? 
-      params['RamdiskId']                  = lparams[:ramdisk_id]            unless lparams[:ramdisk_id].blank? 
-      params['Placement.AvailabilityZone'] = lparams[:availability_zone]     unless lparams[:availability_zone].blank? 
-      params['BlockDeviceMappings']        = lparams[:block_device_mappings] unless lparams[:block_device_mappings].blank?
-      unless lparams[:user_data].blank? 
-        lparams[:user_data].strip! 
-          # Do not use CGI::escape(encode64(...)) as it is done in Amazons EC2 library.
-          # Amazon 169.254.169.254 does not like escaped symbols!
-          # And it doesn't like "\n" inside of encoded string! Grrr....
-          # Otherwise, some of UserData symbols will be lost...
-        params['UserData'] = Base64.encode64(lparams[:user_data]).delete("\n").strip unless lparams[:user_data].blank?
-      end
-      link = generate_request("RunInstances", params)
-        #debugger
-      instances = request_info(link, QEc2DescribeInstancesParser.new(:logger => @logger))
-      get_desc_instances(instances)
-    rescue Exception
-      on_exception
-    end
-    
-      # Terminates EC2 instances. Returns a list of termination params or an exception.
-      #
-      #  ec2.terminate_instances(['i-f222222d','i-f222222e']) #=>
-      #    [{:aws_shutdown_state      => "shutting-down", 
-      #      :aws_instance_id         => "i-f222222d", 
-      #      :aws_shutdown_state_code => 32, 
-      #      :aws_prev_state          => "running", 
-      #      :aws_prev_state_code     => 16}, 
-      #     {:aws_shutdown_state      => "shutting-down", 
-      #      :aws_instance_id         => "i-f222222e", 
-      #      :aws_shutdown_state_code => 32, 
-      #      :aws_prev_state          => "running", 
-      #      :aws_prev_state_code     => 16}]
-      #
-    def terminate_instances(list=[])
-      link = generate_request("TerminateInstances", hash_params('InstanceId',list.to_a))
-      request_info(link, QEc2TerminateInstancesParser.new(:logger => @logger))
-    rescue Exception
-      on_exception
-    end
-
-      # Retreive EC2 instance OS logs. Returns a hash of data or an exception.
-      #
-      #  ec2.get_console_output('i-f222222d') =>
-      #    {:aws_instance_id => 'i-f222222d',
-      #     :aws_timestamp   => "2007-05-23T14:36:07.000-07:00",
-      #     :timestamp       => Wed May 23 21:36:07 UTC 2007,          # Time instance
-      #     :aws_output      => "Linux version 2.6.16-xenU (builder@patchbat.amazonsa) (gcc version 4.0.1 20050727 ..."
-    def get_console_output(instance_id)
-      link = generate_request("GetConsoleOutput", { 'InstanceId.1' => instance_id })
-      request_info(link, QEc2GetConsoleOutputParser.new(:logger => @logger))
-    rescue Exception
-      on_exception
-    end
-
-      # Reboot an EC2 instance. Returns +true+ or an exception.
-      #
-      #  ec2.reboot_instances(['i-f222222d','i-f222222e']) #=> true
-      #
-    def reboot_instances(list)
-      link = generate_request("RebootInstances", hash_params('InstanceId', list.to_a))
-      request_info(link, RightBoolResponseParser.new(:logger => @logger))
-    rescue Exception
-      on_exception
-    end
-
-  #-----------------------------------------------------------------
-  #      Instances: Windows addons
-  #-----------------------------------------------------------------
-  
-      # Get initial Windows Server setup password from an instance console output.
-      #
-      #  my_awesome_key = ec2.create_key_pair('my_awesome_key') #=>
-      #    {:aws_key_name    => "my_awesome_key",
-      #     :aws_fingerprint => "01:02:03:f4:25:e6:97:e8:9b:02:1a:26:32:4e:58:6b:7a:8c:9f:03",
-      #     :aws_material    => "-----BEGIN RSA PRIVATE KEY-----\nMIIEpQIBAAK...Q8MDrCbuQ=\n-----END RSA PRIVATE KEY-----"}
-      #
-      #  my_awesome_instance = ec2.run_instances('ami-a000000a',1,1,['my_awesome_group'],'my_awesome_key', 'WindowsInstance!!!') #=>
-      #   [{:aws_image_id       => "ami-a000000a",
-      #     :aws_instance_id    => "i-12345678",
-      #     ...
-      #     :aws_availability_zone => "us-east-1b"
-      #     }]
-      #
-      #  # wait until instance enters 'operational' state and get it's initial password
-      #
-      #  puts ec2.get_initial_password(my_awesome_instance[:aws_instance_id], my_awesome_key[:aws_material]) #=> "MhjWcgZuY6"
-      #
-    def get_initial_password(instance_id, private_key)
-      console_output = get_console_output(instance_id)
-      crypted_password = console_output[:aws_output][%r{<Password>(.+)</Password>}m] && $1
-      unless crypted_password
-        raise AwsError.new("Initial password was not found in console output for #{instance_id}")
-      else
-        OpenSSL::PKey::RSA.new(private_key).private_decrypt(Base64.decode64(crypted_password))
-      end
-    rescue Exception
-      on_exception
-    end
-
-    # Bundle a Windows image.
-    # Internally, it queues the bundling task and shuts down the instance.
-    # It then takes a snapshot of the Windows volume bundles it, and uploads it to
-    # S3. After bundling completes, Rightaws::Ec2#register_image may be used to
-    # register the new Windows AMI for subsequent launches.
-    #
-    #   ec2.bundle_instance('i-e3e24e8a', 'my-awesome-bucket', 'my-win-image-1') #=>
-    #    [{:aws_update_time => "2008-10-16T13:58:25.000Z",
-    #      :s3_bucket       => "kd-win-1",
-    #      :s3_prefix       => "win2pr",
-    #      :aws_state       => "pending",
-    #      :aws_id          => "bun-26a7424f",
-    #      :aws_instance_id => "i-878a25ee",
-    #      :aws_start_time  => "2008-10-16T13:58:02.000Z"}]
-    #
-    def bundle_instance(instance_id, s3_bucket, s3_prefix, 
-                        s3_owner_aws_access_key_id=nil, s3_owner_aws_secret_access_key=nil,
-                        s3_expires = S3Interface::DEFAULT_EXPIRES_AFTER,
-                        s3_upload_policy='ec2-bundle-read')
-      # S3 access and signatures
-      s3_owner_aws_access_key_id     ||= @aws_access_key_id
-      s3_owner_aws_secret_access_key ||= @aws_secret_access_key
-      s3_expires = Time.now.utc + s3_expires if s3_expires.is_a?(Fixnum) && (s3_expires < S3Interface::ONE_YEAR_IN_SECONDS)
-      # policy
-      policy = { 'expiration' => s3_expires.strftime('%Y-%m-%dT%H:%M:%SZ'),
-                 'conditions' => [ { 'bucket' => s3_bucket },
-                                   { 'acl'    => s3_upload_policy },
-                                   [ 'starts-with', '$key', s3_prefix ] ] }.to_json
-      policy64        = Base64.encode64(policy).gsub("\n","")
-      signed_policy64 = AwsUtils.sign(s3_owner_aws_secret_access_key, policy64)
-      # fill request params
-      params = { 'InstanceId'                       => instance_id,
-                 'Storage.S3.AWSAccessKeyId'        => s3_owner_aws_access_key_id,
-                 'Storage.S3.UploadPolicy'          => policy64,
-                 'Storage.S3.UploadPolicySignature' => signed_policy64,
-                 'Storage.S3.Bucket'                => s3_bucket,
-                 'Storage.S3.Prefix'                => s3_prefix,
-                 }
-      link = generate_request("BundleInstance", params)
-      request_info(link, QEc2BundleInstanceParser.new)
-    rescue Exception
-      on_exception
-    end
-    
-      # Describe the status of the Windows AMI bundlings.
-      # If +list+ is omitted the returns the whole list of tasks.
-      #
-      #  ec2.describe_bundle_tasks(['bun-4fa74226']) #=>
-      #    [{:s3_bucket         => "my-awesome-bucket"
-      #      :aws_id            => "bun-0fa70206",
-      #      :s3_prefix         => "win1pr",
-      #      :aws_start_time    => "2008-10-14T16:27:57.000Z",
-      #      :aws_update_time   => "2008-10-14T16:37:10.000Z",
-      #      :aws_error_code    => "Client.S3Error",
-      #      :aws_error_message =>
-      #       "AccessDenied(403)- Invalid according to Policy: Policy Condition failed: [\"eq\", \"$acl\", \"aws-exec-read\"]",
-      #      :aws_state         => "failed",
-      #      :aws_instance_id   => "i-e3e24e8a"}]
-      #
-    def describe_bundle_tasks(list=[])
-      link = generate_request("DescribeBundleTasks", hash_params('BundleId', list.to_a))
-      request_info(link, QEc2DescribeBundleTasksParser.new)
-    rescue Exception
-      on_exception
-    end
-
-      # Cancel an in‐progress or pending bundle task by id.
-      #
-      #  ec2.cancel_bundle_task('bun-73a7421a') #=>
-      #   [{:s3_bucket         => "my-awesome-bucket"
-      #     :aws_id            => "bun-0fa70206",
-      #     :s3_prefix         => "win02",
-      #     :aws_start_time    => "2008-10-14T13:00:29.000Z",
-      #     :aws_error_message => "User has requested bundling operation cancellation",
-      #     :aws_state         => "failed",
-      #     :aws_update_time   => "2008-10-14T13:01:31.000Z",
-      #     :aws_error_code    => "Client.Cancelled",
-      #     :aws_instance_id   => "i-e3e24e8a"}
-      #
-    def cancel_bundle_task(bundle_id)
-      link = generate_request("CancelBundleTask", { 'BundleId' => bundle_id })
-      request_info(link, QEc2BundleInstanceParser.new)
-    rescue Exception
-      on_exception
-    end
-
-  #-----------------------------------------------------------------
-  #      Security groups
-  #-----------------------------------------------------------------
-
-      # Retrieve Security Group information. If +list+ is omitted the returns the whole list of groups.
-      #
-      #  ec2.describe_security_groups #=>
-      #    [{:aws_group_name  => "default-1",
-      #      :aws_owner       => "000000000888",
-      #      :aws_description => "Default allowing SSH, HTTP, and HTTPS ingress",
-      #      :aws_perms       =>
-      #        [{:owner => "000000000888", :group => "default"},
-      #         {:owner => "000000000888", :group => "default-1"},
-      #         {:to_port => "-1",  :protocol => "icmp", :from_port => "-1",  :cidr_ips => "0.0.0.0/0"},
-      #         {:to_port => "22",  :protocol => "tcp",  :from_port => "22",  :cidr_ips => "0.0.0.0/0"},
-      #         {:to_port => "80",  :protocol => "tcp",  :from_port => "80",  :cidr_ips => "0.0.0.0/0"},
-      #         {:to_port => "443", :protocol => "tcp",  :from_port => "443", :cidr_ips => "0.0.0.0/0"}]},
-      #    ..., {...}]
-      #
-    def describe_security_groups(list=[])
-      link = generate_request("DescribeSecurityGroups", hash_params('GroupName',list.to_a))
-      request_cache_or_info( :describe_security_groups, link,  QEc2DescribeSecurityGroupsParser, @@bench, list.blank?) do |parser|
-        result = []     
-        parser.result.each do |item|
-          perms = []
-          item.ipPermissions.each do |perm|
-            perm.groups.each do |ngroup|
-              perms << {:group => ngroup.groupName,
-                        :owner => ngroup.userId}
-            end
-            perm.ipRanges.each do |cidr_ip|
-              perms << {:from_port => perm.fromPort, 
-                        :to_port   => perm.toPort, 
-                        :protocol  => perm.ipProtocol,
-                        :cidr_ips  => cidr_ip}
-            end
-          end
-
-             # delete duplication
-          perms.each_index do |i|
-            (0...i).each do |j|
-              if perms[i] == perms[j] then perms[i] = nil; break; end
-            end
-          end
-          perms.compact!
-
-          result << {:aws_owner       => item.ownerId, 
-                     :aws_group_name  => item.groupName, 
-                     :aws_description => item.groupDescription,
-                     :aws_perms       => perms}
-        
-        end
-        result
-      end
-    rescue Exception
-      on_exception
-    end
-    
-      # Create new Security Group. Returns +true+ or an exception.
-      #
-      #  ec2.create_security_group('default-1',"Default allowing SSH, HTTP, and HTTPS ingress") #=> true
-      #
-    def create_security_group(name, description)
-      # EC2 doesn't like an empty description...
-      description = " " if description.blank?
-      link = generate_request("CreateSecurityGroup", 
-                              'GroupName'        => name.to_s,
-                              'GroupDescription' => description.to_s)
-      request_info(link, RightBoolResponseParser.new(:logger => @logger))
-    rescue Exception
-      on_exception
-    end
-
-      # Remove Security Group. Returns +true+ or an exception.
-      #
-      #  ec2.delete_security_group('default-1') #=> true
-      #
-    def delete_security_group(name)
-      link = generate_request("DeleteSecurityGroup", 
-                              'GroupName' => name.to_s)
-      request_info(link, RightBoolResponseParser.new(:logger => @logger))
-    rescue Exception
-      on_exception
-    end
-    
-      # Authorize named ingress for security group. Allows instances that are member of someone
-      # else's security group to open connections to instances in my group.
-      #
-      #  ec2.authorize_security_group_named_ingress('my_awesome_group', '7011-0219-8268', 'their_group_name') #=> true
-      #
-    def authorize_security_group_named_ingress(name, owner, group)
-      link = generate_request("AuthorizeSecurityGroupIngress", 
-                              'GroupName'                  => name.to_s,
-                                'SourceSecurityGroupName'    => group.to_s,
-                              'SourceSecurityGroupOwnerId' => owner.to_s.gsub(/-/,''))
-      request_info(link, RightBoolResponseParser.new(:logger => @logger))
-    rescue Exception
-      on_exception
-    end
-    
-      # Revoke named ingress for security group.
-      #
-      #  ec2.revoke_security_group_named_ingress('my_awesome_group', aws_user_id, 'another_group_name') #=> true
-      #
-    def revoke_security_group_named_ingress(name, owner, group)
-      link = generate_request("RevokeSecurityGroupIngress", 
-                              'GroupName'                  => name.to_s,
-                              'SourceSecurityGroupName'    => group.to_s,
-                              'SourceSecurityGroupOwnerId' => owner.to_s.gsub(/-/,''))
-      request_info(link, RightBoolResponseParser.new(:logger => @logger))
-    rescue Exception
-      on_exception
-    end
-    
-      # Add permission to a security group. Returns +true+ or an exception. +protocol+ is one of :'tcp'|'udp'|'icmp'.
-      #
-      #  ec2.authorize_security_group_IP_ingress('my_awesome_group', 80, 82, 'udp', '192.168.1.0/8') #=> true
-      #  ec2.authorize_security_group_IP_ingress('my_awesome_group', -1, -1, 'icmp') #=> true
-      #
-    def authorize_security_group_IP_ingress(name, from_port, to_port, protocol='tcp', cidr_ip='0.0.0.0/0')
-      link = generate_request("AuthorizeSecurityGroupIngress", 
-                              'GroupName'  => name.to_s,
-                              'IpProtocol' => protocol.to_s,
-                              'FromPort'   => from_port.to_s,
-                              'ToPort'     => to_port.to_s,
-                              'CidrIp'     => cidr_ip.to_s)
-      request_info(link, RightBoolResponseParser.new(:logger => @logger))
-    rescue Exception
-      on_exception
-    end
-    
-      # Remove permission from a security group. Returns +true+ or an exception. +protocol+ is one of :'tcp'|'udp'|'icmp' ('tcp' is default). 
-      #
-      #  ec2.revoke_security_group_IP_ingress('my_awesome_group', 80, 82, 'udp', '192.168.1.0/8') #=> true
-      #
-    def revoke_security_group_IP_ingress(name, from_port, to_port, protocol='tcp', cidr_ip='0.0.0.0/0')
-      link = generate_request("RevokeSecurityGroupIngress", 
-                              'GroupName'  => name.to_s,
-                              'IpProtocol' => protocol.to_s,
-                              'FromPort'   => from_port.to_s,
-                              'ToPort'     => to_port.to_s,
-                              'CidrIp'     => cidr_ip.to_s)
-      request_info(link, RightBoolResponseParser.new(:logger => @logger))
-    rescue Exception
-      on_exception
+      request_info_impl(:ec2_connection, @@bench, request, parser)
     end
 
   #-----------------------------------------------------------------
@@ -868,9 +151,10 @@ module RightAws
       #     {:aws_fingerprint=> "1e:29:30:47:58:6d:7b:8c:9f:08:11:20:3c:44:52:69:74:80:97:08", :aws_key_name=>"key-2"},
       #      ..., {...} ]
       #
-    def describe_key_pairs(list=[])
-      link = generate_request("DescribeKeyPairs", hash_params('KeyName',list.to_a))
-      request_cache_or_info :describe_key_pairs, link,  QEc2DescribeKeyPairParser, @@bench, list.blank?
+    def describe_key_pairs(*key_pairs)
+      key_pairs = key_pairs.flatten
+      link = generate_request("DescribeKeyPairs", amazonize_list('KeyName', key_pairs))
+      request_cache_or_info :describe_key_pairs, link,  QEc2DescribeKeyPairParser, @@bench, key_pairs.blank?
     rescue Exception
       on_exception
     end
@@ -940,10 +224,10 @@ module RightAws
     #
     #  ec2.describe_addresses('75.101.154.140') #=> [{:instance_id=>"i-d630cbbf", :public_ip=>"75.101.154.140"}]
     #
-    def describe_addresses(list=[])
-      link = generate_request("DescribeAddresses", 
-                              hash_params('PublicIp',list.to_a))
-      request_cache_or_info :describe_addresses, link,  QEc2DescribeAddressesParser, @@bench, list.blank?
+    def describe_addresses(*addresses)
+      addresses = addresses.flatten
+      link = generate_request("DescribeAddresses", amazonize_list('PublicIp', addresses))
+      request_cache_or_info :describe_addresses, link,  QEc2DescribeAddressesParser, @@bench, addresses.blank?
     rescue Exception
       on_exception
     end
@@ -989,10 +273,10 @@ module RightAws
     #                                                      :zone_state=>"available",
     #                                                      :zone_name=>"us-east-1c"}]
     #
-    def describe_availability_zones(list=[])
-      link = generate_request("DescribeAvailabilityZones", 
-                              hash_params('ZoneName',list.to_a))
-      request_cache_or_info :describe_availability_zones, link,  QEc2DescribeAvailabilityZonesParser, @@bench, list.blank?
+    def describe_availability_zones(*availability_zones)
+      availability_zones = availability_zones.flatten
+      link = generate_request("DescribeAvailabilityZones", amazonize_list('ZoneName', availability_zones))
+      request_cache_or_info :describe_availability_zones, link,  QEc2DescribeAvailabilityZonesParser, @@bench, availability_zones.blank?
     rescue Exception
       on_exception
     end
@@ -1005,227 +289,14 @@ module RightAws
     #
     #  ec2.describe_regions  #=> ["eu-west-1", "us-east-1"]
     #
-    def describe_regions(list=[])
-      link = generate_request("DescribeRegions",
-                              hash_params('RegionName',list.to_a))
-      request_cache_or_info :describe_regions, link,  QEc2DescribeRegionsParser, @@bench, list.blank?
-    rescue Exception
-      on_exception
-    end
-
-
-  #-----------------------------------------------------------------
-  #      EBS: Volumes
-  #-----------------------------------------------------------------
-  
-    # Describe all EBS volumes.
-    #
-    #  ec2.describe_volumes #=> 
-    #      [{:aws_size              => 94,
-    #        :aws_device            => "/dev/sdc",
-    #        :aws_attachment_status => "attached",
-    #        :zone                  => "merlot",
-    #        :snapshot_id           => nil,
-    #        :aws_attached_at       => Wed Jun 18 08:19:28 UTC 2008,
-    #        :aws_status            => "in-use",
-    #        :aws_id                => "vol-60957009",
-    #        :aws_created_at        => Wed Jun 18 08:19:20s UTC 2008,
-    #        :aws_instance_id       => "i-c014c0a9"},
-    #       {:aws_size       => 1,
-    #        :zone           => "merlot",
-    #        :snapshot_id    => nil,
-    #        :aws_status     => "available",
-    #        :aws_id         => "vol-58957031",
-    #        :aws_created_at => Wed Jun 18 08:19:21 UTC 2008,}, ... ]
-    #
-    def describe_volumes(list=[])
-      link = generate_request("DescribeVolumes", 
-                              hash_params('VolumeId',list.to_a))
-      request_cache_or_info :describe_volumes, link,  QEc2DescribeVolumesParser, @@bench, list.blank?
-    rescue Exception
-      on_exception
-    end
-    
-    # Create new EBS volume based on previously created snapshot. 
-    # +Size+ in Gigabytes.
-    #
-    #  ec2.create_volume('snap-000000', 10, zone) #=> 
-    #      {:snapshot_id    => "snap-e21df98b",
-    #       :aws_status     => "creating",
-    #       :aws_id         => "vol-fc9f7a95",
-    #       :zone           => "merlot",
-    #       :aws_created_at => Tue Jun 24 18:13:32 UTC 2008,
-    #       :aws_size       => 94}
-    #
-    def create_volume(snapshot_id, size, zone)
-      link = generate_request("CreateVolume", 
-                              "SnapshotId"        => snapshot_id.to_s,
-                              "Size"              => size.to_s,
-                              "AvailabilityZone"  => zone.to_s )
-      request_info(link, QEc2CreateVolumeParser.new(:logger => @logger))
-    rescue Exception
-      on_exception
-    end
-
-    # Delete the specified EBS volume. 
-    # This does not deletes any snapshots created from this volume.
-    #
-    #  ec2.delete_volume('vol-b48a6fdd') #=> true
-    #
-    def delete_volume(volume_id)
-      link = generate_request("DeleteVolume", 
-                              "VolumeId" => volume_id.to_s)
-      request_info(link, RightBoolResponseParser.new(:logger => @logger))
-    rescue Exception
-      on_exception
-    end
-    
-    # Attach the specified EBS volume to a specified instance, exposing the
-    # volume using the specified device name.
-    #
-    #  ec2.attach_volume('vol-898a6fe0', 'i-7c905415', '/dev/sdh') #=>
-    #    { :aws_instance_id => "i-7c905415",
-    #      :aws_device      => "/dev/sdh",
-    #      :aws_status      => "attaching",
-    #      :aws_attached_at => "2008-03-28T14:14:39.000Z",
-    #      :aws_id          => "vol-898a6fe0" }
-    #
-    def attach_volume(volume_id, instance_id, device)
-      link = generate_request("AttachVolume", 
-                              "VolumeId"   => volume_id.to_s,
-                              "InstanceId" => instance_id.to_s,
-                              "Device"     => device.to_s)
-      request_info(link, QEc2AttachAndDetachVolumeParser.new(:logger => @logger))
-    rescue Exception
-      on_exception
-    end
-    
-    # Detach the specified EBS volume from the instance to which it is attached.
-    # 
-    #   ec2.detach_volume('vol-898a6fe0') #=> 
-    #     { :aws_instance_id => "i-7c905415",
-    #       :aws_device      => "/dev/sdh",
-    #       :aws_status      => "detaching",
-    #       :aws_attached_at => "2008-03-28T14:38:34.000Z",
-    #       :aws_id          => "vol-898a6fe0"}
-    #
-    def detach_volume(volume_id, instance_id=nil, device=nil, force=nil)
-      hash = { "VolumeId" => volume_id.to_s }
-      hash["InstanceId"] = instance_id.to_s unless instance_id.blank?
-      hash["Device"]     = device.to_s      unless device.blank?
-      hash["Force"]      = 'true'           if     force
-      #
-      link = generate_request("DetachVolume", hash)
-      request_info(link, QEc2AttachAndDetachVolumeParser.new(:logger => @logger))
+    def describe_regions(*regions)
+      regions = regions.flatten
+      link = generate_request("DescribeRegions", amazonize_list('RegionName', regions))
+      request_cache_or_info :describe_regions, link,  QEc2DescribeRegionsParser, @@bench, regions.blank?
     rescue Exception
       on_exception
     end
 
-    
-  #-----------------------------------------------------------------
-  #      EBS: Snapshots
-  #-----------------------------------------------------------------
-
-     # Describe all EBS snapshots.
-     #
-     # ec2.describe_snapshots #=> 
-     #   [ { :aws_progress   => "100%",
-     #       :aws_status     => "completed",
-     #       :aws_id         => "snap-72a5401b",
-     #       :aws_volume_id  => "vol-5582673c",
-     #       :aws_started_at => "2008-02-23T02:50:48.000Z"},
-     #     { :aws_progress   => "100%",
-     #       :aws_status     => "completed",
-     #       :aws_id         => "snap-75a5401c",
-     #       :aws_volume_id  => "vol-5582673c",
-     #       :aws_started_at => "2008-02-23T16:23:19.000Z" },...]
-     #
-    def describe_snapshots(list=[])
-      link = generate_request("DescribeSnapshots", 
-                              hash_params('SnapshotId',list.to_a))
-      request_cache_or_info :describe_snapshots, link,  QEc2DescribeSnapshotsParser, @@bench, list.blank?
-    rescue Exception
-      on_exception
-    end
-
-    # Create a snapshot of specified volume.
-    #
-    #  ec2.create_snapshot('vol-898a6fe0') #=> 
-    #      {:aws_volume_id  => "vol-fd9f7a94",
-    #       :aws_started_at => Tue Jun 24 18:40:40 UTC 2008,
-    #       :aws_progress   => "",
-    #       :aws_status     => "pending",
-    #       :aws_id         => "snap-d56783bc"}
-    #
-    def create_snapshot(volume_id)
-      link = generate_request("CreateSnapshot", 
-                              "VolumeId" => volume_id.to_s)
-      request_info(link, QEc2CreateSnapshotParser.new(:logger => @logger))
-    rescue Exception
-      on_exception
-    end
-    
-    # Create a snapshot of specified volume, but with the normal retry algorithms disabled.
-    # This method will return immediately upon error.  The user can specify connect and read timeouts (in s)
-    # for the connection to AWS.  If the user does not specify timeouts, try_create_snapshot uses the default values
-    # in Rightscale::HttpConnection.
-    #
-    #  ec2.try_create_snapshot('vol-898a6fe0') #=> 
-    #      {:aws_volume_id  => "vol-fd9f7a94",
-    #       :aws_started_at => Tue Jun 24 18:40:40 UTC 2008,
-    #       :aws_progress   => "",
-    #       :aws_status     => "pending",
-    #       :aws_id         => "snap-d56783bc"}
-    #
-    def try_create_snapshot(volume_id, connect_timeout = nil, read_timeout = nil)
-      # For safety in the ensure block...we don't want to restore values 
-      # if we never read them in the first place
-      orig_reiteration_time = nil
-      orig_http_params = nil
-      
-      orig_reiteration_time = RightAws::AWSErrorHandler::reiteration_time
-      RightAws::AWSErrorHandler::reiteration_time = 0
-      
-      orig_http_params = Rightscale::HttpConnection::params()
-      new_http_params = orig_http_params.dup
-      new_http_params[:http_connection_retry_count] = 0
-      new_http_params[:http_connection_open_timeout] = connect_timeout if !connect_timeout.nil?
-      new_http_params[:http_connection_read_timeout] = read_timeout if !read_timeout.nil?
-      Rightscale::HttpConnection::params = new_http_params
-      
-      link = generate_request("CreateSnapshot", 
-                              "VolumeId" => volume_id.to_s)
-      request_info(link, QEc2CreateSnapshotParser.new(:logger => @logger))
-     
-    rescue Exception
-      on_exception
-    ensure
-      RightAws::AWSErrorHandler::reiteration_time = orig_reiteration_time if orig_reiteration_time
-      Rightscale::HttpConnection::params = orig_http_params if orig_http_params
-    end
-
-    # Delete the specified snapshot.
-    #
-    #  ec2.delete_snapshot('snap-55a5403c') #=> true
-    #
-    def delete_snapshot(snapshot_id)
-      link = generate_request("DeleteSnapshot", 
-                              "SnapshotId" => snapshot_id.to_s)
-      request_info(link, RightBoolResponseParser.new(:logger => @logger))
-    rescue Exception
-      on_exception
-    end
-    
-  #-----------------------------------------------------------------
-  #      PARSERS: Boolean Response Parser
-  #-----------------------------------------------------------------
-    
-    class RightBoolResponseParser < RightAWSParser #:nodoc:
-      def tagend(name)
-        @result = @text=='true' ? true : false if name == 'return'
-      end
-    end
-
   #-----------------------------------------------------------------
   #      PARSERS: Key Pair
   #-----------------------------------------------------------------
@@ -1259,308 +330,6 @@ module RightAws
       end
     end
 
-  #-----------------------------------------------------------------
-  #      PARSERS: Security Groups
-  #-----------------------------------------------------------------
-
-    class QEc2UserIdGroupPairType #:nodoc:
-      attr_accessor :userId
-      attr_accessor :groupName
-    end
-
-    class QEc2IpPermissionType #:nodoc:
-      attr_accessor :ipProtocol
-      attr_accessor :fromPort
-      attr_accessor :toPort
-      attr_accessor :groups
-      attr_accessor :ipRanges
-    end
-
-    class QEc2SecurityGroupItemType #:nodoc:
-      attr_accessor :groupName
-      attr_accessor :groupDescription
-      attr_accessor :ownerId
-      attr_accessor :ipPermissions
-    end
-
-
-    class QEc2DescribeSecurityGroupsParser < RightAWSParser #:nodoc:
-      def tagstart(name, attributes)
-        case name
-          when 'item' 
-            if @xmlpath=='DescribeSecurityGroupsResponse/securityGroupInfo'
-              @group = QEc2SecurityGroupItemType.new 
-              @group.ipPermissions = []
-            elsif @xmlpath=='DescribeSecurityGroupsResponse/securityGroupInfo/item/ipPermissions'
-              @perm = QEc2IpPermissionType.new
-              @perm.ipRanges = []
-              @perm.groups   = []
-            elsif @xmlpath=='DescribeSecurityGroupsResponse/securityGroupInfo/item/ipPermissions/item/groups'
-              @sgroup = QEc2UserIdGroupPairType.new
-            end
-        end
-      end
-      def tagend(name)
-        case name
-          when 'ownerId'          then @group.ownerId   = @text
-          when 'groupDescription' then @group.groupDescription = @text
-          when 'groupName'
-            if @xmlpath=='DescribeSecurityGroupsResponse/securityGroupInfo/item'
-              @group.groupName  = @text 
-            elsif @xmlpath=='DescribeSecurityGroupsResponse/securityGroupInfo/item/ipPermissions/item/groups/item'
-              @sgroup.groupName = @text 
-            end
-          when 'ipProtocol'       then @perm.ipProtocol = @text
-          when 'fromPort'         then @perm.fromPort   = @text
-          when 'toPort'           then @perm.toPort     = @text
-          when 'userId'           then @sgroup.userId   = @text
-          when 'cidrIp'           then @perm.ipRanges  << @text
-          when 'item'
-            if @xmlpath=='DescribeSecurityGroupsResponse/securityGroupInfo/item/ipPermissions/item/groups'
-              @perm.groups << @sgroup
-            elsif @xmlpath=='DescribeSecurityGroupsResponse/securityGroupInfo/item/ipPermissions'
-              @group.ipPermissions << @perm
-            elsif @xmlpath=='DescribeSecurityGroupsResponse/securityGroupInfo'
-              @result << @group
-            end
-        end
-      end
-      def reset
-        @result = []
-      end
-    end
-
-  #-----------------------------------------------------------------
-  #      PARSERS: Images
-  #-----------------------------------------------------------------
-    
-    class QEc2DescribeImagesParser < RightAWSParser #:nodoc:
-      def tagstart(name, attributes)
-        if name == 'item' && @xmlpath[%r{.*/imagesSet$}]
-          @image = {}
-        end
-      end
-      def tagend(name)
-        case name
-          when 'imageId'       then @image[:aws_id]       = @text
-          when 'imageLocation' then @image[:aws_location] = @text
-          when 'imageState'    then @image[:aws_state]    = @text
-          when 'imageOwnerId'  then @image[:aws_owner]    = @text
-          when 'isPublic'      then @image[:aws_is_public]= @text == 'true' ? true : false
-          when 'productCode'   then (@image[:aws_product_codes] ||= []) << @text
-          when 'architecture'  then @image[:aws_architecture] = @text
-          when 'imageType'     then @image[:aws_image_type] = @text
-          when 'kernelId'      then @image[:aws_kernel_id]  = @text
-          when 'ramdiskId'     then @image[:aws_ramdisk_id] = @text
-          when 'item'          then @result << @image if @xmlpath[%r{.*/imagesSet$}]
-        end
-      end
-      def reset
-        @result = []
-      end
-    end
-
-    class QEc2RegisterImageParser < RightAWSParser #:nodoc:
-      def tagend(name)
-        @result = @text if name == 'imageId'
-      end
-    end
-
-  #-----------------------------------------------------------------
-  #      PARSERS: Image Attribute
-  #-----------------------------------------------------------------
-
-    class QEc2DescribeImageAttributeParser < RightAWSParser #:nodoc:
-      def tagstart(name, attributes)
-        case name
-          when 'launchPermission'
-            @result[:groups] = []
-            @result[:users]  = []
-          when 'productCodes'
-            @result[:aws_product_codes] = []
-        end
-      end
-      def tagend(name)
-          # right now only 'launchPermission' is supported by Amazon. 
-          # But nobody know what will they xml later as attribute. That is why we 
-          # check for 'group' and 'userId' inside of 'launchPermission/item'
-        case name
-          when 'imageId'            then @result[:aws_id] = @text
-          when 'group'              then @result[:groups] << @text if @xmlpath == 'DescribeImageAttributeResponse/launchPermission/item'
-          when 'userId'             then @result[:users]  << @text if @xmlpath == 'DescribeImageAttributeResponse/launchPermission/item'
-          when 'productCode'        then @result[:aws_product_codes] << @text
-          when 'kernel'             then @result[:aws_kernel]  = @text
-          when 'ramdisk'            then @result[:aws_ramdisk] = @text
-          when 'blockDeviceMapping' then @result[:block_device_mapping] = @text
-        end
-      end
-      def reset
-        @result = {}
-      end
-    end
-
-  #-----------------------------------------------------------------
-  #      PARSERS: Instances
-  #-----------------------------------------------------------------
-
-    class QEc2DescribeInstancesParser < RightAWSParser #:nodoc:
-      def tagstart(name, attributes)
-           # DescribeInstances property
-        if (name == 'item' && @xmlpath == 'DescribeInstancesResponse/reservationSet') || 
-           # RunInstances property
-           (name == 'RunInstancesResponse')  
-            @reservation = { :aws_groups    => [],
-                             :instances_set => [] }
-              
-        elsif (name == 'item') && 
-                # DescribeInstances property
-              ( @xmlpath=='DescribeInstancesResponse/reservationSet/item/instancesSet' ||
-               # RunInstances property
-                @xmlpath=='RunInstancesResponse/instancesSet' )
-              # the optional params (sometimes are missing and we dont want them to be nil) 
-            @instance = { :aws_reason       => '',
-                          :dns_name         => '',
-                          :private_dns_name => '',
-                          :ami_launch_index => '',
-                          :ssh_key_name     => '',
-                          :aws_state        => '',
-                          :aws_product_codes => [] }
-        end
-      end
-      def tagend(name)
-        case name 
-          # reservation
-          when 'reservationId'    then @reservation[:aws_reservation_id] = @text
-          when 'ownerId'          then @reservation[:aws_owner]          = @text
-          when 'groupId'          then @reservation[:aws_groups]        << @text
-          # instance  
-          when 'instanceId'       then @instance[:aws_instance_id]    = @text
-          when 'imageId'          then @instance[:aws_image_id]       = @text
-          when 'dnsName'          then @instance[:dns_name]           = @text
-          when 'privateDnsName'   then @instance[:private_dns_name]   = @text
-          when 'reason'           then @instance[:aws_reason]         = @text
-          when 'keyName'          then @instance[:ssh_key_name]       = @text
-          when 'amiLaunchIndex'   then @instance[:ami_launch_index]   = @text
-          when 'code'             then @instance[:aws_state_code]     = @text
-          when 'name'             then @instance[:aws_state]          = @text
-          when 'productCode'      then @instance[:aws_product_codes] << @text
-          when 'instanceType'     then @instance[:aws_instance_type]  = @text
-          when 'launchTime'       then @instance[:aws_launch_time]    = @text
-          when 'kernelId'         then @instance[:aws_kernel_id]      = @text
-          when 'ramdiskId'        then @instance[:aws_ramdisk_id]     = @text
-          when 'platform'         then @instance[:aws_platform]       = @text
-          when 'availabilityZone' then @instance[:aws_availability_zone] = @text
-          when 'item'
-            if @xmlpath == 'DescribeInstancesResponse/reservationSet/item/instancesSet' || # DescribeInstances property
-               @xmlpath == 'RunInstancesResponse/instancesSet'            # RunInstances property
-              @reservation[:instances_set] << @instance
-            elsif @xmlpath=='DescribeInstancesResponse/reservationSet'    # DescribeInstances property
-              @result << @reservation
-            end
-          when 'RunInstancesResponse' then @result << @reservation            # RunInstances property
-        end
-      end
-      def reset
-        @result = []
-      end
-    end
-
-    class QEc2ConfirmProductInstanceParser < RightAWSParser #:nodoc:
-      def tagend(name)
-        @result = @text if name == 'ownerId'
-      end
-    end
-
-    class QEc2TerminateInstancesParser < RightAWSParser #:nodoc:
-      def tagstart(name, attributes)
-        @instance = {} if name == 'item'
-      end
-      def tagend(name)
-        case name
-        when 'instanceId' then @instance[:aws_instance_id] = @text
-        when 'code'
-          if @xmlpath == 'TerminateInstancesResponse/instancesSet/item/shutdownState'
-               @instance[:aws_shutdown_state_code] = @text.to_i
-          else @instance[:aws_prev_state_code]     = @text.to_i end
-        when 'name'
-          if @xmlpath == 'TerminateInstancesResponse/instancesSet/item/shutdownState'
-               @instance[:aws_shutdown_state] = @text
-          else @instance[:aws_prev_state]     = @text end
-        when 'item'       then @result << @instance
-        end
-      end
-      def reset
-        @result = []
-      end
-    end
-
-  #-----------------------------------------------------------------
-  #      PARSERS: Console
-  #-----------------------------------------------------------------
-
-    class QEc2GetConsoleOutputParser < RightAWSParser #:nodoc:
-      def tagend(name)
-        case name
-        when 'instanceId' then @result[:aws_instance_id] = @text
-        when 'timestamp'  then @result[:aws_timestamp]   = @text
-                               @result[:timestamp]       = (Time.parse(@text)).utc
-        when 'output'     then @result[:aws_output]      = Base64.decode64(@text)
-        end
-      end
-      def reset
-        @result = {}
-      end
-    end
-
-  #-----------------------------------------------------------------
-  #      Instances: Wondows related part
-  #-----------------------------------------------------------------
-    class QEc2DescribeBundleTasksParser < RightAWSParser #:nodoc:
-      def tagstart(name, attributes)
-        @bundle = {} if name == 'item'
-      end
-      def tagend(name)
-        case name
-#        when 'requestId'  then @bundle[:request_id]    = @text
-        when 'instanceId' then @bundle[:aws_instance_id]   = @text
-        when 'bundleId'   then @bundle[:aws_id]            = @text
-        when 'bucket'     then @bundle[:s3_bucket]         = @text
-        when 'prefix'     then @bundle[:s3_prefix]         = @text
-        when 'startTime'  then @bundle[:aws_start_time]    = @text
-        when 'updateTime' then @bundle[:aws_update_time]   = @text
-        when 'state'      then @bundle[:aws_state]         = @text
-        when 'progress'   then @bundle[:aws_progress]      = @text
-        when 'code'       then @bundle[:aws_error_code]    = @text
-        when 'message'    then @bundle[:aws_error_message] = @text
-        when 'item'       then @result                    << @bundle
-        end
-      end
-      def reset
-        @result = []
-      end
-    end
-
-    class QEc2BundleInstanceParser < RightAWSParser #:nodoc:
-      def tagend(name)
-        case name
-#        when 'requestId'  then @result[:request_id]    = @text
-        when 'instanceId' then @result[:aws_instance_id]   = @text
-        when 'bundleId'   then @result[:aws_id]            = @text
-        when 'bucket'     then @result[:s3_bucket]         = @text
-        when 'prefix'     then @result[:s3_prefix]         = @text
-        when 'startTime'  then @result[:aws_start_time]    = @text
-        when 'updateTime' then @result[:aws_update_time]   = @text
-        when 'state'      then @result[:aws_state]         = @text
-        when 'progress'   then @result[:aws_progress]      = @text
-        when 'code'       then @result[:aws_error_code]    = @text
-        when 'message'    then @result[:aws_error_message] = @text
-        end
-      end
-      def reset
-        @result = {}
-      end
-    end
-
   #-----------------------------------------------------------------
   #      PARSERS: Elastic IPs
   #-----------------------------------------------------------------
@@ -1600,7 +369,7 @@ module RightAws
         when 'regionName' then @zone[:region_name] = @text
         when 'zoneName'   then @zone[:zone_name]   = @text
         when 'zoneState'  then @zone[:zone_state]  = @text
-        when 'item'      then @result << @zone
+        when 'item'       then @result << @zone
         end
       end
       def reset
@@ -1620,117 +389,6 @@ module RightAws
         @result = []
       end
     end
-
-  #-----------------------------------------------------------------
-  #      PARSERS: EBS - Volumes
-  #-----------------------------------------------------------------
- 
-    class QEc2CreateVolumeParser < RightAWSParser #:nodoc:
-      def tagend(name)
-        case name 
-          when 'volumeId'         then @result[:aws_id]         = @text
-          when 'status'           then @result[:aws_status]     = @text
-          when 'createTime'       then @result[:aws_created_at] = Time.parse(@text)
-          when 'size'             then @result[:aws_size]       = @text.to_i ###
-          when 'snapshotId'       then @result[:snapshot_id]    = @text.blank? ? nil : @text ###
-          when 'availabilityZone' then @result[:zone]           = @text ###
-        end
-      end
-      def reset
-        @result = {}
-      end
-    end
-    
-    class QEc2AttachAndDetachVolumeParser < RightAWSParser #:nodoc:
-      def tagend(name)
-        case name 
-          when 'volumeId'   then @result[:aws_id]                = @text
-          when 'instanceId' then @result[:aws_instance_id]       = @text
-          when 'device'     then @result[:aws_device]            = @text
-          when 'status'     then @result[:aws_attachment_status] = @text
-          when 'attachTime' then @result[:aws_attached_at]       = Time.parse(@text)
-        end
-      end
-      def reset
-        @result = {}
-      end
-    end
-      
-    class QEc2DescribeVolumesParser < RightAWSParser #:nodoc:
-      def tagstart(name, attributes)
-        case name
-        when 'item'
-          case @xmlpath
-            when 'DescribeVolumesResponse/volumeSet' then @volume = {}
-          end
-        end
-      end
-      def tagend(name)
-        case name 
-          when 'volumeId'
-            case @xmlpath
-            when 'DescribeVolumesResponse/volumeSet/item' then @volume[:aws_id] = @text
-            end
-          when 'status'
-            case @xmlpath
-            when 'DescribeVolumesResponse/volumeSet/item' then @volume[:aws_status] = @text
-            when 'DescribeVolumesResponse/volumeSet/item/attachmentSet/item' then @volume[:aws_attachment_status] = @text
-            end
-          when 'size'             then @volume[:aws_size]        = @text.to_i
-          when 'createTime'       then @volume[:aws_created_at]  = Time.parse(@text)
-          when 'instanceId'       then @volume[:aws_instance_id] = @text
-          when 'device'           then @volume[:aws_device]      = @text
-          when 'attachTime'       then @volume[:aws_attached_at] = Time.parse(@text)
-          when 'snapshotId'       then @volume[:snapshot_id]     = @text.blank? ? nil : @text
-          when 'availabilityZone' then @volume[:zone]            = @text
-          when 'item' 
-            case @xmlpath
-            when 'DescribeVolumesResponse/volumeSet' then @result << @volume
-            end
-        end
-      end
-      def reset
-        @result = []
-      end
-    end
-
-  #-----------------------------------------------------------------
-  #      PARSERS: EBS - Snapshots
-  #-----------------------------------------------------------------
-  
-    class QEc2DescribeSnapshotsParser < RightAWSParser #:nodoc:
-      def tagstart(name, attributes)
-        @snapshot = {} if name == 'item'
-      end
-      def tagend(name)
-        case name 
-          when 'volumeId'   then @snapshot[:aws_volume_id]  = @text
-          when 'snapshotId' then @snapshot[:aws_id]         = @text
-          when 'status'     then @snapshot[:aws_status]     = @text
-          when 'startTime'  then @snapshot[:aws_started_at] = Time.parse(@text)
-          when 'progress'   then @snapshot[:aws_progress]   = @text
-          when 'item'       then @result                   << @snapshot
-        end
-      end
-      def reset
-        @result = []
-      end
-    end
-
-    class QEc2CreateSnapshotParser < RightAWSParser #:nodoc:
-      def tagend(name)
-        case name 
-          when 'volumeId'   then @result[:aws_volume_id]  = @text
-          when 'snapshotId' then @result[:aws_id]         = @text
-          when 'status'     then @result[:aws_status]     = @text
-          when 'startTime'  then @result[:aws_started_at] = Time.parse(@text)
-          when 'progress'   then @result[:aws_progress]   = @text
-        end
-      end
-      def reset
-        @result = {}
-      end
-    end
     
   end