amazon-ec2 0.1.0 → 0.2.0

data/website/index.txt

@@ -1,30 +1,70 @@
-h1. Amazon Web Services EC2 Ruby Gem
+h2. Amazon Web Services EC2 Ruby Gem
 
-h1. → 'amazon-ec2'
+h2. → 'amazon-ec2'
 
 h2. About
 
-Amazon Web Services offers a compute power on demand capability known as the Elastic Compute Cloud (EC2).  Using the current API’s the compute resources in the cloud can be provisioned on demand by making SOAP or HTTP Query API calls to EC2.
+Amazon Web Services offers a compute power on demand capability known as the Elastic Compute Cloud (EC2).  The server resources in the cloud can be provisioned on demand by making HTTP Query API calls to EC2.
  
-This ‘Amazon-EC2’ Ruby Gem is an interface library that can be used to interact with the Amazon EC2 system using the Query API.
+This 'amazon-ec2' Ruby Gem is an interface library that can be used to interact with the Amazon EC2 system and control server resources on demand from your Ruby scripts, or from Ruby on Rails applications.
 
-h2. Important Note
 
-In December of 2006 Amazon Web Services released a sample Ruby code library for interacting with EC2.  I have packaged this sample code as this Ruby Gem as a service to the Ruby community and do not plan to be actively maintaining this code on a full-time basis.
- 
-All I ask in return is if you have some Ruby skills and can contribute documentation, automated unit tests, bug fixes, or enhancements as Subversion patch files that you please do so.   I will be happy to incorporate those changes directly into the library as appropriate.
- 
-Alternatively, if you are interested in becoming a more seriously involved contributing developer with full check-in privileges on the source code please feel free to contact me and we can discuss the best way to do so.
+h2. Important! : Are you upgrading from an earlier release?
 
-h2. Project Info
+This latest release of the gem has undergone a pretty massive re-write.  It is no longer compatible with code you may have written that made use of an older version of 'amazon-ec2' (< 0.2.0).
 
-This project is managed as a RubyForge project which you can find at "http://amazon-ec2.rubyforge.org/":http://amazon-ec2.rubyforge.org/ and this is always the best place to find the latest news, report any bugs, submit feature requests, or provide patches.
+Any other gems which depended on 'amazon-ec2' < 0.2.0 will also no longer work with the new release.  The only project I am aware of that depended on the earlier version of 'amazon-ec2' was 'Capazon'.  This project, which allows you to control EC2 from your Capistrano recipies, has now been deprecated and is being reborn as 'Capsize'.  I rewrote the code for Capsize with the assistance of the original creator of Capazon; Jesse Newland.  Feel free to check out "Capsize":http://capsize.rubyforge.org/ to learn more about this exciting new release!
+
+While we apologize for not being able to maintain backward compatibility with the original 'amazon-ec2' gem, there were just too many major enhancements that needed to be made and it just was'nt possible.  I hope that the new robustness and new features in this new release make any transitional pain worthwhile!  Of course the old versions are still out there on RubyForge, and you can still install them if you pass the version string into the gem install command.  I just don't recommend it unless you really have to.
+
+
+h2. What's new?
+
+This release (>= 0.2.0) represents a major re-write of this gem and contains contributions from several people who make use of this gem for their own applications.  Trust us, its worth the pain of upgrading if you have been using an older version.  Some of the major enhancements you will find are:
+
+* MAJOR library changes : THESE CHANGES ARE NOT BACKWARD COMPATIBLE!!  You will need to update 
+the way in which you make calls, handle responses, and rescue exceptions from this library.  
+If you prefer not to make these changes you can feel free to continue to use the older version 
+of the gem.  These older versions however will no longer be maintained.
+
+* MAJOR refactoring of how methods calls are made.  Now all methods are called with a simple hash
+of arguments and none of them are positional.  This feels much more "Ruby'ish".
+
+* MAJOR refactoring of how responses are returned to users.  No longer do you have to call the 
+.parse method, and no longer are you getting back simple arrays of information.  Responses 
+now come in the form of OpenStruct objects that contain all of the data for an object in 
+Enumerable form so you can use iterators (.each, .each_pair, etc).  All methods return an EC2::Response object
+which inherits from OpenStruct.  The return data from EC2, which is in XML form, is parsed
+with XmlSimple and is used to directly construct the return data structure.  This allows us
+to know with some confidence that the data structure returned from AWS will always be consistent
+with this library's responses.  There is also an .xml attribute for each response object that lets you 
+see the full and complete XML response from AWS if that is useful to you.
+
+* Added an exception framework which will now throw appropriate Ruby exceptions
+that match those handed to us by Amazon EC2.  ArgumentError exceptions will also
+be thrown if you are making calls we know to be illegal or malformed.  You should rescue 
+these exceptions in your application instead of parsing text responses.  All exceptions 
+descend from EC2::Error.  You can see them all in exceptions.rb in the gem install.
+
+* Added a full suite of test/spec unit tests which currently cover 100% of the public methods
+in this library.  We have abot 92% code coverage according to rcov.  This has greatly enhanced 
+the reliability of the library as well as our confidence in the code.  
+We used to have 0% test coverage. :-/ 
+
+* Added an EC2 command shell : 'ec2sh' which can be called from anywhere and gives you
+an interactive irb session with an EC2 connection pre-made for you as @ec2.  You can use this 
+to interactively execute any command on EC2 that this library supports.  Try @ec2.methods.sort 
+or @ec2.describe_images to test it out.  You must first setup two shell environment variables
+which contain your ACCESS_KEY_ID and SECRET_ACCESS_KEY for this to work.  Otherwise an error
+will be thrown when you try to start it.  This is way cool and shamelessly borrowed from 
+Marcel Molina's fine AWS::S3 library.
 
-h2. Documentation
+* Updated API version in the query API request to 2007-01-19, and added all known method calls
+in this version of the API to the gem (including reboot, viewing console output, NAT addressing 
+and more!)
 
-You can browse the complete RDoc generated documentation at:
+* Removed .parse method as it is no longer needed or wanted.
 
-"http://amazon-ec2.rubyforge.org/rdoc/":http://amazon-ec2.rubyforge.org/rdoc/
 
 
 h2. Installing
@@ -33,24 +73,149 @@ This gem follows the standard conventions for installation on any system with Ru
 
 h3. Installation pre-requisites
 
-Before you can make use of this gem you will need an "Amazon Web Services developer account":https://aws-portal.amazon.com/gp/aws/developer/registration/index.html.  This account must also be specifically enabled for Amazon EC2 usage.  AWS will provide you with an ‘AWS Access Key ID’ and a ‘Secret Access Key’ which will allow you to authenticate any API calls you make and ensure correct billing to you for usage of the service.  Take note of these (and keep them secret!).
+h4. "Amazon Web Services developer account":https://aws-portal.amazon.com/gp/aws/developer/registration/index.html.
+
+You'll need an account with AWS in order to use this gem at all.  That should be your first stop on this tour.  Your account must also be enabled for Amazon EC2 usage.  After signup you'll be provided with an 'Access Key ID' and a 'Secret Access Key'.  These allow you to authenticate any API calls you make and ensure correct billing to you for usage of their service.  Take note of these keys (and keep them safe and secret!).
+
+h4. Gem Dependencies
+
+The following gems should be installed automatically as part of your install of amazon-ec2.  Most of them are testing or build dependencies but they should be painless to install even if you don't plan on running the tests or building this gem manually on your own.
+
+"XmlSimple":http://xml-simple.rubyforge.org/  (required)
+ 
+"Mocha":http://mocha.rubyforge.org/  (optional for testing)
+
+"Rcov":http://eigenclass.org/hiki.rb?rcov (optional for testing)
+
+"Test-Spec":http://test-spec.rubyforge.org/test-spec/ (optional for testing)
+
+"Syntax":http://syntax.rubyforge.org/ (optional for building your own copy of the gem and its docs)
+
+"RedCloth":http://whytheluckystiff.net/ruby/redcloth  (optional for building your own copy of the gem and its docs)
+
 
 h3. Installing the gem
 
-Linux / OS X : <pre syntax="ruby">sudo gem install amazon-ec2</pre>
+Linux / OS X : <pre syntax="ruby">sudo gem install amazon-ec2 --include-dependencies</pre>
+
+Microsoft Windows : <pre syntax="ruby">gem install amazon-ec2 --include-dependencies</pre>
+
+
+h2. Using the library
 
-Microsoft Windows : <pre syntax="ruby">gem install amazon-ec2</pre>
+h3. Setting up...
 
+The 'ec2sh' and 'ec2-gem-example.rb' scripts which will be introduced to you shortly expect your AWS EC2 credentials to 
+be stored as shell environment variables which are accessible to those scripts.  This makes them convenient to use whenever 
+you need to do a quick query to see what images you have available to you, whats running now,  or to start or stop an 
+instance on EC2.  You'll find 'ec2sh' to be a very handy tool.  I'll describe only the OS X route for setting up (of course 
+the setup steps will vary depending on your particular system and preferred shell).  If you don't want to 
+do it this way, feel free to copy these scripts from the gem dir to any location where you can run them from and modify them directly to include your credentials.
 
-h2. Sample Usage
+h4. OS X Setup
 
-The library exposes one main interface class <pre syntax="ruby">AWSAuthConnection</pre>
+Edit the file ~/.bash_login and add the following to the existing contents:
 
-It is through an instance of this class that you will perform all the operations for using using the EC2 service including query string header signing.
+<pre syntax="ruby">
+
+export RUBYOPT="rubygems"
+
+# For amazon-ec2 and amazon s3 ruby gems
+export AMAZON_ACCESS_KEY_ID="YOUR_ACCESS_KEY_ID"
+export AMAZON_SECRET_ACCESS_KEY="YOUR_SECRET_ACCESS_KEY_ID"
+
+</pre>
+
+Once you save the file you should close and re-open your command terminal so the new variables are made available.  You'll need to do this close/re-open step for each terminal window you have open (or issue the 'source ~/.bash_login' command in each).  Make sure that this file is only readable by your user so you don't inadvertantly expose your credentials to other users on your system.
+
+You can verify that this setup is complete by running the 'set' in a command window and seeing that your credentials are in the list of shell variables.
 
-The public methods on 'AWSAuthConnection' closely mirror the EC2 Query API, and as such the Query API Reference in the "EC2 Developer Guide":http://developer.amazonwebservices.com/connect/kbcategory.jspa?categoryID=84 should be consulted.
+h3. The basics...
 
-h3. Standalone Ruby Script Usage Sample
+The library exposes one main interface module <pre syntax="ruby">EC2::Base</pre>
+
+This method requires arguments which include your AWS credentials and it will return an object that you can use to make 
+method calls directly against EC2.  All the operations for using the EC2 service, including query string header signing,
+are handled automatically for you.  The connection string will look something like this:
+
+<pre syntax="ruby">
+@ec2 = EC2::Base.new(:access_key_id => ACCESS_KEY_ID, :secret_access_key => SECRET_ACCESS_KEY)
+</pre>
+
+We have tried to keep the public methods on 'amazon-ec2' as close as possible to the AWS EC2 Query API.  
+This similarity allows you to reference the Query API Reference in the "EC2 Developer Guide":http://developer.amazonwebservices.com/connect/kbcategory.jspa?categoryID=84 and be able to get started right away. 
+In most cases the methods names only differ in how they are presented.  e.g. 'DescribeImages' becomes '#describe_images() in Ruby.  
+Feel free to browse the full "RDoc documentation":http://amazon-ec2.rubyforge.org/rdoc/ for all classes and methods of 'amazon-ec2' if you want more details.
+
+
+h3. Examples
+
+The best way to become familiar with 'amazon-ec2' is to take it for a test drive.  We have provided a few simple ways to get you started.  There is also some sample code below that should help out in using 'amazon-ec2' with a plain Ruby script, or as part of a Ruby on Rails application.
+
+
+h4. Using the 'ec2-gem-example.rb' sample test script
+
+An example Ruby script which exercises the library a bit more is installed for you to check out when you install this gem.  You can run this script to verify that everything is setup and working correctly in your environment.  Consult the file which is installed at :
+
+<pre syntax="ruby">[your amazon-ec2 gem dir]/examples/ec2-example.rb</pre>
+
+Since we also package this sample file in the gem's bin/ dir you should also be able to run it from anywhere on your shell path (once you have set your environment variables as described above).
+
+
+h4. Using the 'ec2sh' command shell
+
+The 'ec2sh' command shell is actually a standard 'irb' Ruby shell, with the main difference being we read your AWS credentials from your environment and pre-configure a connection string for you.  This lets you run any EC2 command very simply.  This has proven to be a valuable tool during the development of this gem and you should try it out.  Since we install this tool in your system path as part of the installation of this gem, you should be able to simply run 'ec2sh' from any terminal command prompt on your local system.  You'll see some basic instructions for use, and a few examples when you start 'ec2sh'.  Go ahead and try it out now.  We'll wait...
+
+If your not in front of a terminal shell now (perhaps you're browsing this site on your iPhone) this is what you would see:
+
+<pre syntax="ruby">
+
+hostname:/tmp/rails/amazon_test glenn$ ec2sh
+  
+  '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.  The #xml data is available for each response
+  which allows you to view the full and complete XML response returned by
+  EC2 without any parsing applied.  This is useful for viewing the 
+  hierarchy of an entire response in a friendly way (if XML is friendly
+  to you!).  Understanding the hierarchy of the XML response is critical
+  to making effective use of this library.
+    
+    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 EC2::Response objects, each an EC2 image and its data
+      >> @ec2.describe_images.imagesSet.item
+      >> @ec2.describe_images.imagesSet.item[0] (an OpenStruct of a single item in that array)
+      >> @ec2.describe_images.imagesSet.item[0].to_s (a String representation of that OpenStruct item)
+      
+      returns : an XML representation of all images
+      >> puts @ec2.describe_images.xml
+      
+      returns : an XML representation of all images owned by Amazon
+      >> puts @ec2.describe_images(:owner_id => 'amazon').xml
+    
+>> @ec2.describe_images.imagesSet.item[0].to_s
+=> "#<EC2::Response:0x100A465B4 imageId=\"ami-018e6b68\" imageLocation=\"rbuilder-online/phonehome-1.5.6-x86_10132.img.manifest.xml\" imageOwnerId=\"099034111737\" imageState=\"available\" isPublic=\"true\" parent=#<EC2::Response:0x100A469A6 ...>>"
+
+</pre>
+
+
+h4. Using 'amazon-ec2' in Ruby scripts
+
+Try out the following bit of code.  This should walk through each image returned by a call to #describe_images and print out its key data.  Note in the example below that you cannot walk through the results of the #describe_images call with the '.each' iterator (You'll get errors if you try).  You need to instead walk through the Array of items which are in the 'imagesSet' embedded in the response.  This reflects exactly the XML hierarchy of data returned from EC2 which we parse to Ruby OpenStruct objects (EC2::Response).
 
 <pre syntax="ruby">
 #!/usr/bin/env ruby
@@ -58,103 +223,187 @@ h3. Standalone Ruby Script Usage Sample
 require 'rubygems'
 require 'ec2'
 
-AWS_ACCESS_KEY_ID = '--YOUR AWS ACCESS KEY ID--'
-AWS_SECRET_ACCESS_KEY = '--YOUR AWS SECRET ACCESS KEY--'
+ACCESS_KEY_ID = '--YOUR AWS ACCESS KEY ID--'
+SECRET_ACCESS_KEY = '--YOUR AWS SECRET ACCESS KEY--'
   
-conn = EC2::AWSAuthConnection.new(AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY)
+ec2 = EC2::Base.new(:access_key_id => ACCESS_KEY_ID, :secret_access_key => SECRET_ACCESS_KEY)
  
-puts "----- listing images -----"
-puts conn.describe_images()
+puts "----- listing images owned by 'amazon' -----"
+ec2.describe_images(:owner_id => "amazon").imagesSet.item.each do |image|
+  # OpenStruct objects have members!
+  image.members.each do |member|
+    puts "#{member} => #{image[member]}" 
+  end
+end
 </pre>
 
-An example Ruby script which exercises the library is provided for use as a starting point in the gem installation.  Consult the file which is installed at :
-
-<pre syntax="ruby">[your amazon-ec2 gem dir]/examples/ec2-example.rb</pre>
 
-h3. Ruby on Rails Usage Sample
+h4. Using 'amazon-ec2' in Ruby on Rails applications
 
 in config/environment.rb:
 
 <pre syntax="ruby">
-# Include Amazon Web Services EC2 library gem
-require_gem 'amazon-ec2'
+# Require the amazon-ec2 gem and make its methods available in your Rails app
+# Put this at the bottom of your environment.rb
+require 'EC2'
 </pre>
- 
+
 in app/controllers/your_controller.rb:
 <pre syntax="ruby">
-...
-conn = EC2::AWSAuthConnection.new(AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY)
 
-# The .parse method gives you back an array of
-# values from the API response that you can
-# use in your view
-@ec2_images = conn.describe_images().parse
-  
-# Or with some parameters
-# (in this case specific owner ID's)
-@ec2_images_mine = ec2.describe_images([],["522821470517"],[]).parse
-...
-</pre>
+[some controller code ...]
 
-in app/views/your_view.rhtml:
+ec2 = EC2::Base.new(:access_key_id => "YOUR_AWS_ACCESS_KEY_ID", :secret_access_key => "YOUR_AWS_SECRET_ACCESS_KEY")
 
-Test it out with something like this...
+# get ALL public images
+@ec2_images = ec2.describe_images().imagesSet.item
 
-<pre syntax="ruby">
-...
-<%= debug(@ec2_images) %>
-<%= debug(@ec2_images_mine) %>
-...
-</pre>
+# Get info on all public EC2 images created by the Amazon EC2 team.
+@ec2_images_amazon = ec2.describe_images(:owner_id => "amazon").imagesSet.item
 
-Or this...
+[some more controller code ...]
 
-<pre syntax="ruby">
-...
-<% @ec2_images.each do |image| %>
-  <% image.each_with_index do |value, index| %>
-    <%= "#{index} => #{value}" %><br />
-  <% end %>
-<% end %>
-...
 </pre>
- 
-Or even this...
- 
+
+and then you can show off your EC2 image data with some code in app/views/your_view.rhtml:
+
 <pre syntax="ruby">
-...
-<table>
+
+<h1>EC2 Test#index</h1>
+
+<h1>Sample 1 - debug() view</h1>
+
+<%= debug(@ec2_images_amazon) %>
+
+<h1>Sample 2 - Build a table</h1>
+
+<table border='1'>
   <tr>
-    <th>Id</th>
-    <th>Location</th>
-    <th>Owner</th>
-    <th>State</th>
-    <th>Public?</th>
+    <th>image.imageId</th>
+    <th>image.imageLocation</th>
+    <th>image.imageOwnerId</th>
+    <th>image.imageState</th>
+    <th>image.isPublic</th>
   </tr>
   
-  <% for ec2_image in @ec2_images %>
+  <% for image in @ec2_images_amazon %>
     <tr>
-      <td><%=h ec2_image[1] %></td>
-      <td><%=h ec2_image[2] %></td>
-      <td><%=h ec2_image[3] %></td>
-      <td><%=h ec2_image[4] %></td>
-      <td><%=h ec2_image[5] %></td>
+      <td><%=h image.imageId %></td>
+      <td><%=h image.imageLocation %></td>
+      <td><%=h image.imageOwnerId %></td>
+      <td><%=h image.imageState %></td>
+      <td><%=h image.isPublic %></td>
     </tr>
   <% end %>
 </table>
-...
+
+<h1>Sample 3 - Iterate</h1>
+
+<% @ec2_images_amazon.each do |image| %>
+	<% image.each_pair do |key, value| %>
+		<% unless key == 'parent' %>
+			<%= "#{key} => #{value}" %><br />
+		<% end %>
+	<% end %>
+	<br />
+<% end %>
+
+</pre>
+
+
+h4. Important notes regarding the structure of EC2::Response Objects
+
+One of the key benefits of this new version of the library is that all responses from EC2 are bundled up in 
+a real data structure and no longer require parsing of text.  We use an OpenStruct as the parent for the EC2::Response 
+object and we populate it directly from the XML given to us by EC2 in response to any command we issue.  This means that 
+future changes to the API and what is returned by EC2 will largely be handled transparently by the gem.  This is a huge 
+benefit.  What this means though, is that you may have to do a little homework on what actually gets returned by EC2 as XML.  
+For example, when you make a #describe_images call in ec2sh to EC2 what you will get back will look like:
+
+
+<pre syntax="ruby">
+$ ec2sh
+>> puts @ec2.describe_images(:owner_id => 'amazon').xml
+
+<?xml version="1.0"?>
+<DescribeImagesResponse xmlns="http://ec2.amazonaws.com/doc/2007-01-19/">
+    <imagesSet>
+        <item>
+            <imageId>ami-20b65349</imageId>
+            <imageLocation>ec2-public-images/fedora-core4-base.manifest.xml</imageLocation>
+            <imageState>available</imageState>
+            <imageOwnerId>amazon</imageOwnerId>
+            <isPublic>true</isPublic>
+        </item>
+        <item>
+            <imageId>ami-22b6534b</imageId>
+            <imageLocation>ec2-public-images/fedora-core4-mysql.manifest.xml</imageLocation>
+            <imageState>available</imageState>
+            <imageOwnerId>amazon</imageOwnerId>
+            <isPublic>true</isPublic>
+        </item>
+        <item>
+            <imageId>ami-23b6534a</imageId>
+            <imageLocation>ec2-public-images/fedora-core4-apache.manifest.xml</imageLocation>
+            <imageState>available</imageState>
+            <imageOwnerId>amazon</imageOwnerId>
+            <isPublic>true</isPublic>
+        </item>
+        <item>
+            <imageId>ami-25b6534c</imageId>
+            <imageLocation>ec2-public-images/fedora-core4-apache-mysql.manifest.xml</imageLocation>
+            <imageState>available</imageState>
+            <imageOwnerId>amazon</imageOwnerId>
+            <isPublic>true</isPublic>
+        </item>
+        <item>
+            <imageId>ami-26b6534f</imageId>
+            <imageLocation>ec2-public-images/developer-image.manifest.xml</imageLocation>
+            <imageState>available</imageState>
+            <imageOwnerId>amazon</imageOwnerId>
+            <isPublic>true</isPublic>
+        </item>
+        <item>
+            <imageId>ami-2bb65342</imageId>
+            <imageLocation>ec2-public-images/getting-started.manifest.xml</imageLocation>
+            <imageState>available</imageState>
+            <imageOwnerId>amazon</imageOwnerId>
+            <isPublic>true</isPublic>
+        </item>
+    </imagesSet>
+</DescribeImagesResponse>
+
 </pre>
 
+You can see in the XML the structure that you will need to follow when constructing queries for information and parsing responses from EC2.
 
-h2. Resources
+So, for example, if you wanted to get the image ID of the third image listed in the response above you would need to do:
+
+<pre syntax="ruby">
+>> puts @ec2.describe_images(:owner_id => 'amazon').imagesSet.item[2].imageId
+ami-23b6534a
+</pre>
+
+EC2 will typically return 'sets' of things (imagesSet, reservationSet, etc.) which we map to ruby Arrays (.imagesSet.item in the example above).  If you want to iterate over a response set you will need to iterate over this array.  The Arrays will typically contain additional EC2::Response objects that represent each individual item.  You'll find that you can use the 'ec2sh' to help you understand the structure more completely if you try issuing commands there as a way to practice seeing what will be returned and making sure you get exactly what you want.  You can always call the EC2::Response#xml method like I did above to see the exact XML returned which allows you to easily derive the structure for the Ruby OpenStruct object.
 
-h3. Project Related
 
-"http://aws.amazon.com/":http://aws.amazon.com/
-"http://amazon-ec2.rubyforge.org/":http://amazon-ec2.rubyforge.org/
+h2. Contributing
 
-h3. Project Tools
+We can always use your help!  Do you have Ruby skills?  Do you see a bug or enhancement that you'd like to see fixed?  We would love to have your patches for documentation, test cases, or enhancements.
 
+h2. Project Info
+
+This project is managed as a RubyForge project which you can find at "http://amazon-ec2.rubyforge.org/":http://amazon-ec2.rubyforge.org/ and this is always the best place to find the latest news, report any bugs, submit feature requests, or provide patches.
+
+h2. Learning More
+
+h3. Documentation
+
+Complete RDoc generated documentation can be found at "http://amazon-ec2.rubyforge.org/rdoc/":http://amazon-ec2.rubyforge.org/rdoc/
+
+h3. Websites
+
+"Amazon Web Services Home":http://aws.amazon.com/
 "Project Home":http://rubyforge.org/projects/amazon-ec2/
 "Downloads":http://rubyforge.org/frs/?group_id=2753
 "Browse Code":http://rubyforge.org/scm/?group_id=2753
@@ -165,12 +414,14 @@ h3. Project Tools
 
 h3. Related Projects
 
-"Capazon":http://capazon.rubyforge.org/
+"Capsize":http://capsize.rubyforge.org/ : A Capistrano (>= 2.x) plugin that allows complete control of Amazon EC2 from Capistrano recipes.
 
 
 h2. Credits
 
-The original sample code for this library was provided by Amazon Web Services, LLC.  Thanks to them for providing all of us with samples that got this started.
+The original sample code for this library was provided by Amazon Web Services, LLC.  Thanks to them for providing all of us with samples that got this started.  This latest version of amazon-ec2 doesn't much resemble the original.  They got us going though and thanks to the EC2 team for including Ruby in their plans.  We hope to see more AWS Ruby code.
+
+Thanks to all the great folks who submitted patches and kept this project rolling.  I would especially like to thank Sean Knapp, Kevin Clark, and Randy Bias.  Your patches and help are much appreciated.
  
 Thanks to Dr. Nic Williams and his great 'NewGem' Ruby Gem Generator.  This gem of a Gem helped me package up this code for distribution in a flash!  You can find Dr. Nic's NewGem generator at "http://newgem.rubyforge.org/":http://newgem.rubyforge.org/