krisr-amazon-ec2 0.5.0

data/Rakefile

@@ -0,0 +1,101 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "amazon-ec2"
+    gem.summary = %Q{Amazon EC2 Ruby Gem}
+    gem.description = %Q{An interface library that allows Ruby applications to easily connect to the HTTP 'Query API' for the Amazon Web Services Elastic Compute Cloud (EC2) and manipulate cloud servers.}
+    gem.email = "glenn@rempe.us"
+    gem.homepage = "http://github.com/grempe/amazon-ec2"
+    gem.authors = ["Glenn Rempe"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+
+#    gem.autorequire = 'EC2'
+    gem.rdoc_options = ["--quiet", "--title", "amazon-ec2 documentation", "--opname", "index.html", "--line-numbers", "--main", "README.rdoc", "--inline-source"]
+
+    gem.rubyforge_project = 'amazon-ec2'
+
+    gem.add_dependency('xml-simple', '>= 1.0.12')
+    gem.add_development_dependency('mocha', '>= 0.9.5')
+    gem.add_development_dependency('test-spec', '>= 0.10.0')
+    gem.add_development_dependency('rcov', '>= 0.8.1.2.0')
+    gem.add_development_dependency('perftools.rb', '= 0.1.6')
+
+  end
+
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "amazon-ec2 #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+begin
+  require 'rake/contrib/sshpublisher'
+  namespace :rubyforge do
+
+    desc "Release gem and RDoc documentation to RubyForge"
+    task :release => ["rubyforge:release:gem", "rubyforge:release:docs"]
+
+    namespace :release do
+      desc "Publish RDoc to RubyForge."
+      task :docs => [:rdoc] do
+        config = YAML.load(
+            File.read(File.expand_path('~/.rubyforge/user-config.yml'))
+        )
+
+        host = "#{config['username']}@rubyforge.org"
+        remote_dir = "/var/www/gforge-projects/amazon-ec2/"
+        local_dir = 'rdoc'
+
+        Rake::SshDirPublisher.new(host, remote_dir, local_dir).upload
+      end
+    end
+  end
+rescue LoadError
+  puts "Rake SshDirPublisher is unavailable or your rubyforge environment is not configured."
+end
+
+desc "Generate a perftools.rb profile"
+task :profile do
+  system("CPUPROFILE=perftools/ec2prof RUBYOPT='-r/usr/local/lib/ruby/gems/1.8/gems/perftools.rb-0.1.6/lib/perftools.bundle' ruby -r'rubygems' bin/ec2-gem-profile.rb")
+  system("pprof.rb --text --ignore=Gem perftools/ec2prof > perftools/ec2prof-results.txt")
+  system("pprof.rb --dot --ignore=Gem perftools/ec2prof > perftools/ec2prof-results.dot")
+end

data/VERSION

@@ -0,0 +1 @@
+0.5.0

data/amazon-ec2.gemspec

@@ -0,0 +1,123 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{amazon-ec2}
+  s.version = "0.5.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Glenn Rempe"]
+  s.date = %q{2009-08-04}
+  s.description = %q{An interface library that allows Ruby applications to easily connect to the HTTP 'Query API' for the Amazon Web Services Elastic Compute Cloud (EC2) and manipulate cloud servers.}
+  s.email = %q{glenn@rempe.us}
+  s.executables = ["ec2-gem-example.rb", "ec2-gem-profile.rb", "ec2sh", "setup.rb"]
+  s.extra_rdoc_files = [
+    "ChangeLog",
+     "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "ChangeLog",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "amazon-ec2.gemspec",
+     "bin/ec2-gem-example.rb",
+     "bin/ec2-gem-profile.rb",
+     "bin/ec2sh",
+     "bin/setup.rb",
+     "deps.rip",
+     "lib/AWS.rb",
+     "lib/AWS/EC2.rb",
+     "lib/AWS/EC2/availability_zones.rb",
+     "lib/AWS/EC2/console.rb",
+     "lib/AWS/EC2/elastic_ips.rb",
+     "lib/AWS/EC2/image_attributes.rb",
+     "lib/AWS/EC2/images.rb",
+     "lib/AWS/EC2/instances.rb",
+     "lib/AWS/EC2/keypairs.rb",
+     "lib/AWS/EC2/products.rb",
+     "lib/AWS/EC2/security_groups.rb",
+     "lib/AWS/EC2/snapshots.rb",
+     "lib/AWS/EC2/volumes.rb",
+     "lib/AWS/ELB.rb",
+     "lib/AWS/ELB/load_balancers.rb",
+     "lib/AWS/exceptions.rb",
+     "lib/AWS/responses.rb",
+     "lib/EC2.rb",
+     "perftools/ec2prof",
+     "perftools/ec2prof-results.dot",
+     "perftools/ec2prof-results.txt",
+     "perftools/ec2prof.symbols",
+     "test/test_EC2.rb",
+     "test/test_EC2_availability_zones.rb",
+     "test/test_EC2_console.rb",
+     "test/test_EC2_elastic_ips.rb",
+     "test/test_EC2_image_attributes.rb",
+     "test/test_EC2_images.rb",
+     "test/test_EC2_instances.rb",
+     "test/test_EC2_keypairs.rb",
+     "test/test_EC2_products.rb",
+     "test/test_EC2_responses.rb",
+     "test/test_EC2_s3_xmlsimple.rb",
+     "test/test_EC2_security_groups.rb",
+     "test/test_EC2_snapshots.rb",
+     "test/test_EC2_volumes.rb",
+     "test/test_ELB_load_balancers.rb",
+     "test/test_helper.rb",
+     "wsdl/2007-08-29.ec2.wsdl",
+     "wsdl/2008-02-01.ec2.wsdl",
+     "wsdl/2008-05-05.ec2.wsdl",
+     "wsdl/2008-12-01.ec2.wsdl"
+  ]
+  s.homepage = %q{http://github.com/grempe/amazon-ec2}
+  s.rdoc_options = ["--quiet", "--title", "amazon-ec2 documentation", "--opname", "index.html", "--line-numbers", "--main", "README.rdoc", "--inline-source"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{amazon-ec2}
+  s.rubygems_version = %q{1.3.4}
+  s.summary = %q{Amazon EC2 Ruby Gem}
+  s.test_files = [
+    "test/test_EC2.rb",
+     "test/test_EC2_availability_zones.rb",
+     "test/test_EC2_console.rb",
+     "test/test_EC2_elastic_ips.rb",
+     "test/test_EC2_image_attributes.rb",
+     "test/test_EC2_images.rb",
+     "test/test_EC2_instances.rb",
+     "test/test_EC2_keypairs.rb",
+     "test/test_EC2_products.rb",
+     "test/test_EC2_responses.rb",
+     "test/test_EC2_s3_xmlsimple.rb",
+     "test/test_EC2_security_groups.rb",
+     "test/test_EC2_snapshots.rb",
+     "test/test_EC2_volumes.rb",
+     "test/test_ELB_load_balancers.rb",
+     "test/test_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<xml-simple>, [">= 1.0.12"])
+      s.add_development_dependency(%q<mocha>, [">= 0.9.5"])
+      s.add_development_dependency(%q<test-spec>, [">= 0.10.0"])
+      s.add_development_dependency(%q<rcov>, [">= 0.8.1.2.0"])
+      s.add_development_dependency(%q<perftools.rb>, ["= 0.1.6"])
+    else
+      s.add_dependency(%q<xml-simple>, [">= 1.0.12"])
+      s.add_dependency(%q<mocha>, [">= 0.9.5"])
+      s.add_dependency(%q<test-spec>, [">= 0.10.0"])
+      s.add_dependency(%q<rcov>, [">= 0.8.1.2.0"])
+      s.add_dependency(%q<perftools.rb>, ["= 0.1.6"])
+    end
+  else
+    s.add_dependency(%q<xml-simple>, [">= 1.0.12"])
+    s.add_dependency(%q<mocha>, [">= 0.9.5"])
+    s.add_dependency(%q<test-spec>, [">= 0.10.0"])
+    s.add_dependency(%q<rcov>, [">= 0.8.1.2.0"])
+    s.add_dependency(%q<perftools.rb>, ["= 0.1.6"])
+  end
+end

data/bin/ec2-gem-example.rb

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby
+
+# Amazon Web Services EC2 Query API Ruby library
+#
+# Ruby Gem Name::  amazon-ec2
+# Author::    Glenn Rempe  (mailto:glenn@rempe.us)
+# Copyright:: Copyright (c) 2007-2008 Glenn Rempe
+# License::   Distributes under the same terms as Ruby
+# Home::      http://github.com/grempe/amazon-ec2/tree/master
+#++
+
+require File.dirname(__FILE__) + '/../lib/AWS'
+require 'pp'
+
+# pull these from the local shell environment variables set in ~/.bash_login
+# or using appropriate methods specific to your login shell.
+#
+# e.g. in ~/.bash_login
+#
+#  # For amazon-ec2 and amazon s3 ruby gems
+#  export AMAZON_ACCESS_KEY_ID="FOO"
+#  export AMAZON_SECRET_ACCESS_KEY="BAR"
+
+ACCESS_KEY_ID = ENV['AMAZON_ACCESS_KEY_ID']
+SECRET_ACCESS_KEY = ENV['AMAZON_SECRET_ACCESS_KEY']
+
+if ACCESS_KEY_ID.nil? || ACCESS_KEY_ID.empty?
+  puts "Error : You must add the shell environment variables AMAZON_ACCESS_KEY_ID and AMAZON_SECRET_ACCESS_KEY before calling #{$0}!"
+  exit
+end
+
+# us-east-1.ec2.amazonaws.com == ec2.amazonaws.com
+# eu-west-1.ec2.amazonaws.com for the european region
+# test different servers by running something like:
+# export EC2_URL='https://ec2.amazonaws.com';./bin/ec2-gem-example.rb
+if ENV['EC2_URL']
+  ec2 = AWS::EC2::Base.new( :access_key_id => ACCESS_KEY_ID, :secret_access_key => SECRET_ACCESS_KEY, :server => URI.parse(ENV['EC2_URL']).host )
+else
+  # default server is US ec2.amazonaws.com
+  ec2 = AWS::EC2::Base.new( :access_key_id => ACCESS_KEY_ID, :secret_access_key => SECRET_ACCESS_KEY )
+end
+
+puts "----- ec2.methods.sort -----"
+p ec2.methods.sort
+
+puts "----- listing images owned by 'amazon' -----"
+ec2.describe_images(:owner_id => "amazon").imagesSet.item.each do |image|
+  image.keys.each do |key|
+    puts "#{key} => #{image[key]}"
+  end
+end
+
+puts "----- listing all running instances -----"
+pp ec2.describe_instances()
+
+puts "----- creating a security group -----"
+pp ec2.create_security_group(:group_name => "ec2-example-rb-test-group", :group_description => "ec-example.rb test group description.")
+
+puts "----- listing security groups -----"
+pp ec2.describe_security_groups()
+
+puts "----- deleting a security group -----"
+pp ec2.delete_security_group(:group_name => "ec2-example-rb-test-group")
+
+puts "----- listing my keypairs (verbose mode) -----"
+pp ec2.describe_keypairs()

data/bin/ec2-gem-profile.rb

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+# Basic single command application that we can call with perftools.rb to get consistent results.
+
+require File.dirname(__FILE__) + '/../lib/AWS'
+ACCESS_KEY_ID = ENV['AMAZON_ACCESS_KEY_ID']
+SECRET_ACCESS_KEY = ENV['AMAZON_SECRET_ACCESS_KEY']
+ec2 = AWS::EC2::Base.new( :access_key_id => ACCESS_KEY_ID, :secret_access_key => SECRET_ACCESS_KEY )
+@images = ec2.describe_images
+

data/bin/ec2sh

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby
+
+# Amazon Web Services EC2 Query API Ruby library
+#
+# Ruby Gem Name::  amazon-ec2
+# Author::    Glenn Rempe  (mailto:glenn@rempe.us)
+# Copyright:: Copyright (c) 2007-2008 Glenn Rempe
+# License::   Distributes under the same terms as Ruby
+# Home::      http://github.com/grempe/amazon-ec2/tree/master
+#++
+
+# CREDITS : Credit for this bit of shameful ripoff coolness
+# goes to Marcel Molina and his AWS::S3 gem.  Thanks!
+
+# Usage : running this starts up an irb session and
+# sets up the connection to EC2 as a class variable called
+# '@ec2'.  So just do something like the following on the
+# shell command line:
+
+#   macbook-pro:~ glenn$ ec2sh
+#   >> @ec2.describe_images
+#   => [#<AWS::EC2::Item image_location...
+
+aws_lib   = File.dirname(__FILE__) + '/../lib/AWS'
+setup = File.dirname(__FILE__) + '/setup'
+irb_name = RUBY_PLATFORM =~ /mswin32/ ? 'irb.bat' : 'irb'
+
+if ( ENV['AMAZON_ACCESS_KEY_ID'] && ENV['AMAZON_SECRET_ACCESS_KEY'] )
+
+  welcome_message = <<-MESSAGE
+
+  'ec2sh' usage :
+  This is an interactive 'irb' command shell that allows you to use all
+  commands available to the amazon-ec2 gem.  You'll find this to be a
+  great tool to help you debug issues and practice running commands
+  against the live EC2 servers prior to putting them in your code.
+
+  The EC2 connection is wired to the class instance '@ec2'.  Make method calls
+  on this to execute commands on EC2.  Adding a #to_s
+  at the end of any command should give you a full String representation of the
+  response.
+
+    Examples to try:
+
+      returns : all ec2 public methods
+      >> @ec2.methods.sort
+
+      returns : a string representation of ALL images
+      >> @ec2.describe_images.to_s
+
+      returns : an Array of AWS::Response objects, each an EC2 image and its data
+      >> @ec2.describe_images.imagesSet.item
+      >> @ec2.describe_images.imagesSet.item[0] (a hash representing a single item in that array)
+      >> @ec2.describe_images.imagesSet.item[0].to_s (a String representation of that item)
+
+  MESSAGE
+
+  puts welcome_message
+  exec "#{irb_name} -r #{aws_lib} -r #{setup} --simple-prompt"
+else
+  puts "You must define AMAZON_ACCESS_KEY_ID and AMAZON_SECRET_ACCESS_KEY as shell environment variables before running #{$0}!"
+end

data/bin/setup.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+
+# Amazon Web Services EC2 Query API Ruby library
+#
+# Ruby Gem Name::  amazon-ec2
+# Author::    Glenn Rempe  (mailto:glenn@rempe.us)
+# Copyright:: Copyright (c) 2007-2008 Glenn Rempe
+# License::   Distributes under the same terms as Ruby
+# Home::      http://github.com/grempe/amazon-ec2/tree/master
+#++
+
+if ENV['AMAZON_ACCESS_KEY_ID'] && ENV['AMAZON_SECRET_ACCESS_KEY']
+  opts = {
+    :access_key_id => ENV['AMAZON_ACCESS_KEY_ID'],
+    :secret_access_key => ENV['AMAZON_SECRET_ACCESS_KEY']
+  }
+  if ENV['EC2_URL']
+    opts[:server] = URI.parse(ENV['EC2_URL']).host
+  end
+  @ec2 = AWS::EC2::Base.new(opts)
+  @elb = AWS::ELB::Base.new(opts)
+end
+
+puts "EC2 Server: #{opts[:server]}"
+
+include AWS

data/deps.rip

@@ -0,0 +1 @@
+xml-simple 1.0.12 

data/lib/AWS.rb

@@ -0,0 +1,239 @@
+# Require any lib files that we have bundled with this Ruby Gem in the lib/AWS directory.
+# Parts of the AWS module and Base class are broken out into separate
+# files for maintainability and are organized by the functional groupings defined
+# in the AWS API developers guide.
+
+
+%w[ base64 cgi openssl digest/sha1 net/https rexml/document time ostruct ].each { |f| require f }
+
+module AWS
+  # Builds the canonical string for signing. This strips out all '&', '?', and '='
+  # from the query string to be signed.
+  #   Note:  The parameters in the path passed in must already be sorted in
+  #   case-insensitive alphabetical order and must not be url encoded.
+  def AWS.canonical_string(params, host, method="POST", base="/")
+    # Sort, and encode parameters into a canonical string.
+    sorted_params = params.sort {|x,y| x[0] <=> y[0]}
+    encoded_params = sorted_params.collect do |p|
+      encoded = (CGI::escape(p[0].to_s) +
+                 "=" + CGI::escape(p[1].to_s))
+      # Ensure spaces are encoded as '%20', not '+'
+      encoded.gsub('+', '%20')
+    end
+    sigquery = encoded_params.join("&")
+
+    # Generate the request description string
+    req_desc =
+      method + "\n" +
+      host + "\n" +
+      base + "\n" +
+      sigquery
+
+  end
+
+  # Encodes the given string with the secret_access_key, by taking the
+  # hmac-sha1 sum, and then base64 encoding it.  Optionally, it will also
+  # url encode the result of that to protect the string if it's going to
+  # be used as a query string parameter.
+  def AWS.encode(secret_access_key, str, urlencode=true)
+    digest = OpenSSL::Digest::Digest.new('sha1')
+    b64_hmac =
+      Base64.encode64(
+        OpenSSL::HMAC.digest(digest, secret_access_key, str)).gsub("\n","")
+
+    if urlencode
+      return CGI::escape(b64_hmac)
+    else
+      return b64_hmac
+    end
+  end
+  
+  class Base
+
+    attr_reader :use_ssl, :server, :proxy_server, :port
+
+    def initialize( options = {} )
+
+      options = { :access_key_id => "",
+                  :secret_access_key => "",
+                  :use_ssl => true,
+                  :server => default_host,
+                  :proxy_server => nil
+                  }.merge(options)
+
+      @server = options[:server]
+      @proxy_server = options[:proxy_server]
+      @use_ssl = options[:use_ssl]
+
+      raise ArgumentError, "No :access_key_id provided" if options[:access_key_id].nil? || options[:access_key_id].empty?
+      raise ArgumentError, "No :secret_access_key provided" if options[:secret_access_key].nil? || options[:secret_access_key].empty?
+      raise ArgumentError, "No :use_ssl value provided" if options[:use_ssl].nil?
+      raise ArgumentError, "Invalid :use_ssl value provided, only 'true' or 'false' allowed" unless options[:use_ssl] == true || options[:use_ssl] == false
+      raise ArgumentError, "No :server provided" if options[:server].nil? || options[:server].empty?
+      
+      if options[:port]
+        # user-specified port
+        @port = options[:port]
+      elsif @use_ssl
+        # https
+        @port = 443
+      else
+        # http
+        @port = 80
+      end
+
+      @access_key_id = options[:access_key_id]
+      @secret_access_key = options[:secret_access_key]
+
+      # Use proxy server if defined
+      # Based on patch by Mathias Dalheimer.  20070217
+      proxy = @proxy_server ? URI.parse(@proxy_server) : OpenStruct.new
+      @http = Net::HTTP::Proxy( proxy.host,
+                                proxy.port,
+                                proxy.user,
+                                proxy.password).new(options[:server], @port)
+
+      @http.use_ssl = @use_ssl
+
+      # Don't verify the SSL certificates.  Avoids SSL Cert warning in log on every GET.
+      @http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+    end
+
+
+    protected
+
+      # pathlist is a utility method which takes a key string and and array as input.
+      # It converts the array into a Hash with the hash key being 'Key.n' where
+      # 'n' increments by 1 for each iteration.  So if you pass in args
+      # ("ImageId", ["123", "456"]) you should get
+      # {"ImageId.1"=>"123", "ImageId.2"=>"456"} returned.
+      def pathlist(key, arr)
+        params = {}
+        arr.each_with_index do |value, i|
+          params["#{key}.#{i+1}"] = value
+        end
+        params
+      end
+      
+      # Same as _pathlist_ except it deals with arrays of hashes.
+      # So if you pass in args
+      # ("People", [{:name=>'jon', :age=>'22'}, {:name=>'chris'}], {:name => 'Name', :age => 'Age'}) you should get
+      # {"People.1.Name"=>"jon", "People.1.Age"=>'22', 'People.2.Name'=>'chris'}
+      def pathhashlist(key, arr_of_hashes, mappings)
+        params ={}
+        arr_of_hashes.each_with_index do |hash, i|
+          hash.each do |attribute, value|
+            params["#{key}.#{i+1}.#{mappings[attribute]}"] = value
+          end
+        end
+        params
+      end
+
+      # Make the connection to AWS EC2 passing in our request.  This is generally called from
+      # within a 'Response' class object or one of its sub-classes so the response is interpreted
+      # in its proper context.  See lib/EC2/responses.rb
+      def make_request(action, params, data='')
+
+        @http.start do
+
+          # remove any keys that have nil or empty values
+          params.reject! { |key, value| value.nil? or value.empty?}
+
+          params.merge!( {"Action" => action,
+                          "SignatureVersion" => "2",
+                          "SignatureMethod" => 'HmacSHA1',
+                          "AWSAccessKeyId" => @access_key_id,
+                          "Version" => api_version,
+                          "Timestamp"=>Time.now.getutc.iso8601} )
+
+          sig = get_aws_auth_param(params, @secret_access_key, @server)
+
+          query = params.sort.collect do |param|
+            CGI::escape(param[0]) + "=" + CGI::escape(param[1])
+          end.join("&") + "&Signature=" + sig
+
+          req = Net::HTTP::Post.new("/")
+          req.content_type = 'application/x-www-form-urlencoded'
+          req['User-Agent'] = "github-amazon-ec2-ruby-gem"
+          response = @http.request(req, query)
+
+          # Make a call to see if we need to throw an error based on the response given by EC2
+          # All error classes are defined in EC2/exceptions.rb
+          aws_error?(response)
+
+          return response
+
+        end
+
+      end
+
+      # Set the Authorization header using AWS signed header authentication
+      def get_aws_auth_param(params, secret_access_key, server)
+        canonical_string =  AWS.canonical_string(params, server)
+        encoded_canonical = AWS.encode(secret_access_key, canonical_string)
+      end
+
+      # allow us to have a one line call in each method which will do all of the work
+      # in making the actual request to AWS.
+      def response_generator( options = {} )
+
+        options = {
+          :action => "",
+          :params => {}
+        }.merge(options)
+
+        raise ArgumentError, ":action must be provided to response_generator" if options[:action].nil? || options[:action].empty?
+
+        http_response = make_request(options[:action], options[:params])
+        http_xml = http_response.body
+        return Response.parse(:xml => http_xml)
+
+      end
+
+      # Raises the appropriate error if the specified Net::HTTPResponse object
+      # contains an Amazon EC2 error; returns +false+ otherwise.
+      def aws_error?(response)
+
+        # return false if we got a HTTP 200 code,
+        # otherwise there is some type of error (40x,50x) and
+        # we should try to raise an appropriate exception
+        # from one of our exception classes defined in
+        # exceptions.rb
+        return false if response.is_a?(Net::HTTPSuccess)
+        
+        # parse the XML document so we can walk through it
+        doc = REXML::Document.new(response.body)
+
+        # Check that the Error element is in the place we would expect.
+        # and if not raise a generic error exception
+        if doc.root.elements['Error']
+          error_element = doc.root.elements['Error']
+        elsif doc.root.elements['Errors'] && doc.root.elements['Errors'].elements['Error'] && doc.root.elements['Errors'].elements['Error'].name == 'Error'
+          error_element = doc.root.elements['Errors'].elements['Error']
+        else
+          raise Error, "Unexpected error format. response.body is: #{response.body}"
+        end
+
+        # An valid error response looks like this:
+        # <?xml version="1.0"?><Response><Errors><Error><Code>InvalidParameterCombination</Code><Message>Unknown parameter: foo</Message></Error></Errors><RequestID>291cef62-3e86-414b-900e-17246eccfae8</RequestID></Response>
+        # AWS EC2 throws some exception codes that look like Error.SubError.  Since we can't name classes this way
+        # we need to strip out the '.' in the error 'Code' and we name the error exceptions with this
+        # non '.' name as well.
+        error_code    = error_element.elements['Code'].text.gsub('.', '')
+        error_message = error_element.elements['Message'].text
+
+        # Raise one of our specific error classes if it exists.
+        # otherwise, throw a generic EC2 Error with a few details.
+        if AWS.const_defined?(error_code)
+          raise AWS.const_get(error_code), error_message
+        else
+          raise AWS::Error, error_message
+        end
+
+      end
+
+  end
+end
+
+Dir[File.join(File.dirname(__FILE__), 'AWS/*.rb')].sort.each { |lib| require lib }