amazon-ec2 0.2.10 → 0.2.13

data/{History.txt → CHANGELOG}

@@ -1,3 +1,10 @@
+=== 0.2.12 2008-04-25
+ * A few adjustments to work with GitHub.
+
+=== 0.2.11 2008-04-25
+ * Moved gem completely to GitHub.
+ * Removed a LOT of RubyForge related cruft that's no longer needed.
+
 === 0.2.10 2008-04-13
  * Fix bug where ec2#disassociate_address would return 'undefined method 'reject!' for "xxx.xxx.xxx.xxx":String'.
    Thanks to Brian Thomas for reporting.

data/README.rdoc

@@ -0,0 +1,322 @@
+= Amazon Web Services Elastic Compute Cloud (EC2) Ruby Gem
+
+== About amazon-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 and control server resources on demand from your Ruby scripts, or from applications written in your Ruby framework of choice (Ruby on Rails, Merb, etc.).
+
+For the most complete and up-to date README information please visit the project homepage at:
+
+http://github.com/grempe/amazon-ec2/tree/master
+
+or the EC2 website at http://aws.amazon.com/ec2
+
+
+== Installation
+
+This gem follows the standard conventions for installation on any system with Ruby and RubyGems installed.  If you have worked with gems before this will look very familiar.
+
+=== Get an AWS account
+
+Before you can make use of this gem you will need an Amazon Web Services developer account which you can sign up for at 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!).
+
+=== Install required gem pre-requisites
+
+The following gems should be installed automatically as part of your install of amazon-ec2. Most of them are needed for testing 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 (required)
+  Mocha (optional for testing)
+  Rcov (optional for testing)
+  Test-Spec (optional for testing)
+
+=== Install the amazon-ec2 gem
+
+  # ONE TIME ONLY
+  # Execute this on each machine where you install gems to add GitHub as a gem source
+  # Do this only once or you'll end up with multiple entries in 'gem sources'
+  gem sources -a http://gems.github.com/
+
+  # ONE TIME ONLY
+  # Only if you had a previous version of the gem installed from RubyForge before we moved to GitHub
+  # Say 'Y' to remove all previous versions and all binaries when prompted.  It won't hurt to do
+  # this in any case.
+  sudo gem uninstall amazon-ec2
+
+  # Finally install the gem
+  sudo gem install grempe-amazon-ec2
+
+== Using amazon-ec2
+
+The library exposes one main interface class EC2::Base.  It is through an instance of this class that you will perform all the operations for using the EC2 service including query string header signing.
+
+The public methods on EC2::Base 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 ) will prove helpful.
+
+
+=== 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, what's 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.
+
+Edit the file ~/.bash_login and add the following to the existing contents:
+
+  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"
+
+Once you save the file you should close and re-open your 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 inadvertently 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 basics
+
+The library exposes one main interface module
+
+  EC2::Base
+
+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:
+
+  @ec2 = EC2::Base.new(:access_key_id => ACCESS_KEY_ID, :secret_access_key => SECRET_ACCESS_KEY)
+
+I've 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 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 for all classes and methods of 'amazon-ec2' if you want more details.
+
+
+=== 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.
+
+==== 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 :
+
+  [your amazon-ec2 gem dir]/examples/ec2-example.rb
+
+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).
+
+==== 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 you're not in front of a terminal shell now (perhaps you’re browsing this site on your iPhone) this is what you would see:
+
+
+  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 ...>>"
+
+
+=== Ruby script usage example:
+
+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).
+
+  #!/usr/bin/env ruby
+  
+  require 'rubygems'
+  require 'ec2'
+  
+  ACCESS_KEY_ID = '--YOUR AWS ACCESS KEY ID--'
+  SECRET_ACCESS_KEY = '--YOUR AWS SECRET ACCESS KEY--'
+  
+  ec2 = EC2::Base.new(:access_key_id => ACCESS_KEY_ID, :secret_access_key => SECRET_ACCESS_KEY)
+  
+  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
+
+=== Ruby on Rails usage example:
+
+<b>config/environment.rb</b>
+
+	# 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'
+
+<b>app/controllers/my_controller.rb</b>
+
+	[some controller code ...]
+
+	ec2 = EC2::Base.new(:access_key_id => "YOUR_AWS_ACCESS_KEY_ID", :secret_access_key => "YOUR_AWS_SECRET_ACCESS_KEY")
+
+	# get ALL public images
+	@ec2_images = ec2.describe_images().imagesSet.item
+
+	# Get info on all public EC2 images created by the Amazon EC2 team.
+	@ec2_images_amazon = ec2.describe_images(:owner_id => "amazon").imagesSet.item
+
+	[some more controller code ...]
+
+
+<b>app/views/my/index.rhtml</b>
+
+	<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>image.imageId</th>
+	    <th>image.imageLocation</th>
+	    <th>image.imageOwnerId</th>
+	    <th>image.imageState</th>
+	    <th>image.isPublic</th>
+	  </tr>
+
+	  <% for image in @ec2_images_amazon %>
+	    <tr>
+	      <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 %>
+
+
+=== 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. EC2::Response inherits from the OpenStruct class 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' what you will get back will look like:
+
+  $ 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>
+
+You can see in the XML the structure that you will need to follow when constructing queries for information and parsing responses from EC2.
+
+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:
+
+  >> puts @ec2.describe_images(:owner_id => 'amazon').imagesSet.item[2].imageId
+  ami-23b6534a
+
+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.
+
+
+== Additional Resources
+
+=== Project Websites
+
+* Project Home : http://github.com/grempe/amazon-ec2/tree/master
+* Discussion Group : http://groups.google.com/group/amazon-ec2
+* Report Bugs / Request Features : http://grempe.lighthouseapp.com/projects/10644-amazon-ec2/overview
+* Amazon Web Services : http://aws.amazon.com
+
+=== Related Projects
+
+Jesse Newland and I created the Capsize project which can help when using Capistrano and EC2 together.  You can check out the latest code at:
+
+  http://github.com/jnewland/capsize/tree/master
+
+== Credits
+
+The original code for this library was provided by Amazon Web Services, LLC as sample code.  Thanks to them for providing all of us with something to get us started.
+
+== Contact
+
+Comments, patches, Git pull requests and bug reports are welcome. Send an email to mailto:glenn.rempe@nospam@gmail.com or use the Google Groups forum for this project.
+
+Enjoy!
+
+Glenn Rempe

data/Rakefile

@@ -1,4 +1,30 @@
-require 'config/requirements'
-require 'config/hoe' # setup Hoe + all gem configuration
-
-Dir['tasks/**/*.rake'].each { |rake| load rake }
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+# read the contents of the gemspec, eval it, and assign it to 'spec'
+# this lets us maintain all gemspec info in one place.  Nice and DRY.
+spec = eval(IO.read("amazon-ec2.gemspec"))
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+task :install => [:package] do
+  sh %{sudo gem install pkg/#{GEM}-#{VERSION}}
+end
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/test*.rb']
+  t.verbose = true
+end
+
+Rake::RDocTask.new do |rd|
+  rd.main = "README.rdoc"
+  rd.rdoc_files.include("README.rdoc", "lib/**/*.rb")
+  rd.rdoc_dir = 'doc'
+  rd.options = spec.rdoc_options
+end
+

data/bin/ec2-gem-example.rb

@@ -31,9 +31,6 @@ end
 
 ec2 = EC2::Base.new( :access_key_id => ACCESS_KEY_ID, :secret_access_key => SECRET_ACCESS_KEY )
 
-puts "----- GEM Version -----"
-puts EC2::VERSION::STRING
-
 puts "----- ec2.methods.sort -----"
 p ec2.methods.sort
 

data/lib/EC2.rb

@@ -24,13 +24,6 @@ module EC2
   # This is the version of the API as defined by Amazon Web Services
   API_VERSION = '2008-02-01'
 
-  # This release version is passed in with each request as part
-  # of the HTTP 'User-Agent' header.  Set this be the same value
-  # as what is stored in the lib/EC2/version.rb module constant instead.
-  # This way we keep it nice and DRY and only have to define the
-  # version number in a single place.
-  RELEASE_VERSION = EC2::VERSION::STRING
-
   # 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
@@ -174,7 +167,7 @@ module EC2
 
           req = Net::HTTP::Post.new("/")
           req.content_type = 'application/x-www-form-urlencoded'
-          req['User-Agent'] = "rubyforge-amazon-ec2-ruby-gem-query-api v-#{RELEASE_VERSION}"
+          req['User-Agent'] = "github-amazon-ec2-ruby-gem"
 
           response = @http.request(req, query)
 

data/lib/EC2/instances.rb

@@ -28,7 +28,8 @@ module EC2
     # launch, the instances start in the default security group.
     #
     # An optional instance type can be specified.  Currently supported types are 'm1.small', 'm1.large',
-    # and 'm1.xlarge'.  'm1.small' is the default if no instance_type is specified.
+    # 'm1.xlarge' and the high CPU types 'c1.medium' and 'c1.xlarge'.  'm1.small' is the default
+    # if no instance_type is specified.
     #
     # You can provide an optional key pair ID for each image in the launch request. All instances
     # that are created from images that use this key pair will have access to the associated public
@@ -82,7 +83,7 @@ module EC2
       raise ArgumentError, ":min_count is not valid" unless options[:min_count].to_i > 0
       raise ArgumentError, ":max_count is not valid" unless options[:max_count].to_i > 0
       raise ArgumentError, ":addressing_type must be 'direct' or 'public'" unless options[:addressing_type] == "public" || options[:addressing_type] == "direct"
-      raise ArgumentError, ":instance_type must be 'm1.small', 'm1.large' or 'm1.xlarge'" unless options[:instance_type] == "m1.small" || options[:instance_type] == "m1.large" || options[:instance_type] == "m1.xlarge"
+      raise ArgumentError, ":instance_type must be 'm1.small', 'm1.large', 'm1.xlarge', 'c1.medium', or 'c1.xlarge'" unless options[:instance_type] == "m1.small" || options[:instance_type] == "m1.large" || options[:instance_type] == "m1.xlarge" || options[:instance_type] == "c1.medium" || options[:instance_type] == "c1.xlarge"
       raise ArgumentError, ":base64_encoded must be 'true' or 'false'" unless options[:base64_encoded] == true || options[:base64_encoded] == false
 
       # If :user_data is passed in then URL escape and Base64 encode it

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: amazon-ec2
 version: !ruby/object:Gem::Version 
-  version: 0.2.10
+  version: 0.2.13
 platform: ruby
 authors: 
 - Glenn Rempe
@@ -9,7 +9,7 @@ autorequire: EC2
 bindir: bin
 cert_chain: []
 
-date: 2008-04-13 00:00:00 -07:00
+date: 2008-06-03 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -19,7 +19,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.0.11
+        version: "0"
     version: 
 - !ruby/object:Gem::Dependency 
   name: mocha
@@ -28,7 +28,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.4.0
+        version: "0"
     version: 
 - !ruby/object:Gem::Dependency 
   name: test-spec
@@ -37,7 +37,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.3.0
+        version: "0"
     version: 
 - !ruby/object:Gem::Dependency 
   name: rcov
@@ -46,28 +46,10 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.8.0.2
+        version: "0"
     version: 
-- !ruby/object:Gem::Dependency 
-  name: syntax
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 1.0.0
-    version: 
-- !ruby/object:Gem::Dependency 
-  name: RedCloth
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 3.0.4
-    version: 
-description: An interface library that allows Ruby or Ruby on Rails applications to easily connect to the HTTP 'Query API' for the Amazon Web Services Elastic Compute Cloud (EC2) and manipulate server instances.
-email: grempe@rubyforge.org
+description: 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.
+email: glenn.rempe@gmail.com
 executables: 
 - ec2-gem-example.rb
 - ec2sh
@@ -75,21 +57,15 @@ executables:
 extensions: []
 
 extra_rdoc_files: 
-- README.txt
-- History.txt
-- License.txt
+- README.rdoc
+- CHANGELOG
+- LICENSE
 files: 
-- History.txt
-- License.txt
-- Manifest.txt
-- README.txt
+- README.rdoc
+- LICENSE
+- CHANGELOG
 - Rakefile
-- bin/ec2-gem-example.rb
-- bin/ec2sh
-- bin/setup.rb
-- config/hoe.rb
-- config/requirements.rb
-- lib/EC2.rb
+- lib/EC2
 - lib/EC2/console.rb
 - lib/EC2/elastic_ips.rb
 - lib/EC2/exceptions.rb
@@ -100,14 +76,7 @@ files:
 - lib/EC2/products.rb
 - lib/EC2/responses.rb
 - lib/EC2/security_groups.rb
-- lib/EC2/version.rb
-- script/destroy
-- script/generate
-- script/txt2html
-- setup.rb
-- tasks/deployment.rake
-- tasks/environment.rake
-- tasks/website.rake
+- lib/EC2.rb
 - test/test_EC2.rb
 - test/test_EC2_console.rb
 - test/test_EC2_elastic_ips.rb
@@ -118,15 +87,9 @@ files:
 - test/test_EC2_products.rb
 - test/test_EC2_responses.rb
 - test/test_EC2_security_groups.rb
-- test/test_EC2_version.rb
 - test/test_helper.rb
-- website/index.html
-- website/index.txt
-- website/javascripts/rounded_corners_lite.inc.js
-- website/stylesheets/screen.css
-- website/template.rhtml
 has_rdoc: true
-homepage: http://amazon-ec2.rubyforge.org
+homepage: http://github.com/grempe/amazon-ec2/
 post_install_message: 
 rdoc_options: 
 - --quiet
@@ -136,7 +99,7 @@ rdoc_options:
 - index.html
 - --line-numbers
 - --main
-- README.txt
+- README.rdoc
 - --inline-source
 require_paths: 
 - lib
@@ -154,11 +117,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   version: 
 requirements: []
 
-rubyforge_project: amazon-ec2
+rubyforge_project: 
 rubygems_version: 1.1.1
 signing_key: 
 specification_version: 2
-summary: An interface library that allows Ruby or Ruby on Rails applications to easily connect to the HTTP 'Query API' for the Amazon Web Services Elastic Compute Cloud (EC2) and manipulate server instances.
+summary: 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.
 test_files: 
 - test/test_EC2.rb
 - test/test_EC2_console.rb
@@ -170,5 +133,4 @@ test_files:
 - test/test_EC2_products.rb
 - test/test_EC2_responses.rb
 - test/test_EC2_security_groups.rb
-- test/test_EC2_version.rb
 - test/test_helper.rb