awsum 0.5

data/.autotest

@@ -0,0 +1 @@
+require 'autotest/redgreen'

data/.gitignore

@@ -0,0 +1,5 @@
+doc
+*.swp
+coverage
+.bundle/
+pkg/

data/.rspec

@@ -0,0 +1 @@
+--colour

data/Gemfile

@@ -0,0 +1,15 @@
+source "http://rubygems.org"
+
+gem "rake"
+gem "bundler", "~> 1.0.0"
+
+group :development do
+  gem "jeweler"
+  gem "rspec", ">= 2.0.0.beta.22"
+  gem "fakeweb"
+
+  gem "shoulda"
+  gem "mocha"
+  gem "rcov"
+  gem "timecop"
+end

data/Gemfile.lock

@@ -0,0 +1,44 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.2)
+    fakeweb (1.2.8)
+    gemcutter (0.6.1)
+    git (1.2.5)
+    jeweler (1.4.0)
+      gemcutter (>= 0.1.0)
+      git (>= 1.2.5)
+      rubyforge (>= 2.0.0)
+    json_pure (1.4.6)
+    mocha (0.9.8)
+      rake
+    rake (0.8.7)
+    rcov (0.9.9)
+    rspec (2.0.0.beta.22)
+      rspec-core (= 2.0.0.beta.22)
+      rspec-expectations (= 2.0.0.beta.22)
+      rspec-mocks (= 2.0.0.beta.22)
+    rspec-core (2.0.0.beta.22)
+    rspec-expectations (2.0.0.beta.22)
+      diff-lcs (>= 1.1.2)
+    rspec-mocks (2.0.0.beta.22)
+      rspec-core (= 2.0.0.beta.22)
+      rspec-expectations (= 2.0.0.beta.22)
+    rubyforge (2.0.4)
+      json_pure (>= 1.1.7)
+    shoulda (2.11.3)
+    timecop (0.3.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  fakeweb
+  jeweler
+  mocha
+  rake
+  rcov
+  rspec (>= 2.0.0.beta.22)
+  shoulda
+  timecop

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2009 Internuity Ltd, Andrew Timberlake <andrew@andrewtimberlake.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,42 @@
+=Awsum
+
+Awsum (Pronounced Awesome) is a library for working with Amazon web services.
+The concept of Awsum is to expose the AWS library is the most ruby way possible
+allowing you to work with objects in a very natural way.
+
+==Quick Start
+
+  #Create a snapshot for every volume of every instance you own
+  ec2 = Awsum::Ec2.new(<access key>, <secret key>)
+  ec2.instances.each do |instance|
+    instance.volumes.each do |volume|
+      volume.create_snapshot
+    end
+  end
+
+==Working with different Regions
+You can use blocks to wrap your calls for a specific Region
+  ec2.region('eu-west-1').use do
+    #Run an instance in the eu-west-1 region
+    run_instance(...)
+  end
+
+==Using the library on an EC2 instance
+
+There are two methods specifically for using a library on an EC2 instance
+  Awsum::Ec2#me
+  Awsum::Ec2#user_data
+
+To extend the quick start example, you could do
+
+  #Create a snapshot of every volume of the currently running instance
+  ec2 = Awsum::Ec2.new(<access key>, <secret key>)
+  ec2.me.volumes.each do |volume|
+    volume.create_snapshot
+  end
+
+==Note:
+
+Awsum is currently under active development and only supports EC2 at the moment.
+
+Once EC2 is complete, I will focus on S3, SQS, CloudSpace and then others

data/Rakefile

@@ -0,0 +1,75 @@
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'rake/rdoctask'
+require 'rake/testtask'
+
+$LOAD_PATH.unshift('lib')
+require 'awsum'
+
+begin
+  require 'jeweler'
+
+  Jeweler::Tasks.new do |gem|
+    gem.name     = 'awsum'
+    gem.summary  = 'A library for working with Amazon Web Services in the most natural rubyish way'
+    gem.email    = 'andrew@andrewtimberlake.com'
+    gem.homepage = 'http://andrewtimberlake.com/projects/awsum'
+    gem.authors  = ['Andrew Timberlake']
+    gem.version  = Awsum::VERSION
+
+    #gem.add_dependency
+    gem.add_development_dependency('rspec', '>= 2.0.0.beta.22')
+  end
+
+  Jeweler::GemcutterTasks.new
+
+  task :default => :spec
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end
+
+desc 'Run code coverage'
+task :coverage do |t|
+  puts `rcov -T #{Dir.glob('test/**/test_*.rb').join(' ')}`
+end
+
+desc 'Start an IRB session with all necessary files required.'
+task :shell do |t|
+  chdir File.dirname(__FILE__)
+  exec 'irb -I lib/ -I lib/awsum -r rubygems -r awsum'
+end
+
+desc 'Generate documentation.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title    = 'AWSum'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc 'Clean up files.'
+task :clean do |t|
+  FileUtils.rm_rf "doc"
+  FileUtils.rm_rf "tmp"
+  FileUtils.rm_rf "pkg"
+end
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = "./spec/lib/**/*_spec.rb"
+end
+
+namespace :spec do
+  desc "Run RSpec integration code examples (LIVE runs against Amazon AWS)"
+  RSpec::Core::RakeTask.new(:integration) do |t|
+    t.pattern = "./spec/functional/**/*_spec.rb"
+  end
+end

data/awsum.gemspec

@@ -0,0 +1,199 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{awsum}
+  s.version = "0.5"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Andrew Timberlake"]
+  s.date = %q{2010-09-19}
+  s.email = %q{andrew@andrewtimberlake.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".autotest",
+     ".gitignore",
+     ".rspec",
+     "Gemfile",
+     "Gemfile.lock",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "awsum.gemspec",
+     "lib/awsum.rb",
+     "lib/awsum/ec2.rb",
+     "lib/awsum/ec2/address.rb",
+     "lib/awsum/ec2/availability_zone.rb",
+     "lib/awsum/ec2/image.rb",
+     "lib/awsum/ec2/instance.rb",
+     "lib/awsum/ec2/keypair.rb",
+     "lib/awsum/ec2/parsers/address_parser.rb",
+     "lib/awsum/ec2/parsers/availability_zone_parser.rb",
+     "lib/awsum/ec2/parsers/image_parser.rb",
+     "lib/awsum/ec2/parsers/instance_parser.rb",
+     "lib/awsum/ec2/parsers/keypair_parser.rb",
+     "lib/awsum/ec2/parsers/purchase_reserved_instances_offering_parser.rb",
+     "lib/awsum/ec2/parsers/region_parser.rb",
+     "lib/awsum/ec2/parsers/register_image_parser.rb",
+     "lib/awsum/ec2/parsers/reserved_instance_parser.rb",
+     "lib/awsum/ec2/parsers/reserved_instances_offering_parser.rb",
+     "lib/awsum/ec2/parsers/security_group_parser.rb",
+     "lib/awsum/ec2/parsers/snapshot_parser.rb",
+     "lib/awsum/ec2/parsers/volume_parser.rb",
+     "lib/awsum/ec2/region.rb",
+     "lib/awsum/ec2/reserved_instance.rb",
+     "lib/awsum/ec2/reserved_instances_offering.rb",
+     "lib/awsum/ec2/security_group.rb",
+     "lib/awsum/ec2/snapshot.rb",
+     "lib/awsum/ec2/volume.rb",
+     "lib/awsum/error.rb",
+     "lib/awsum/net_fix.rb",
+     "lib/awsum/parser.rb",
+     "lib/awsum/requestable.rb",
+     "lib/awsum/s3.rb",
+     "lib/awsum/s3/bucket.rb",
+     "lib/awsum/s3/headers.rb",
+     "lib/awsum/s3/object.rb",
+     "lib/awsum/s3/parsers/bucket_parser.rb",
+     "lib/awsum/support.rb",
+     "spec/fixtures/ec2/addresses.xml",
+     "spec/fixtures/ec2/allocate_address.xml",
+     "spec/fixtures/ec2/associate_address.xml",
+     "spec/fixtures/ec2/attach_volume.xml",
+     "spec/fixtures/ec2/authorize_ip_access.xml",
+     "spec/fixtures/ec2/authorize_owner_group_access.xml",
+     "spec/fixtures/ec2/authorize_owner_group_access_error.xml",
+     "spec/fixtures/ec2/availability_zones.xml",
+     "spec/fixtures/ec2/available_volume.xml",
+     "spec/fixtures/ec2/create_key_pair.xml",
+     "spec/fixtures/ec2/create_security_group.xml",
+     "spec/fixtures/ec2/create_snapshot.xml",
+     "spec/fixtures/ec2/create_volume.xml",
+     "spec/fixtures/ec2/delete_key_pair.xml",
+     "spec/fixtures/ec2/delete_security_group.xml",
+     "spec/fixtures/ec2/delete_snapshot.xml",
+     "spec/fixtures/ec2/delete_volume.xml",
+     "spec/fixtures/ec2/deregister_image.xml",
+     "spec/fixtures/ec2/detach_volume.xml",
+     "spec/fixtures/ec2/disassociate_address.xml",
+     "spec/fixtures/ec2/image.xml",
+     "spec/fixtures/ec2/images.xml",
+     "spec/fixtures/ec2/instance.xml",
+     "spec/fixtures/ec2/instances.xml",
+     "spec/fixtures/ec2/internal_error.xml",
+     "spec/fixtures/ec2/invalid_amiid_error.xml",
+     "spec/fixtures/ec2/invalid_request_error.xml",
+     "spec/fixtures/ec2/key_pairs.xml",
+     "spec/fixtures/ec2/purchase_reserved_instances_offering.xml",
+     "spec/fixtures/ec2/purchase_reserved_instances_offerings.xml",
+     "spec/fixtures/ec2/regions.xml",
+     "spec/fixtures/ec2/register_image.xml",
+     "spec/fixtures/ec2/release_address.xml",
+     "spec/fixtures/ec2/reserved_instances.xml",
+     "spec/fixtures/ec2/reserved_instances_offering.xml",
+     "spec/fixtures/ec2/reserved_instances_offerings.xml",
+     "spec/fixtures/ec2/revoke_ip_access.xml",
+     "spec/fixtures/ec2/revoke_owner_group_access.xml",
+     "spec/fixtures/ec2/run_instances.xml",
+     "spec/fixtures/ec2/security_groups.xml",
+     "spec/fixtures/ec2/snapshots.xml",
+     "spec/fixtures/ec2/terminate_instances.xml",
+     "spec/fixtures/ec2/unassociated_address.xml",
+     "spec/fixtures/ec2/volumes.xml",
+     "spec/fixtures/errors/invalid_parameter_value.xml",
+     "spec/fixtures/s3/buckets.xml",
+     "spec/fixtures/s3/copy_failure.xml",
+     "spec/fixtures/s3/invalid_request_signature.xml",
+     "spec/fixtures/s3/keys.xml",
+     "spec/lib/awsum/ec2/address_spec.rb",
+     "spec/lib/awsum/ec2/availability_zones_spec.rb",
+     "spec/lib/awsum/ec2/image_spec.rb",
+     "spec/lib/awsum/ec2/instance_spec.rb",
+     "spec/lib/awsum/ec2/keypair_spec.rb",
+     "spec/lib/awsum/ec2/parsers/address_parser_spec.rb",
+     "spec/lib/awsum/ec2/parsers/availability_zone_parser_spec.rb",
+     "spec/lib/awsum/ec2/parsers/image_parser_spec.rb",
+     "spec/lib/awsum/ec2/parsers/instance_parser_spec.rb",
+     "spec/lib/awsum/ec2/parsers/keypair_parser_spec.rb",
+     "spec/lib/awsum/ec2/parsers/purchase_reserved_instances_offering_parser_spec.rb",
+     "spec/lib/awsum/ec2/parsers/region_parser_spec.rb",
+     "spec/lib/awsum/ec2/parsers/register_image_parser_spec.rb",
+     "spec/lib/awsum/ec2/parsers/reserved_instance_parser_spec.rb",
+     "spec/lib/awsum/ec2/parsers/reserved_instances_offering_parser_spec.rb",
+     "spec/lib/awsum/ec2/parsers/security_group_parser_spec.rb",
+     "spec/lib/awsum/ec2/parsers/snapshot_parser_spec.rb",
+     "spec/lib/awsum/ec2/parsers/volume_parser_spec.rb",
+     "spec/lib/awsum/ec2/region_spec.rb",
+     "spec/lib/awsum/ec2/reserved_instance_spec.rb",
+     "spec/lib/awsum/ec2/reserved_instances_offering_spec.rb",
+     "spec/lib/awsum/ec2/security_group_spec.rb",
+     "spec/lib/awsum/ec2/snapshots_spec.rb",
+     "spec/lib/awsum/ec2/volume_spec.rb",
+     "spec/lib/awsum/ec2_spec.rb",
+     "spec/lib/awsum/error_spec.rb",
+     "spec/lib/awsum/requestable_spec.rb",
+     "spec/lib/awsum/s3/bucket_spec.rb",
+     "spec/lib/awsum/s3/object_spec.rb",
+     "spec/lib/awsum/s3/parsers/bucket_parser_spec.rb",
+     "spec/lib/awsum/s3/parsers/object_parser_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://andrewtimberlake.com/projects/awsum}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{A library for working with Amazon Web Services in the most natural rubyish way}
+  s.test_files = [
+    "spec/lib/awsum/s3/parsers/object_parser_spec.rb",
+     "spec/lib/awsum/s3/parsers/bucket_parser_spec.rb",
+     "spec/lib/awsum/s3/object_spec.rb",
+     "spec/lib/awsum/s3/bucket_spec.rb",
+     "spec/lib/awsum/ec2/reserved_instance_spec.rb",
+     "spec/lib/awsum/ec2/region_spec.rb",
+     "spec/lib/awsum/ec2/availability_zones_spec.rb",
+     "spec/lib/awsum/ec2/parsers/register_image_parser_spec.rb",
+     "spec/lib/awsum/ec2/parsers/security_group_parser_spec.rb",
+     "spec/lib/awsum/ec2/parsers/image_parser_spec.rb",
+     "spec/lib/awsum/ec2/parsers/snapshot_parser_spec.rb",
+     "spec/lib/awsum/ec2/parsers/region_parser_spec.rb",
+     "spec/lib/awsum/ec2/parsers/availability_zone_parser_spec.rb",
+     "spec/lib/awsum/ec2/parsers/reserved_instance_parser_spec.rb",
+     "spec/lib/awsum/ec2/parsers/address_parser_spec.rb",
+     "spec/lib/awsum/ec2/parsers/purchase_reserved_instances_offering_parser_spec.rb",
+     "spec/lib/awsum/ec2/parsers/volume_parser_spec.rb",
+     "spec/lib/awsum/ec2/parsers/reserved_instances_offering_parser_spec.rb",
+     "spec/lib/awsum/ec2/parsers/keypair_parser_spec.rb",
+     "spec/lib/awsum/ec2/parsers/instance_parser_spec.rb",
+     "spec/lib/awsum/ec2/image_spec.rb",
+     "spec/lib/awsum/ec2/address_spec.rb",
+     "spec/lib/awsum/ec2/keypair_spec.rb",
+     "spec/lib/awsum/ec2/snapshots_spec.rb",
+     "spec/lib/awsum/ec2/volume_spec.rb",
+     "spec/lib/awsum/ec2/instance_spec.rb",
+     "spec/lib/awsum/ec2/security_group_spec.rb",
+     "spec/lib/awsum/ec2/reserved_instances_offering_spec.rb",
+     "spec/lib/awsum/ec2_spec.rb",
+     "spec/lib/awsum/error_spec.rb",
+     "spec/lib/awsum/requestable_spec.rb",
+     "spec/spec_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::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, [">= 2.0.0.beta.22"])
+    else
+      s.add_dependency(%q<rspec>, [">= 2.0.0.beta.22"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 2.0.0.beta.22"])
+  end
+end
+

data/lib/awsum.rb

@@ -0,0 +1,20 @@
+# AWSum is a library facilitating access to Amazon's web services in (hopefully)
+# a very object-oriented, ruby way.
+#
+# Author:: Andrew Timberlake
+# Copyright:: Copyright (c) 2009 Internuity Ltd
+# Licence:: MIT License (http://www.opensource.org/licenses/mit-license.php)
+#
+
+require 'awsum/parser'
+require 'awsum/requestable'
+require 'awsum/support'
+
+module Awsum
+  VERSION = "0.5"
+
+  API_VERSION = '2010-06-15'
+  SIGNATURE_VERSION = 2
+end
+
+

data/lib/awsum/ec2.rb

@@ -0,0 +1,741 @@
+require 'awsum'
+require 'awsum/ec2/address'
+require 'awsum/ec2/availability_zone'
+require 'awsum/ec2/image'
+require 'awsum/ec2/instance'
+require 'awsum/ec2/keypair'
+require 'awsum/ec2/region'
+require 'awsum/ec2/reserved_instance'
+require 'awsum/ec2/reserved_instances_offering'
+require 'awsum/ec2/security_group'
+require 'awsum/ec2/snapshot'
+require 'awsum/ec2/volume'
+
+module Awsum
+  # Handles all interaction with Amazon EC2
+  #
+  # ==Getting Started
+  # Create an Awsum::Ec2 object and begin calling methods on it.
+  #   require 'rubygems'
+  #   require 'awsum'
+  #   ec2 = Awsum::Ec2.new('your access id', 'your secret key')
+  #   images = ec2.my_images
+  #   ...
+  #
+  # All calls to EC2 can be done directly in this class, or through a more object oriented way through the various returned classes
+  #
+  # ==Examples
+  #   ec2.image('ami-ABCDEF').run
+  #
+  #   ec2.instance('i-123456789').volumes.each do |vol|
+  #     vol.create_snapsot
+  #   end
+  #
+  #   ec2.regions.each do |region|
+  #     region.use
+  #       images.each do |img|
+  #         puts "#{img.id} - #{region.name}"
+  #       end
+  #     end
+  #   end
+  #
+  # ==Errors
+  # All methods will raise an Awsum::Error if an error is returned from Amazon
+  #
+  # ==Missing Methods
+  # * ConfirmProductInstance
+  # * ModifyImageAttribute
+  # * DescribeImageAttribute
+  # * ResetImageAttribute
+  # If you need any of this functionality, please consider getting involved and help complete this library.
+  class Ec2
+    include Awsum::Requestable
+
+    # Create an new ec2 instance
+    #
+    # The access_key and secret_key are both required to do any meaningful work.
+    #
+    # If you want to get these keys from environment variables, you can do that in your code as follows:
+    #   ec2 = Awsum::Ec2.new(ENV['AWS_ACCESS_KEY_ID'], ENV['AWS_SECRET_ACCESS_KEY'])
+    def initialize(access_key = nil, secret_key = nil)
+      @access_key = access_key
+      @secret_key = secret_key
+    end
+
+    # Retrieve a list of available Images
+    #
+    # ===Options:
+    # * <tt>:image_ids</tt> - array of Image id's, default: []
+    # * <tt>:owners</tt> - array of owner id's, default: []
+    # * <tt>:executable_by</tt> - array of user id's who have executable permission, default: []
+    def images(options = {})
+      options = {:image_ids => [], :owners => [], :executable_by => []}.merge(options)
+      action = 'DescribeImages'
+      params = {
+          'Action' => action
+        }
+      #Add options
+      params.merge!(array_to_params(options[:image_ids], "ImageId"))
+      params.merge!(array_to_params(options[:owners], "Owner"))
+      params.merge!(array_to_params(options[:executable_by], "ExecutableBy"))
+
+      response = send_query_request(params)
+      parser = Awsum::Ec2::ImageParser.new(self)
+      parser.parse(response.body)
+    end
+
+    # Retrieve all Image(s) owned by you
+    def my_images
+      images :owners => 'self'
+    end
+
+    # Retrieve a single Image
+    def image(image_id)
+      images(:image_ids => [image_id])[0]
+    end
+
+    # Register an Image
+    def register_image(image_location)
+      action = 'RegisterImage'
+      params = {
+          'Action'        => action,
+          'ImageLocation' => image_location
+        }
+
+      response = send_query_request(params)
+      parser = Awsum::Ec2::RegisterImageParser.new(self)
+      parser.parse(response.body)
+    end
+
+    # Deregister an Image. Once deregistered, you can no longer launch the Image
+    def deregister_image(image_id)
+      action = 'DeregisterImage'
+      params = {
+          'Action'  => action,
+          'ImageId' => image_id
+        }
+
+      response = send_query_request(params)
+      response.is_a?(Net::HTTPSuccess)
+    end
+
+    # Launch an ec2 Instance
+    #
+    # ===Options:
+    # * <tt>:min</tt> - The minimum number of instances to launch. Default: 1
+    # * <tt>:max</tt> - The maximum number of instances to launch. Default: 1
+    # * <tt>:key_name</tt> - The name of the key pair with which to launch instances
+    # * <tt>:security_groups</tt> - The names of security groups to associate launched instances with
+    # * <tt>:user_data</tt> - User data made available to instances (Note: Must be 16K or less, will be base64 encoded by Awsum)
+    # * <tt>:instance_type</tt> - The size of the instances to launch, can be one of [m1.small, m1.large, m1.xlarge, c1.medium, c1.xlarge], default is m1.small
+    # * <tt>:availability_zone</tt> - The name of the availability zone to launch this Instance in
+    # * <tt>:kernel_id</tt> - The ID of the kernel with which to launch instances
+    # * <tt>:ramdisk_id</tt> - The ID of the RAM disk with which to launch instances
+    # * <tt>:block_device_map</tt> - A 'hash' of mappings. E.g. {'instancestore0' => 'sdb'}
+    def run_instances(image_id, options = {})
+      options = {:min => 1, :max => 1}.merge(options)
+      action = 'RunInstances'
+      params = {
+        'Action'                     => action,
+        'ImageId'                    => image_id,
+        'MinCount'                   => options[:min],
+        'MaxCount'                   => options[:max],
+        'KeyName'                    => options[:key_name],
+        'UserData'                   => options[:user_data].nil? ? nil : Base64::encode64(options[:user_data]).gsub(/\n/, ''),
+        'InstanceType'               => options[:instance_type],
+        'Placement.AvailabilityZone' => options[:availability_zone],
+        'KernelId'                   => options[:kernel_id],
+        'RamdiskId'                  => options[:ramdisk_id]
+      }
+      if options[:block_device_map].respond_to?(:keys)
+        map = options[:block_device_map]
+        map.keys.each_with_index do |key, i|
+          params["BlockDeviceMapping.#{i+1}.VirtualName"] = key
+          params["BlockDeviceMapping.#{i+1}.DeviceName"] = map[key]
+        end
+      else
+        raise ArgumentError.new("options[:block_device_map] - must be a key => value map") unless options[:block_device_map].nil?
+      end
+      params.merge!(array_to_params(options[:security_groups], "SecurityGroup"))
+
+      response = send_query_request(params)
+      parser = Awsum::Ec2::InstanceParser.new(self)
+      parser.parse(response.body)
+    end
+    alias_method :launch_instances, :run_instances
+
+    #Retrieve the information on a number of Instance(s)
+    def instances(*instance_ids)
+      action = 'DescribeInstances'
+      params = {
+        'Action' => action
+      }
+      params.merge!(array_to_params(instance_ids, 'InstanceId'))
+
+      response = send_query_request(params)
+      parser = Awsum::Ec2::InstanceParser.new(self)
+      parser.parse(response.body)
+    end
+
+    #Retrieve the information on a single Instance
+    def instance(instance_id)
+      instances([instance_id])[0]
+    end
+
+    # Retrieves the currently running Instance
+    # This should only be run on a running EC2 instance
+    def me
+      require 'open-uri'
+      begin
+        instance_id = open('http://169.254.169.254/latest/meta-data/instance-id').read
+        instance instance_id
+      rescue OpenURI::HTTPError => e
+        nil
+      end
+    end
+
+    # Retreives the user-data supplied when starting the currently running Instance
+    # This should only be run on a running EC2 instance
+    def user_data
+      require 'open-uri'
+      begin
+        open('http://169.254.169.254/latest/user-data').read
+      rescue OpenURI::HTTPError => e
+        nil
+      end
+    end
+
+    # Terminates the Instance(s)
+    #
+    # Returns true if the terminations succeeds, false otherwise
+    def terminate_instances(*instance_ids)
+      action = 'TerminateInstances'
+      params = {
+        'Action' => action
+      }
+      params.merge!(array_to_params(instance_ids, 'InstanceId'))
+
+      response = send_query_request(params)
+      response.is_a?(Net::HTTPSuccess)
+    end
+
+    #Retrieve the information on a number of Volume(s)
+    def volumes(*volume_ids)
+      action = 'DescribeVolumes'
+      params = {
+        'Action' => action
+      }
+      params.merge!(array_to_params(volume_ids, 'VolumeId'))
+
+      response = send_query_request(params)
+      parser = Awsum::Ec2::VolumeParser.new(self)
+      parser.parse(response.body)
+    end
+
+    # Retreive information on a Volume
+    def volume(volume_id)
+      volumes(volume_id)[0]
+    end
+
+    # Create a new volume
+    #
+    # ===Options:
+    # * <tt>:size</tt> - The size of the volume to be created (in GB) (<b>NOTE:</b> Required if you are not creating from a snapshot)
+    # * <tt>:snapshot_id</tt> - The snapshot id from which to create the volume
+    #
+    def create_volume(availability_zone, options = {})
+      raise ArgumentError.new('You must specify a size if not creating a volume from a snapshot') if options[:snapshot_id].blank? && options[:size].blank?
+
+      action = 'CreateVolume'
+      params = {
+        'Action'           => action,
+        'AvailabilityZone' => availability_zone
+      }
+      params['Size'] = options[:size] unless options[:size].blank?
+      params['SnapshotId'] = options[:snapshot_id] unless options[:snapshot_id].blank?
+
+      response = send_query_request(params)
+      parser = Awsum::Ec2::VolumeParser.new(self)
+      parser.parse(response.body)[0]
+    end
+
+    # Attach a volume to an instance
+    def attach_volume(volume_id, instance_id, device = '/dev/sdh')
+      action = 'AttachVolume'
+      params = {
+        'Action'     => action,
+        'VolumeId'   => volume_id,
+        'InstanceId' => instance_id,
+        'Device'     => device
+      }
+
+      response = send_query_request(params)
+      response.is_a?(Net::HTTPSuccess)
+    end
+
+    # Detach a volume from an instance
+    #
+    # ===Options
+    # * <tt>:instance_id</tt> - The ID of the instance from which the volume will detach
+    # * <tt>:device</tt> - The device name
+    # * <tt>:force</tt> - Whether to force the detachment. <b>NOTE:</b> If forced you may have data corruption issues.
+    def detach_volume(volume_id, options = {})
+      action = 'DetachVolume'
+      params = {
+        'Action'     => action,
+        'VolumeId'   => volume_id
+      }
+      params['InstanceId'] = options[:instance_id] unless options[:instance_id].blank?
+      params['Device'] = options[:device] unless options[:device].blank?
+      params['Force'] = options[:force] unless options[:force].blank?
+
+      response = send_query_request(params)
+      response.is_a?(Net::HTTPSuccess)
+    end
+
+    # Delete a volume
+    def delete_volume(volume_id)
+      action = 'DeleteVolume'
+      params = {
+        'Action'     => action,
+        'VolumeId'   => volume_id
+      }
+
+      response = send_query_request(params)
+      response.is_a?(Net::HTTPSuccess)
+    end
+
+    # Create a Snapshot of a Volume
+    def create_snapshot(volume_id)
+      action = 'CreateSnapshot'
+      params = {
+        'Action'   => action,
+        'VolumeId' => volume_id
+      }
+
+      response = send_query_request(params)
+      parser = Awsum::Ec2::SnapshotParser.new(self)
+      parser.parse(response.body)[0]
+    end
+
+    # List Snapshot(s)
+    def snapshots(*snapshot_ids)
+      action = 'DescribeSnapshots'
+      params = {
+        'Action' => action
+      }
+      params.merge!(array_to_params(snapshot_ids, 'SnapshotId'))
+
+      response = send_query_request(params)
+      parser = Awsum::Ec2::SnapshotParser.new(self)
+      parser.parse(response.body)
+    end
+
+    # Get the information about a Snapshot
+    def snapshot(snapshot_id)
+      snapshots(snapshot_id)[0]
+    end
+
+    # Delete a Snapshot
+    def delete_snapshot(snapshot_id)
+      action = 'DeleteSnapshot'
+      params = {
+        'Action'     => action,
+        'SnapshotId' => snapshot_id
+      }
+
+      response = send_query_request(params)
+      response.is_a?(Net::HTTPSuccess)
+    end
+
+    # List all AvailabilityZone(s)
+    def availability_zones(*zone_names)
+      action = 'DescribeAvailabilityZones'
+      params = {
+        'Action' => action
+      }
+      params.merge!(array_to_params(zone_names, 'ZoneName'))
+
+      response = send_query_request(params)
+      parser = Awsum::Ec2::AvailabilityZoneParser.new(self)
+      parser.parse(response.body)
+    end
+
+    # List all Region(s)
+    def regions(*region_names)
+      action = 'DescribeRegions'
+      params = {
+        'Action' => action
+      }
+      params.merge!(array_to_params(region_names, 'RegionName'))
+
+      response = send_query_request(params)
+      parser = Awsum::Ec2::RegionParser.new(self)
+      parser.parse(response.body)
+    end
+
+    # List a Region
+    def region(region_name, &block)
+      region = regions(region_name)[0]
+      if block_given?
+        region.use(&block)
+      else
+        region
+      end
+    end
+
+    # List Addresses
+    def addresses(*public_ips)
+      action = 'DescribeAddresses'
+      params = {
+        'Action' => action
+      }
+      params.merge!(array_to_params(public_ips, 'PublicIp'))
+
+      response = send_query_request(params)
+      parser = Awsum::Ec2::AddressParser.new(self)
+      parser.parse(response.body)
+    end
+
+    # Get the Address with a specific public ip
+    def address(public_ip)
+      addresses(public_ip)[0]
+    end
+
+    # Allocate Address
+    #
+    # Will aquire an elastic ip address for use with your account
+    def allocate_address
+      action = 'AllocateAddress'
+      params = {
+        'Action' => action
+      }
+
+      response = send_query_request(params)
+      parser = Awsum::Ec2::AddressParser.new(self)
+      parser.parse(response.body)[0]
+    end
+
+    # Associate Address
+    #
+    # Will link an allocated elastic ip address to an Instance
+    #
+    # <b>NOTE:</b> If the ip address is already associated with another instance, it will be associated with the new instance.
+    #
+    # You can run this command more than once and it will not return an error.
+    def associate_address(instance_id, public_ip)
+      action = 'AssociateAddress'
+      params = {
+        'Action'     => action,
+        'InstanceId' => instance_id,
+        'PublicIp'   => public_ip
+      }
+
+      response = send_query_request(params)
+      response.is_a?(Net::HTTPSuccess)
+    end
+
+    # Disassociate Address
+    #
+    # Will disassociate an allocated elastic ip address from the Instance it's allocated to
+    #
+    # <b>NOTE:</b> You can run this command more than once and it will not return an error.
+    def disassociate_address(public_ip)
+      action = 'DisassociateAddress'
+      params = {
+        'Action'     => action,
+        'PublicIp'   => public_ip
+      }
+
+      response = send_query_request(params)
+      response.is_a?(Net::HTTPSuccess)
+    end
+
+    # Releases an associated Address
+    #
+    # <b>NOTE:</b> This is not a direct call to the Amazon web service. This is a safe operation that will first check to see if the address is allocated to an instance and fail if it is
+    # To ensure an address is released whether associated or not, use #release_address!
+    def release_address(public_ip)
+      address = address(public_ip)
+
+      if address.instance_id.nil?
+        action = 'ReleaseAddress'
+        params = {
+          'Action'   => action,
+          'PublicIp' => public_ip
+        }
+
+        response = send_query_request(params)
+        response.is_a?(Net::HTTPSuccess)
+      else
+        raise 'Address is currently allocated' #FIXME: Add a proper Awsum error here
+      end
+    end
+
+    # Releases an associated Address
+    #
+    # <b>NOTE:</b> This will disassociate an address automatically if it is associated with an instance
+    def release_address!(public_ip)
+      action = 'ReleaseAddress'
+      params = {
+        'Action'   => action,
+        'PublicIp' => public_ip
+      }
+
+      response = send_query_request(params)
+      response.is_a?(Net::HTTPSuccess)
+    end
+
+    # List KeyPair(s)
+    def key_pairs(*key_names)
+      action = 'DescribeKeyPairs'
+      params = {
+        'Action' => action
+      }
+      params.merge!(array_to_params(key_names, 'KeyName'))
+
+      response = send_query_request(params)
+      parser = Awsum::Ec2::KeyPairParser.new(self)
+      parser.parse(response.body)
+    end
+
+    # Get a single KeyPair
+    def key_pair(key_name)
+      key_pairs(key_name)[0]
+    end
+
+    # Create a new KeyPair
+    def create_key_pair(key_name)
+      action = 'CreateKeyPair'
+      params = {
+        'Action'  => action,
+        'KeyName' => key_name
+      }
+
+      response = send_query_request(params)
+      parser = Awsum::Ec2::KeyPairParser.new(self)
+      parser.parse(response.body)[0]
+    end
+
+    # Delete a KeyPair
+    def delete_key_pair(key_name)
+      action = 'DeleteKeyPair'
+      params = {
+        'Action'  => action,
+        'KeyName' => key_name
+      }
+
+      response = send_query_request(params)
+      response.is_a?(Net::HTTPSuccess)
+    end
+
+    # List SecurityGroup(s)
+    def security_groups(*group_names)
+      action = 'DescribeSecurityGroups'
+      params = {
+        'Action' => action
+      }
+      params.merge!(array_to_params(group_names, 'GroupName'))
+
+      response = send_query_request(params)
+      parser = Awsum::Ec2::SecurityGroupParser.new(self)
+      parser.parse(response.body)
+    end
+
+    # Get a single SecurityGroup
+    def security_group(group_name)
+      security_groups(group_name)[0]
+    end
+
+    # Create a new SecurityGroup
+    def create_security_group(name, description)
+      action = 'CreateSecurityGroup'
+      params = {
+        'Action'           => action,
+        'GroupName'        => name,
+        'GroupDescription' => description
+      }
+
+      response = send_query_request(params)
+      response.is_a?(Net::HTTPSuccess)
+    end
+
+    # Delete a SecurityGroup
+    def delete_security_group(group_name)
+      action = 'DeleteSecurityGroup'
+      params = {
+        'Action'  => action,
+        'GroupName' => group_name
+      }
+
+      response = send_query_request(params)
+      response.is_a?(Net::HTTPSuccess)
+    end
+
+    # Authorize access on a specific security group
+    #
+    # ===Options:
+    # ====User/Group access
+    # * <tt>:source_security_group_name</tt> - Name of the security group to authorize access to when operating on a user/group pair
+    # * <tt>:source_security_group_owner_id</tt> - Owner of the security group to authorize access to when operating on a user/group pair
+    # ====CIDR IP access
+    # * <tt>:ip_protocol</tt> - IP protocol to authorize access to when operating on a CIDR IP (tcp, udp or icmp) (default: tcp)
+    # * <tt>:from_port</tt> - Bottom of port range to authorize access to when operating on a CIDR IP. This contains the ICMP type if ICMP is being authorized.
+    # * <tt>:to_port</tt> - Top of port range to authorize access to when operating on a CIDR IP. This contains the ICMP type if ICMP is being authorized.
+    # * <tt>:cidr_ip</tt> - CIDR IP range to authorize access to when operating on a CIDR IP. (default: 0.0.0.0/0)
+    def authorize_security_group_ingress(group_name, options = {})
+      got_at_least_one_user_group_option = !options[:source_security_group_name].nil? || !options[:source_security_group_owner_id].nil?
+      got_user_group_options = !options[:source_security_group_name].nil? && !options[:source_security_group_owner_id].nil?
+      got_at_least_one_cidr_option = !options[:ip_protocol].nil? || !options[:from_port].nil? || !options[:to_port].nil? || !options[:cidr_ip].nil?
+      #Add in defaults
+      options = {:cidr_ip => '0.0.0.0/0'}.merge(options) if got_at_least_one_cidr_option
+      options = {:ip_protocol => 'tcp'}.merge(options) if got_at_least_one_cidr_option
+      got_cidr_options = !options[:ip_protocol].nil? && !options[:from_port].nil? && !options[:to_port].nil? && !options[:cidr_ip].nil?
+      raise ArgumentError.new('Can only authorize user/group or CIDR IP, not both') if got_at_least_one_user_group_option && got_at_least_one_cidr_option
+      raise ArgumentError.new('Need all user/group options when authorizing user/group access') if got_at_least_one_user_group_option && !got_user_group_options
+      raise ArgumentError.new('Need all CIDR IP options when authorizing CIDR IP access') if got_at_least_one_cidr_option && !got_cidr_options
+      raise ArgumentError.new('ip_protocol can only be one of tcp, udp or icmp') if got_at_least_one_cidr_option && !%w(tcp udp icmp).detect{|p| p == options[:ip_protocol] }
+
+      action = 'AuthorizeSecurityGroupIngress'
+      params = {
+        'Action'    => action,
+        'GroupName' => group_name
+      }
+      params['SourceSecurityGroupName'] = options[:source_security_group_name] unless options[:source_security_group_name].nil?
+      params['SourceSecurityGroupOwnerId'] = options[:source_security_group_owner_id] unless options[:source_security_group_owner_id].nil?
+      params['IpProtocol'] = options[:ip_protocol] unless options[:ip_protocol].nil?
+      params['FromPort'] = options[:from_port] unless options[:from_port].nil?
+      params['ToPort'] = options[:to_port] unless options[:to_port].nil?
+      params['CidrIp'] = options[:cidr_ip] unless options[:cidr_ip].nil?
+
+      response = send_query_request(params)
+      response.is_a?(Net::HTTPSuccess)
+    end
+
+    # Revoke access on a specific SecurityGroup
+    #
+    # ===Options:
+    # ====User/Group access
+    # * <tt>:source_security_group_name</tt> - Name of the security group to authorize access to when operating on a user/group pair
+    # * <tt>:source_security_group_owner_id</tt> - Owner of the security group to authorize access to when operating on a user/group pair
+    # ====CIDR IP access
+    # * <tt>:ip_protocol</tt> - IP protocol to authorize access to when operating on a CIDR IP (tcp, udp or icmp) (default: tcp)
+    # * <tt>:from_port</tt> - Bottom of port range to authorize access to when operating on a CIDR IP. This contains the ICMP type if ICMP is being authorized.
+    # * <tt>:to_port</tt> - Top of port range to authorize access to when operating on a CIDR IP. This contains the ICMP type if ICMP is being authorized.
+    # * <tt>:cidr_ip</tt> - CIDR IP range to authorize access to when operating on a CIDR IP. (default: 0.0.0.0/0)
+    def revoke_security_group_ingress(group_name, options = {})
+      got_at_least_one_user_group_option = !options[:source_security_group_name].nil? || !options[:source_security_group_owner_id].nil?
+      got_user_group_options = !options[:source_security_group_name].nil? && !options[:source_security_group_owner_id].nil?
+      got_at_least_one_cidr_option = !options[:ip_protocol].nil? || !options[:from_port].nil? || !options[:to_port].nil? || !options[:cidr_ip].nil?
+      #Add in defaults
+      options = {:cidr_ip => '0.0.0.0/0'}.merge(options) if got_at_least_one_cidr_option
+      options = {:ip_protocol => 'tcp'}.merge(options) if got_at_least_one_cidr_option
+      got_cidr_options = !options[:ip_protocol].nil? && !options[:from_port].nil? && !options[:to_port].nil? && !options[:cidr_ip].nil?
+      raise ArgumentError.new('Can only authorize user/group or CIDR IP, not both') if got_at_least_one_user_group_option && got_at_least_one_cidr_option
+      raise ArgumentError.new('Need all user/group options when revoking user/group access') if got_at_least_one_user_group_option && !got_user_group_options
+      raise ArgumentError.new('Need all CIDR IP options when revoking CIDR IP access') if got_at_least_one_cidr_option && !got_cidr_options
+      raise ArgumentError.new('ip_protocol can only be one of tcp, udp or icmp') if got_at_least_one_cidr_option && !%w(tcp udp icmp).detect{|p| p == options[:ip_protocol] }
+
+      action = 'RevokeSecurityGroupIngress'
+      params = {
+        'Action'    => action,
+        'GroupName' => group_name
+      }
+      params['SourceSecurityGroupName'] = options[:source_security_group_name] unless options[:source_security_group_name].nil?
+      params['SourceSecurityGroupOwnerId'] = options[:source_security_group_owner_id] unless options[:source_security_group_owner_id].nil?
+      params['IpProtocol'] = options[:ip_protocol] unless options[:ip_protocol].nil?
+      params['FromPort'] = options[:from_port] unless options[:from_port].nil?
+      params['ToPort'] = options[:to_port] unless options[:to_port].nil?
+      params['CidrIp'] = options[:cidr_ip] unless options[:cidr_ip].nil?
+
+      response = send_query_request(params)
+      response.is_a?(Net::HTTPSuccess)
+    end
+
+    # List all reserved instance offerings that are available for purchase
+    #
+    # ===Options:
+    # * <tt>:reserved_instances_offering_ids</tt> - Display the reserved instance offerings with the specified ids. Can be an individual id or an array of ids
+    # * <tt>:instance_type</tt> - Display available reserved instance offerings of the specific instance type, can be one of [m1.small, m1.large, m1.xlarge, c1.medium, c1.xlarge], default is all
+    # * <tt>:availability_zone</tt> - Display the reserved instance offerings within the specified availability zone
+    # * <tt>:product_description</tt> - Display the reserved instance offerings with the specified product description
+    #
+    # ===Example
+    #   #To get all offerings for m1.small instances in availability zone us-east-1a
+    #   ec2.reserved_instances_offerings(:instance_type => 'm1.small', :availability_zone => 'us-east-1a')
+    def reserved_instances_offerings(options = {})
+      action = 'DescribeReservedInstancesOfferings'
+      params = {
+        'Action' => action
+      }
+      params.merge!(array_to_params(options[:reserved_instances_offering_ids], 'ReservedInstancesOfferingId')) if options[:reserved_instances_offering_ids]
+      params['InstanceType'] = options[:instance_type] if options[:instance_type]
+      params['AvailabilityZone'] = options[:availability_zone] if options[:availability_zone]
+      params['ProductDescription'] = options[:product_description] if options[:product_description]
+
+      response = send_query_request(params)
+      parser = Awsum::Ec2::ReservedInstancesOfferingParser.new(self)
+      parser.parse(response.body)
+    end
+
+    # Get a single reserved instances offering by id
+    def reserved_instances_offering(id)
+      reserved_instances_offerings(:reserved_instances_offering_ids => id)[0]
+    end
+
+    # Purchase reserved instances
+    #
+    # ===Options:
+    # * <tt>:reserved_instances_offering_ids</tt> - A single reserved instance offering id (or an array of instance ids)
+    # * <tt>:instance_counts</tt> - A number of reserved instances to purchase (or an array of counts per instance in the reserved_instances_offering_ids array)
+    #
+    # ===Example
+    #  ec2.purchase_reserved_instances_offering('reservation-123456', 1)
+    #  or
+    #  ec2.purchase_reserved_instances_offering(['reservation-123456', 'reservation-654321'], [1, 2])
+    def purchase_reserved_instances_offering(reserved_instances_offering_ids, instance_counts = 1)
+      action = 'PurchaseReservedInstancesOffering'
+      params = {
+        'Action'        => action,
+      }
+      params.merge!(array_to_params([instance_counts].flatten, 'InstanceCount'))
+      params.merge!(array_to_params([reserved_instances_offering_ids].flatten, 'ReservedInstancesOfferingId'))
+
+      response = send_query_request(params)
+      parser = Awsum::Ec2::PurchaseReservedInstancesOfferingParser.new(self)
+      result = parser.parse(response.body)
+      if reserved_instances_offering_ids.is_a?(Array)
+        reserved_instances(*result)
+      else
+        reserved_instance(result)
+      end
+    end
+
+    def reserved_instances(*reserved_instances_ids)
+      action = 'DescribeReservedInstances'
+      params = {
+        'Action'        => action
+      }
+      params.merge!(array_to_params(reserved_instances_ids, 'ReservedInstanceId'))
+
+      response = send_query_request(params)
+      parser = Awsum::Ec2::ReservedInstanceParser.new(self)
+      parser.parse(response.body)
+    end
+
+    # Retrieve a single reserved instance by id
+    def reserved_instance(reserved_instance_id)
+      reserved_instances(reserved_instance_id)[0]
+    end
+
+#private
+    #The host to make all requests against
+    def host
+      @host ||= 'ec2.amazonaws.com'
+    end
+
+    def host=(host)
+      @host = host
+    end
+  end
+end