amazon-ec2 0.1.0 → 0.2.0

data/lib/EC2/instances.rb

@@ -1,121 +1,191 @@
-# Amazon Web Services EC2 Query API Ruby Library
-# This library has been packaged as a Ruby Gem 
-# by Glenn Rempe ( grempe @nospam@ rubyforge.org ).
-# 
-# Source code and gem hosted on RubyForge
-# under the Ruby License as of 12/14/2006:
-# http://amazon-ec2.rubyforge.org
+#--
+# Amazon Web Services EC2 Query API Ruby library
+#
+# Ruby Gem Name::  amazon-ec2
+# Author::    Glenn Rempe  (mailto:glenn@elasticworkbench.com)
+# Copyright:: Copyright (c) 2007 Glenn Rempe
+# License::   Distributes under the same terms as Ruby
+# Home::      http://amazon-ec2.rubyforge.org
+#++
 
 module EC2
   
-  class AWSAuthConnection
+  class Base
     
-    # The RunInstances operation launches a specified number of instances.
+    #Amazon Developer Guide Docs:
     #
-    # Note:
-    #   The Query version of RunInstances only allows instances of a 
-    #   single AMI to be launched in one call. This is different 
-    #   from the SOAP API call of the same name but similar to the 
-    #   ec2-run-instances command line tool.
+    # The RunInstances operation launches a specified number of instances. 
     # 
-    # A call to RunInstances is guaranteed to start no fewer than the 
-    # requested minimum. If there is insufficient capacity available 
-    # then no instances will be started. Amazon EC2 will make a best 
-    # effort attempt to satisfy the requested maximum values.
-    #
-    # Every instance is launched in a security group. This may be 
-    # specified as part of the launch request. If a security group is 
-    # not indicated then instances are started in a the default security group.
-    #
-    # An optional keypair ID may be provided for each image in the launch 
-    # request. All instances that are created from images for which this 
-    # is provided will have access to the associated public key at boot 
-    # time (detailed below). This key may be used to provide secure access 
-    # to an instance of an image on a per-instance basis. Amazon EC2 public 
-    # images make use of this functionality to provide secure passwordless 
-    # access to instances (and launching those images without a keypair ID 
-    # will leave them inaccessible).
-    #
-    # The public key material is made available to the instance at boot 
-    # time by placing it in a file named openssh_id.pub on a logical 
-    # device that is exposed to the instance as /dev/sda2 (the ephemeral store). 
-    # The format of this file is suitable for use as an entry within 
-    # ~/.ssh/authorized_keys (the OpenSSH format). This can be done at boot 
-    # time (as part of rclocal, for example) allowing for secure 
-    # password-less access. As the need arises, other formats will 
-    # also be considered.
-    def run_instances(imageId, kwargs={})
-      
-      # setup the default input parameters hash
-      in_params = { :minCount=>1, :maxCount=>1, :keyname=>nil, :groupIds=>[], :userData=>nil, :base64Encoded=>false }
-      
-      # Override or extend the default input params with any passed in kwargs
-      in_params.merge!(kwargs)
-      
-      # If userData is passed in then URL escape and Base64 encode it
+    # Note : The Query version of RunInstances only allows instances of a single AMI to be launched in 
+    # one call. This is different from the SOAP API call of the same name but similar to the 
+    # ec2-run-instances command line tool. 
+    # 
+    # A call to RunInstances is guaranteed to start no fewer than the requested minimum. If there is 
+    # insufficient capacity available then no instances will be started. Amazon EC2 will make a best effort 
+    # attempt to satisfy the requested maximum values. 
+    # 
+    # Every instance is launched in a security group. This may be specified as part of the launch request. If a 
+    # security group is not indicated then instances are started in a the default security group. 
+    # An optional keypair ID may be provided for each image in the launch request. All instances that are 
+    # created from images for which this is provided will have access to the associated public key at boot time 
+    # (detailed below). This key may be used to provide secure access to an instance of an image on a 
+    # per-instance basis. Amazon EC2 public images make use of this functionality to provide secure 
+    # passwordless access to instances (and launching those images without a keypair ID will leave them 
+    # inaccessible). 
+    # 
+    # The public key material is made available to the instance at boot time by placing it in a file named 
+    # openssh_id.pub on a logical device that is exposed to the instance as /dev/sda2 (the ephemeral 
+    # store). The format of this file is suitable for use as an entry within ~/.ssh/authorized_keys (the 
+    # OpenSSH format). This can be done at boot time (as part of rclocal, for example) allowing for secure 
+    # password-less access. As the need arises, other formats will also be considered.
+    #
+    #Required Arguments:
+    #
+    # :image_id => String (Default : "")
+    # :min_count => Integer (default : 1 )
+    # :max_count => Integer (default : 1 )
+    #
+    #Optional Arguments:
+    #
+    # :key_name => String (default : nil)
+    # :group_id => Array (default : [])
+    # :user_data => String (default : nil)
+    # :addressing_type => String (default : "public")
+    # :base64_encoded => Boolean (default : false)
+    #
+    def run_instances( options = {} )
+      
+      options = { :image_id => "",
+                  :min_count => 1, 
+                  :max_count => 1,
+                  :key_name => nil,
+                  :group_id => [],
+                  :user_data => nil,
+                  :addressing_type => "public",
+                  :base64_encoded => false }.merge(options)
+      
+      # Do some validation on the arguments provided
+      raise ArgumentError, ":image_id must be provided" if options[:image_id].nil? || options[:image_id].empty?
+      raise ArgumentError, ":min_count is not valid" unless options[:min_count].to_i > 0
+      raise ArgumentError, ":max_count is not valid" unless options[:max_count].to_i > 0
+      raise ArgumentError, ":addressing_type must be 'direct' or 'public'" unless options[:addressing_type] == "public" || options[:addressing_type] == "direct"
+      raise ArgumentError, ":base64_encoded must be 'true' or 'false'" unless options[:base64_encoded] == true || options[:base64_encoded] == false
+      
+      # If :user_data is passed in then URL escape and Base64 encode it
       # as needed.  Need for URL Escape + Base64 encoding is determined 
-      # by base64Encoded param.
-      if in_params[:userData]
-        if in_params[:base64Encoded]
-          userData = in_params[:userData]
+      # by :base64_encoded param.
+      if options[:user_data]
+        if options[:base64_encoded]
+          user_data = options[:user_data]
         else
-          userData = Base64.encode64(in_params[:userData]).gsub(/\n/,"").strip()
+          user_data = Base64.encode64(options[:user_data]).gsub(/\n/,"").strip()
         end
       else
-        userData = nil
+        user_data = nil
       end
-
+      
       params = {
-        "ImageId"  => imageId,
-        "MinCount" => in_params[:minCount].to_s,
-        "MaxCount" => in_params[:maxCount].to_s,
-      }.merge(pathlist("SecurityGroup", in_params[:groupIds])) 
+        "ImageId"  => options[:image_id],
+        "MinCount" => options[:min_count].to_s,
+        "MaxCount" => options[:max_count].to_s,
+      }.merge(pathlist("SecurityGroup", options[:group_id])) 
+      
+      params["KeyName"] = options[:key_name] unless options[:key_name].nil? 
+      params["UserData"] = user_data unless user_data.nil?
+      params["AddressingType"] = options[:addressing_type]
+       
+      return response_generator(:action => "RunInstances", :params => params)
       
-      params["KeyName"] = in_params[:keyname] unless in_params[:keyname].nil? 
-      params["UserData"] = userData unless userData.nil?
-
-      RunInstancesResponse.new(make_request("RunInstances", params))
     end
     
-    # The DescribeInstances operation returns information about instances owned 
-    # by the user making the request.
-    #
-    # An optional list of instance IDs may be provided to request information 
-    # for those instances only. If no instance IDs are provided, information of 
-    # all relevant instances information will be returned. If an instance is 
-    # specified that does not exist a fault is returned. If an instance is specified 
-    # that exists but is not owned by the user making the request, then that 
-    # instance will not be included in the returned results.
-    #
-    # Recently terminated instances will be included in the returned results 
-    # for a small interval subsequent to their termination. This interval 
-    # is typically of the order of one hour.
-    def describe_instances(instanceIds=[])
-      params = pathlist("InstanceId", instanceIds)
-      DescribeInstancesResponse.new(make_request("DescribeInstances", params))
+    
+    #Amazon Developer Guide Docs:
+    #
+    # The DescribeInstances operation returns information about instances owned by the user 
+    # making the request.
+    #
+    # An optional list of instance IDs may be provided to request information for those instances only. If no 
+    # instance IDs are provided, information of all relevant instances information will be returned. If an 
+    # instance is specified that does not exist a fault is returned. If an instance is specified that exists but is not 
+    # owned by the user making the request, then that instance will not be included in the returned results. 
+    # 
+    # Recently terminated instances will be included in the returned results for a small interval subsequent to 
+    # their termination. This interval is typically of the order of one hour
+    #
+    #Required Arguments:
+    #
+    # none
+    #
+    #Optional Arguments:
+    #
+    # :instance_id => Array (default : [])
+    #
+    def describe_instances( options = {} )
+      
+      options = { :instance_id => [] }.merge(options)
+      
+      params = pathlist("InstanceId", options[:instance_id])
+      
+      return response_generator(:action => "DescribeInstances", :params => params)
+      
     end
     
-    # The TerminateInstances operation shuts down one or more instances. 
-    # This operation is idempotent and terminating an instance that is 
-    # in the process of shutting down (or already terminated) will succeed.
-    #
-    # Terminated instances remain visible for a short period of time 
-    # (approximately one hour) after termination, after which their 
-    # instance ID is invalidated.
-    def terminate_instances(instanceIds)
-      params = pathlist("InstanceId", instanceIds)
-      TerminateInstancesResponse.new(make_request("TerminateInstances", params))
+    
+    #Amazon Developer Guide Docs:
+    #
+    # The RebootInstances operation requests a reboot of one or more instances. This operation is 
+    # asynchronous; it only queues a request to reboot the specified instance(s). The operation will succeed 
+    # provided the instances are valid and belong to the user. Terminated instances will be ignored.
+    #
+    #Required Arguments:
+    #
+    # :instance_id => Array (default : [])
+    #
+    #Optional Arguments:
+    #
+    # none
+    #
+    def reboot_instances( options = {} )
+      
+      # defaults
+      options = { :instance_id => [] }.merge(options)
+      
+      raise ArgumentError, "No instance IDs provided" if options[:instance_id].nil? || options[:instance_id].empty?
+      
+      params = pathlist("InstanceId", options[:instance_id])
+      
+      return response_generator(:action => "RebootInstances", :params => params)
+      
     end
     
-    # The RebootInstances operation requests a reboot of one or more instances. 
-    # This operation is asynchronous; it only queues a request to reboot the specified 
-    # instance(s). The operation will succeed provided the instances are valid and 
-    # belong to the user. Terminated instances will be ignored.
-    def reboot_instances(*instance_ids)
-      raise "No instance ids given" if instance_ids.empty?
-      params = pathlist("InstanceId", instance_ids)
-      ResetInstancesResponse.new(make_request("RebootInstances", params))
+    
+    #Amazon Developer Guide Docs:
+    #
+    # The TerminateInstances operation shuts down one or more instances. This operation is idempotent 
+    # and terminating an instance that is in the process of shutting down (or already terminated) will succeed. 
+    # Terminated instances remain visible for a short period of time (approximately one hour) after 
+    # termination, after which their instance ID is invalidated.
+    #
+    #Required Arguments:
+    #
+    # :instance_id => Array (default : [])
+    #
+    #Optional Arguments:
+    #
+    # none
+    #
+    def terminate_instances( options = {} )
+      
+      options = { :instance_id => [] }.merge(options)
+      
+      raise ArgumentError, "No :instance_id provided" if options[:instance_id].nil? || options[:instance_id].empty?
+      
+      params = pathlist("InstanceId", options[:instance_id])
+      
+      return response_generator(:action => "TerminateInstances", :params => params)
+      
     end
+    
   end
   
 end

data/lib/EC2/keypairs.rb

@@ -1,36 +1,92 @@
-# Amazon Web Services EC2 Query API Ruby Library
-# This library has been packaged as a Ruby Gem 
-# by Glenn Rempe ( grempe @nospam@ rubyforge.org ).
-# 
-# Source code and gem hosted on RubyForge
-# under the Ruby License as of 12/14/2006:
-# http://amazon-ec2.rubyforge.org
+#--
+# Amazon Web Services EC2 Query API Ruby library
+#
+# Ruby Gem Name::  amazon-ec2
+# Author::    Glenn Rempe  (mailto:glenn@elasticworkbench.com)
+# Copyright:: Copyright (c) 2007 Glenn Rempe
+# License::   Distributes under the same terms as Ruby
+# Home::      http://amazon-ec2.rubyforge.org
+#++
 
 module EC2
   
-  class AWSAuthConnection
+  class Base
     
-    # The CreateKeyPair operation creates a new 2048 bit RSA keypair 
-    # and returns a unique ID that can be used to reference this 
-    # keypair when launching new instances.
-    def create_keypair(keyName)
-      params = { "KeyName" => keyName }
-      CreateKeyPairResponse.new(make_request("CreateKeyPair", params))
+    
+    #Amazon Developer Guide Docs:
+    #
+    # The CreateKeyPair operation creates a new 2048 bit RSA keypair and returns a unique ID that can be 
+    # used to reference this keypair when launching new instances.
+    #
+    #Required Arguments:
+    #
+    # :key_name => String (default : "")
+    #
+    #Optional Arguments:
+    #
+    # none
+    #
+    def create_keypair( options = {} )
+      
+      # defaults
+      options = { :key_name => "" }.merge(options)
+      
+      raise ArgumentError, "No :key_name provided" if options[:key_name].nil? || options[:key_name].empty?
+      
+      params = { "KeyName" => options[:key_name] }
+      
+      return response_generator(:action => "CreateKeyPair", :params => params)
+      
     end
     
-    # The DescribeKeyPairs operation returns information about keypairs 
-    # available for use by the user making the request. Selected keypairs 
-    # may be specified or the list may be left empty if information for 
+    
+    #Amazon Developer Guide Docs:
+    #
+    # The DescribeKeyPairs operation returns information about keypairs available for use by the user 
+    # making the request. Selected keypairs may be specified or the list may be left empty if information for 
     # all registered keypairs is required.
-    def describe_keypairs(keyNames=[])
-      params = pathlist("KeyName", keyNames)
-      DescribeKeyPairsResponse.new(make_request("DescribeKeyPairs", params))
+    #
+    #Required Arguments:
+    #
+    # :key_name => Array (default : [])
+    #
+    #Optional Arguments:
+    #
+    # none
+    #
+    def describe_keypairs( options = {} )
+      
+      options = { :key_name => [] }.merge(options)
+      
+      params = pathlist("KeyName", options[:key_name] )
+      
+      return response_generator(:action => "DescribeKeyPairs", :params => params)
+      
     end
     
+    
+    #Amazon Developer Guide Docs:
+    #
     # The DeleteKeyPair operation deletes a keypair.
-    def delete_keypair(keyName)
-      params = { "KeyName" => keyName }
-      DeleteKeyPairResponse.new(make_request("DeleteKeyPair", params))
+    #
+    #Required Arguments:
+    #
+    # :key_name => String (default : "")
+    #
+    #Optional Arguments:
+    #
+    # none
+    #
+    def delete_keypair( options = {} )
+      
+      options = { :key_name => "" }.merge(options)
+      
+      raise ArgumentError, "No :key_name provided" if options[:key_name].nil? || options[:key_name].empty?
+      
+      params = { "KeyName" => options[:key_name] }
+      
+      return response_generator(:action => "DeleteKeyPair", :params => params)
+      
     end
     
   end

data/lib/EC2/responses.rb

@@ -1,348 +1,169 @@
-# Amazon Web Services EC2 Query API Ruby Library
-# This library has been packaged as a Ruby Gem 
-# by Glenn Rempe ( grempe @nospam@ rubyforge.org ).
-# 
-# Source code and gem hosted on RubyForge
-# under the Ruby License as of 12/14/2006:
-# http://amazon-ec2.rubyforge.org
+#--
+# Amazon Web Services EC2 Query API Ruby library
+#
+# Ruby Gem Name::  amazon-ec2
+# Author::    Glenn Rempe  (mailto:glenn@elasticworkbench.com)
+# Copyright:: Copyright (c) 2007 Glenn Rempe
+# License::   Distributes under the same terms as Ruby
+# Home::      http://amazon-ec2.rubyforge.org
+#++
 
 module EC2
   
-  class Response
-    attr_reader :http_response
-    attr_reader :http_xml
-    attr_reader :structure
+  # The make_request() and ec2_error? methods, which are shared by all, will raise any 
+  # exceptions encountered along the way as it converses with EC2.
+  #
+  # Exception Handling: If for some reason an error occurrs when executing a method
+  # (e.g. its arguments were incorrect, or it simply failed) then an exception will 
+  # be thrown.  The exceptions are defined in exceptions.rb as individual classes and should
+  # match the exceptions that Amazon has defined for EC2.  If the exception raised cannot be
+  # identified then a more generic exception class will be thrown.
+  #
+  # The implication of this is that you need to be prepared to handle any exceptions that
+  # may be raised by this library in YOUR code with a 'rescue' clauses.  It is up to you
+  # how gracefully you want to handle these exceptions that are raised.
+  
+  # Credits :
+  # I learned the magic of making an OpenStruct object able to respond as a fully Enumerable 
+  # object (responds to .each, etc.) thanks to a great blog article on Struct and OpenStruct 
+  # at http://errtheblog.com/post/30
+  #
+  # Thanks to Sean Knapp for the XmlSimple response patch which greatly simplified the response
+  # mechanism for the whole library while making it more accurate and much less brittle to boot!
+  #
+  
+  require 'xmlsimple'
+  
+  class Response < OpenStruct
     
-    ERROR_XPATH = "Response/Errors/Error"
+    include Enumerable
     
-    def initialize(http_response)
-      @http_response = http_response
-      @http_xml = http_response.body
-      @is_error = false
-      if http_response.is_a? Net::HTTPSuccess
-        @structure = parse
-      else
-        @is_error = true
-        @structure = parse_error
-      end
-    end
     
-    def is_error?
-      @is_error
-    end
-    
-    def parse_error
-      doc = REXML::Document.new(@http_xml)
-      element = REXML::XPath.first(doc, ERROR_XPATH)
-      
-      errorCode = REXML::XPath.first(element, "Code").text
-      errorMessage = REXML::XPath.first(element, "Message").text
+    def self.parse(options = {})
+      options = {
+        :xml => "",
+        :parse_options => { 'ForceArray' => ['item'], 'SuppressEmpty' => nil }
+      }.merge(options)
+      response = Response.new(XmlSimple.xml_in(options[:xml], options[:parse_options]))
       
-      [["#{errorCode}: #{errorMessage}"]]
+      # set the xml attribute of the response object to contain the original XML that was
+      # returned by amazon.  This allows anyone to bypass our parsing if desired and just
+      # get right at the raw XML response.
+      response.xml = options[:xml]
+      return response
     end
     
-    def parse
-      # Placeholder -- this method should be overridden in child classes.
-      nil
-    end
     
-    def to_s
-      @structure.collect do |line|
-        line.join("\t")
-      end.join("\n")
+    # Every member of an OpenStruct object has getters and setters, the latter of which
+    # has a method ending in "=". Find all of these methods, excluding those defined on
+    # parent classes.
+    def members
+      methods(false).sort.grep(/=/).map { |m| m[0...-1] } 
     end
     
-  end
-  
-  
-  class DescribeImagesResponse < Response
-    ELEMENT_XPATH = "DescribeImagesResponse/imagesSet/item"
-    def parse
-      doc = REXML::Document.new(@http_xml)
-      lines = []
-      
-      doc.elements.each(ELEMENT_XPATH) do |element|
-        imageId = REXML::XPath.first(element, "imageId").text
-        imageLocation = REXML::XPath.first(element, "imageLocation").text
-        imageOwnerId = REXML::XPath.first(element, "imageOwnerId").text
-        imageState = REXML::XPath.first(element, "imageState").text
-        isPublic = REXML::XPath.first(element, "isPublic").text
-        lines << ["IMAGE", imageId, imageLocation, imageOwnerId, imageState, isPublic]
+    
+    # Required by the Enumerable module. Iterate over each item in the members array
+    # and pass as a value the block passed to each using yield.
+    def each
+      members.each do |method|
+        yield send(method)
       end
-      lines
-    end
-  end
-  
-  
-  class RegisterImageResponse < Response
-    ELEMENT_XPATH = "RegisterImageResponse/imageId"
-    def parse
-      doc = REXML::Document.new(@http_xml)
-      lines = [["IMAGE", REXML::XPath.first(doc, ELEMENT_XPATH).text]]
-    end
-  end
-  
-  
-  class DeregisterImageResponse < Response
-    def parse
-      # If we don't get an error, the deregistration succeeded.
-      [["Image deregistered."]]
-    end
-  end
-  
-  
-  class CreateKeyPairResponse < Response
-    ELEMENT_XPATH = "CreateKeyPairResponse"
-    def parse
-      doc = REXML::Document.new(@http_xml)
-      element = REXML::XPath.first(doc, ELEMENT_XPATH)
-      
-      keyName = REXML::XPath.first(element, "keyName").text
-      keyFingerprint = REXML::XPath.first(element, "keyFingerprint").text
-      keyMaterial = REXML::XPath.first(element, "keyMaterial").text
-      
-      line = [["KEYPAIR", keyName, keyFingerprint], [keyMaterial]]
+      self
     end
-  end
-  
-  
-  class DescribeKeyPairsResponse < Response
-    ELEMENT_XPATH = "DescribeKeyPairsResponse/keySet/item"
-    def parse
-      doc = REXML::Document.new(@http_xml)
-      lines = []
-  
-      doc.elements.each(ELEMENT_XPATH) do |element|
-        keyName = REXML::XPath.first(element, "keyName").text
-        keyFingerprint = REXML::XPath.first(element, "keyFingerprint").text
-        lines << ["KEYPAIR", keyName, keyFingerprint]
+    
+    
+    # Same as the each method, but with both key and value.
+    #
+    #Sample Use:
+    # obj.each_pair { |k,v| puts "key: #{k}, value: #{v}" }
+    def each_pair 
+      members.each do |method|
+        yield method, send(method)
       end
-      lines
+      self
     end
-  end
-  
-  
-  class DeleteKeyPairResponse < Response
-    def parse
-      # If we don't get an error, the deletion succeeded.
-      [["Keypair deleted."]]
+    
+    
+    # Alternative method for getting members.
+    def [](member)
+      send(member)
     end
-  end
-  
-  
-  class RunInstancesResponse < Response
-    ELEMENT_XPATH = "RunInstancesResponse"
-    def parse
-      doc = REXML::Document.new(@http_xml)
-      lines = []
-      
-      rootelement = REXML::XPath.first(doc, ELEMENT_XPATH)
-      
-      reservationId = REXML::XPath.first(rootelement, "reservationId").text
-      ownerId = REXML::XPath.first(rootelement, "ownerId").text
-      groups = nil
-      rootelement.elements.each("groupSet/item/groupId") do |element|
-        if not groups
-          groups = element.text
-        else
-          groups += "," + element.text
-        end
-      end
-      lines << ["RESERVATION", reservationId, ownerId, groups]
-      
-      #    rootelement = REXML::XPath.first(doc, ELEMENT_XPATH)
-      rootelement.elements.each("instancesSet/item") do |element|
-        instanceId = REXML::XPath.first(element, "instanceId").text
-        imageId = REXML::XPath.first(element, "imageId").text
-        instanceState = REXML::XPath.first(element, "instanceState/name").text
-        # Only for debug mode, which we don't support yet:
-        instanceStateCode = REXML::XPath.first(element, "instanceState/code").text
-        dnsName = REXML::XPath.first(element, "dnsName").text
-        # We don't return this, but still:
-        reason = REXML::XPath.first(element, "reason").text
-        lines << ["INSTANCE", instanceId, imageId, dnsName, instanceState]
-      end
-      lines
+    
+    
+    # Alternative method for setting members.
+    def []=(member, value)
+      send("#{member}=", value)
     end
-  end
-  
-  
-  class DescribeInstancesResponse < Response
-    ELEMENT_XPATH = "DescribeInstancesResponse/reservationSet/item"
-    def parse
-      doc = REXML::Document.new(@http_xml)
-      lines = []
-      
-      doc.elements.each(ELEMENT_XPATH) do |rootelement|
-        reservationId = REXML::XPath.first(rootelement, "reservationId").text
-        ownerId = REXML::XPath.first(rootelement, "ownerId").text
-        groups = nil
-        rootelement.elements.each("groupSet/item/groupId") do |element|
-          if not groups
-            groups = element.text
-          else
-            groups += "," + element.text
+    
+    
+    # Helper for converting to string which support a long and short version
+    # to avoid recursion problems with parents.
+    def to_string(short=false)
+      s = "#<#{self.class}:0x#{(2 ** 32 + object_id).to_s(16).upcase}"
+      if (short)
+        s += " ..."
+      else
+        each_pair { |k,v|
+          if (v == self.parent && v.kind_of?(Response))
+            v = v.to_string(true)
+          elsif (v.kind_of?(String))
+            v = "\"#{v.gsub("\"", "\\\"")}\""
+          elsif (v.kind_of?(NilClass))
+            v = "nil"
           end
-        end
-        lines << ["RESERVATION", reservationId, ownerId, groups]
-        
-        rootelement.elements.each("instancesSet/item") do |element|
-          instanceId = REXML::XPath.first(element, "instanceId").text
-          imageId = REXML::XPath.first(element, "imageId").text
-          instanceState = REXML::XPath.first(element, "instanceState/name").text
-          # Only for debug mode, which we don't support yet:
-          instanceStateCode = REXML::XPath.first(element, "instanceState/code").text
-          dnsName = REXML::XPath.first(element, "dnsName").text
-          # We don't return this, but still:
-          reason = REXML::XPath.first(element, "reason").text
-          lines << ["INSTANCE", instanceId, imageId, dnsName, instanceState]
-        end
-      end
-      lines
-    end
-  end
-  
-  
-  class TerminateInstancesResponse < Response
-    ELEMENT_XPATH = "TerminateInstancesResponse/instancesSet/item"
-    def parse
-      doc = REXML::Document.new(@http_xml)
-      lines = []
-      
-      doc.elements.each(ELEMENT_XPATH) do |element|
-        instanceId = REXML::XPath.first(element, "instanceId").text
-        shutdownState = REXML::XPath.first(element, "shutdownState/name").text
-        # Only for debug mode, which we don't support yet:
-        shutdownStateCode = REXML::XPath.first(element, "shutdownState/code").text
-        previousState = REXML::XPath.first(element, "previousState/name").text
-        # Only for debug mode, which we don't support yet:
-        previousStateCode = REXML::XPath.first(element, "previousState/code").text
-        lines << ["INSTANCE", instanceId, previousState, shutdownState]
+          s += " #{k}=#{v}"
+        }
       end
-      lines
+      s += ">"
+      return s
     end
-  end
-  
-  class ResetInstancesResponse < Response
-    def parse
-      doc = REXML::Document.new(@http_xml)
-      # Let's use the tag they're actually returning since it doesn't match the docs -- Kevin Clark 2/26/07
-      REXML::XPath.match( doc, "//return").first.text == "true" ? true : false 
+    
+    
+    # Override of to string method.
+    def to_s
+      return to_string
     end
-  end
-  
-  
-  class CreateSecurityGroupResponse < Response
-    def parse
-      # If we don't get an error, the creation succeeded.
-      [["Security Group created."]]
+    
+    
+    private 
+    
+    # Initialize the object by passing data to the OpenStruct initialize method
+    # and then converting ourself to guarantee we have top-to-bottom data 
+    # representation as a Response object.
+    def initialize(data, parent=nil)
+      super(data)
+      self.parent = parent
+      Response.convert(self, parent)
     end
-  end
-  
-  
-  class DescribeSecurityGroupsResponse < Response
-    ELEMENT_XPATH = "DescribeSecurityGroupsResponse/securityGroupInfo/item"
-    def parse
-      doc = REXML::Document.new(@http_xml)
-      lines = []
-      
-      doc.elements.each(ELEMENT_XPATH) do |rootelement|
-        groupName = REXML::XPath.first(rootelement, "groupName").text
-        ownerId = REXML::XPath.first(rootelement, "ownerId").text
-        groupDescription = REXML::XPath.first(rootelement, "groupDescription").text
-        lines << ["GROUP", ownerId, groupName, groupDescription]
-        rootelement.elements.each("ipPermissions/item") do |element|
-          ipProtocol = REXML::XPath.first(element, "ipProtocol").text
-          fromPort = REXML::XPath.first(element, "fromPort").text
-          toPort = REXML::XPath.first(element, "toPort").text
-          permArr = [
-                     "PERMISSION",
-                     ownerId,
-                     groupName,
-                     "ALLOWS",
-                     ipProtocol,
-                     fromPort,
-                     toPort,
-                     "FROM"
-                    ]
-          element.elements.each("groups/item") do |subelement|
-            userId = REXML::XPath.first(subelement, "userId").text
-            targetGroupName = REXML::XPath.first(subelement, "groupName").text
-            lines << permArr + ["USER", userId, "GRPNAME", targetGroupName]
-          end
-          element.elements.each("ipRanges/item") do |subelement|
-            cidrIp = REXML::XPath.first(subelement, "cidrIp").text
-            lines << permArr + ["CIDR", cidrIp]
+    
+    
+    # The "brains" of our Response class. This method takes an arbitray object and
+    # depending on its class attempts to convert it.
+    def self.convert(obj, parent)
+      if (obj.kind_of?(Response))
+        # Recursively convert the object.
+        obj.each_pair { |k,v|
+          if (v != obj.parent)
+            obj[k] = convert(v, obj)
           end
-        end
-      end
-      lines
-    end
-  end
-  
-  
-  class DeleteSecurityGroupResponse < Response
-    def parse
-      # If we don't get an error, the deletion succeeded.
-      [["Security Group deleted."]]
-    end
-  end
-  
-  
-  class AuthorizeSecurityGroupIngressResponse < Response
-    def parse
-      # If we don't get an error, the authorization succeeded.
-      [["Ingress authorized."]]
-    end
-  end
-  
-  
-  class RevokeSecurityGroupIngressResponse < Response
-    def parse
-      # If we don't get an error, the revocation succeeded.
-      [["Ingress revoked."]]
-    end
-  end
-  
-  
-  class ModifyImageAttributeResponse < Response
-    def parse
-      # If we don't get an error, modification succeeded.
-      [["Image attribute modified."]]
-    end
-  end
-  
-  
-  class ResetImageAttributeResponse < Response
-    def parse
-      # If we don't get an error, reset succeeded.
-      [["Image attribute reset."]]
-    end
-  end
-  
-  
-  class DescribeImageAttributeResponse < Response
-    ELEMENT_XPATH = "DescribeImageAttributeResponse"
-    def parse
-      doc = REXML::Document.new(@http_xml)
-      lines = []
-      
-      rootelement = REXML::XPath.first(doc, ELEMENT_XPATH)
-      imageId = REXML::XPath.first(rootelement, "imageId").text
-      
-      # Handle launchPermission attributes:
-      rootelement.elements.each("launchPermission/item/*") do |element|
-        lines << [
-                  "launchPermission",
-                  imageId,
-                  element.name,
-                  element.text
-                 ]
+        }
+        return obj
+      elsif (obj.kind_of?(Hash))
+        # Hashes make good Responses already thanks to OpenStruct.
+        return Response.new(obj, parent)
+      elsif (obj.kind_of?(Array))
+        # With arrays, make sure each element is appropriately converted.
+        new_arr = []
+        obj.each { |elem|
+          new_arr << convert(elem, parent)
+        }
+        return new_arr
+      else
+        # At this point we're out of ideas, so let's hope it is a string.
+        return obj
       end
-      lines
     end
-  end
-
-# end EC2 Module
-end
 
+  end  # class Response < OpenStruct
+  
+end  # module EC2