cloudservers 0.2.0

data/.gitignore

@@ -0,0 +1,2 @@
+pkg/
+doc/

data/COPYING

@@ -0,0 +1,10 @@
+Unless otherwise noted, all files are released under the MIT license, exceptions contain licensing information in them.
+
+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.
+
+Except as contained in this notice, the name of Rackspace US, Inc. shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization from Rackspace US, Inc.
+

data/README.rdoc

@@ -0,0 +1,87 @@
+= Rackspace Cloud Servers
+
+== Description
+
+This is a Ruby interface into the Rackspace[http://rackspacecloud.com/] {Cloud Servers}[http://www.rackspacecloud.com/cloud_hosting_products/servers] service. Cloud Servers from The Rackspace Cloud put you in complete control of your hosting infrastructure. Each Cloud Server is a fully-customizable, pay by the hour, virtualized Windows or Linux server instance that you launch, maintain, and control with full root access.
+
+*Note that in version 0.2.0 the connection style changed, from positional arguments to a hash of options*
+
+== Installation
+
+This source is available on Github[http://github.com/rackspace/ruby-cloudservers/] and the gem is available on Gemcutter[http://gemcutter.org/].  To install it, do
+
+  gem sources -a http://gemcutter.org/ (Newer Ruby Gems have this already)
+  
+  sudo gem install cloudservers
+  
+To use it in a Rails application, add the following information to your config/environment.rb
+
+  config.gem "cloudservers"
+  
+
+== Examples
+
+See the class definitions for documentation on specific methods and operations.
+
+  require 'rubygems'
+  require 'cloudservers'
+
+  # Log into the Cloud Servers system
+  cs = CloudServers::Connection.new(:username => USERNAME, :api_key => API_KEY)	
+
+  # Get a listing of all current servers
+  >> cs.servers
+  => [{:name=>"RenamedRubyTest", :id=>110917}]
+
+  # Access a specific server
+  >> server = cs.server(110917)
+  >> server.name
+  => "RenamedRubyTest"
+
+  # or...
+  server_manager.find(110917)
+  
+
+  # See what type of server this is
+  >> server.flavor.name
+  => "256 server"
+  >> server.image.name
+  => "Ubuntu 8.04.2 LTS (hardy)"
+
+  # Soft-reboot the server
+  >> server.reboot
+  => true
+
+  # Create a new 512MB CentOS 5.2 server.  The root password is returned in the adminPass method.
+  >> image = cs.get_image(8)
+  => #<CloudServers::Image:0x1014a8060 ...>, status"ACTIVE"
+  >> image.name
+  => "CentOS 5.2"
+  >> flavor = cs.get_flavor(2)
+  => #<CloudServers::Flavor:0x101469130 @disk=20, @name="512 server", @id=2, @ram=512>
+  >> flavor.name
+  => "512 server"
+  >> newserver = cs.create_server(:name => "New Server", :imageId => image.id, :flavorId => flavor.id)
+  => #<CloudServers::Server:0x101433f08 ....
+  >> newserver.status
+  => "BUILD"
+  >> newserver.progress
+  => 0
+  >> newserver.adminPass
+  => "NewServerMbhzUnO"
+  >> newserver.refresh
+  => true
+  >> newserver.progress
+  => 12
+  
+  # Delete the new server
+  >> newserver.delete!
+  => true  
+
+== Authors
+
+By H. Wade Minter <wade.minter@rackspace.com> and Mike Mayo <mike.mayo@rackspace.com>
+
+== License
+
+See COPYING for license information.

data/Rakefile

@@ -0,0 +1,17 @@
+require 'rubygems'
+require './lib/cloudservers.rb'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "cloudservers"
+    gemspec.summary = "Rackspace Cloud Servers Ruby API"
+    gemspec.description = "A Ruby API to version 1.0 of the Rackspace Cloud Servers product."
+    gemspec.email = "wade.minter@rackspace.com"
+    gemspec.homepage = "http://github.com/rackspace/cloudservers"
+    gemspec.authors = ["H. Wade Minter","Mike Mayo"]
+    gemspec.add_dependency 'json'
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install jeweler"
+end

data/TODO

@@ -0,0 +1,13 @@
+* There are caching bugs in the API, so that accurate information is not always returned (ie. if you add a server and
+  then list available servers, the new one will not show up.).  That needs to be corrected on the API end before
+  data will be accurate.
+
+* Add pagination in object listing.
+
+* Allow some sort of flag to get the stack trace when an exception is thrown.
+
+* Shared IP group modification code.
+
+* Support the changes-since parameter.
+
+* Tests.  Accusations of heresy and/or apostasy are expected.  :-)

data/VERSION

@@ -0,0 +1 @@
+0.2.0

data/cloudservers.gemspec

@@ -0,0 +1,62 @@
+# 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{cloudservers}
+  s.version = "0.2.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["H. Wade Minter", "Mike Mayo"]
+  s.date = %q{2010-05-06}
+  s.description = %q{A Ruby API to version 1.0 of the Rackspace Cloud Servers product.}
+  s.email = %q{wade.minter@rackspace.com}
+  s.extra_rdoc_files = [
+    "README.rdoc",
+     "TODO"
+  ]
+  s.files = [
+    ".gitignore",
+     "COPYING",
+     "README.rdoc",
+     "Rakefile",
+     "TODO",
+     "VERSION",
+     "cloudservers.gemspec",
+     "lib/cloudservers.rb",
+     "lib/cloudservers/authentication.rb",
+     "lib/cloudservers/connection.rb",
+     "lib/cloudservers/entity_manager.rb",
+     "lib/cloudservers/exception.rb",
+     "lib/cloudservers/flavor.rb",
+     "lib/cloudservers/image.rb",
+     "lib/cloudservers/server.rb",
+     "lib/cloudservers/shared_ip_group.rb",
+     "test/cloudservers_authentication_test.rb",
+     "test/test_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/rackspace/cloudservers}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{Rackspace Cloud Servers Ruby API}
+  s.test_files = [
+    "test/cloudservers_authentication_test.rb",
+     "test/test_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<json>, [">= 0"])
+    else
+      s.add_dependency(%q<json>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<json>, [">= 0"])
+  end
+end
+

data/lib/cloudservers/authentication.rb

@@ -0,0 +1,38 @@
+module CloudServers
+  class Authentication
+    
+    # Performs an authentication to the Rackspace Cloud authorization servers.  Opens a new HTTP connection to the API server,
+    # sends the credentials, and looks for a successful authentication.  If it succeeds, it sets the svrmgmthost,
+    # svrmgtpath, svrmgmtport, svrmgmtscheme, authtoken, and authok variables on the connection.  If it fails, it raises
+    # an exception.
+    #
+    # Should probably never be called directly.
+    def initialize(connection)
+      path = '/v1.0'
+      hdrhash = { "X-Auth-User" => connection.authuser, "X-Auth-Key" => connection.authkey }
+      begin
+        server = Net::HTTP::Proxy(connection.proxy_host, connection.proxy_port).new('auth.api.rackspacecloud.com',443)
+        server.use_ssl = true
+        server.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        server.start
+      rescue
+        raise CloudServers::Exception::Connection, "Unable to connect to #{server}"
+      end
+      response = server.get(path,hdrhash)
+      if (response.code == "204")
+        connection.authtoken = response["x-auth-token"]
+        connection.svrmgmthost = URI.parse(response["x-server-management-url"]).host
+        connection.svrmgmtpath = URI.parse(response["x-server-management-url"]).path
+        # Force the path into the v1.0 URL space
+        connection.svrmgmtpath.sub!(/\/.*?\//, '/v1.0/')
+        connection.svrmgmtport = URI.parse(response["x-server-management-url"]).port
+        connection.svrmgmtscheme = URI.parse(response["x-server-management-url"]).scheme
+        connection.authok = true
+      else
+        connection.authtoken = false
+        raise CloudServers::Exception::Authentication, "Authentication failed with response code #{response.code}"
+      end
+      server.finish
+    end
+  end
+end

data/lib/cloudservers/connection.rb

@@ -0,0 +1,306 @@
+module CloudServers
+  class Connection
+    
+    attr_reader   :authuser
+    attr_reader   :authkey
+    attr_accessor :authtoken
+    attr_accessor :authok
+    attr_accessor :svrmgmthost
+    attr_accessor :svrmgmtpath
+    attr_accessor :svrmgmtport
+    attr_accessor :svrmgmtscheme
+    attr_reader   :proxy_host
+    attr_reader   :proxy_port
+    
+    # Creates a new CloudServers::Connection object.  Uses CloudServers::Authentication to perform the login for the connection.
+    #
+    # Setting the retry_auth option to false will cause an exception to be thrown if your authorization token expires.
+    # Otherwise, it will attempt to reauthenticate.
+    #
+    # This is useful if you are using the library on a Rackspace-hosted system, as it provides faster speeds, keeps traffic off of
+    # the public network, and the bandwidth is not billed.
+    #
+    # This will likely be the base class for most operations.
+    #
+    # The constructor takes a hash of options, including:
+    #
+    #   :username - Your Rackspace Cloud username *required*
+    #   :api_key - Your Rackspace Cloud API key *required*
+    #   :retry_auth - Whether to retry if your auth token expires (defaults to true)
+    #   :proxy_host - If you need to connect through a proxy, supply the hostname here
+    #   :proxy_port - If you need to connect through a proxy, supply the port here
+    #
+    #   cf = CloudServers::Connection.new(:username => 'YOUR_USERNAME', :api_key => 'YOUR_API_KEY')
+    def initialize(options = {:retry_auth => true}) 
+      @authuser = options[:username] || (raise Authentication, "Must supply a :username")
+      @authkey = options[:api_key] || (raise Authentication, "Must supply an :api_key")
+      @retry_auth = options[:retry_auth]
+      @proxy_host = options[:proxy_host]
+      @proxy_port = options[:proxy_port]
+      @authok = false
+      @http = {}
+      CloudServers::Authentication.new(self)
+    end
+    
+    # Returns true if the authentication was successful and returns false otherwise.
+    #
+    #   cs.authok?
+    #   => true
+    def authok?
+      @authok
+    end
+    
+    # This method actually makes the HTTP REST calls out to the server
+    def csreq(method,server,path,port,scheme,headers = {},data = nil,attempts = 0) # :nodoc:
+      start = Time.now
+      hdrhash = headerprep(headers)
+      start_http(server,path,port,scheme,hdrhash)
+      request = Net::HTTP.const_get(method.to_s.capitalize).new(path,hdrhash)
+      request.body = data
+      response = @http[server].request(request)
+      raise CloudServers::Exception::ExpiredAuthToken if response.code == "401"
+      response
+    rescue Errno::EPIPE, Timeout::Error, Errno::EINVAL, EOFError
+      # Server closed the connection, retry
+      raise CloudServers::Exception::Connection, "Unable to reconnect to #{server} after #{count} attempts" if attempts >= 5
+      attempts += 1
+      @http[server].finish
+      start_http(server,path,port,scheme,headers)
+      retry
+    rescue CloudServers::Exception::ExpiredAuthToken
+      raise CloudServers::Exception::Connection, "Authentication token expired and you have requested not to retry" if @retry_auth == false
+      CloudFiles::Authentication.new(self)
+      retry
+    end
+    
+    # Returns the CloudServers::Server object identified by the given id.
+    #
+    #   >> server = cs.get_server(110917)
+    #   => #<CloudServers::Server:0x101407ae8 ...>
+    #   >> server.name
+    #   => "MyServer"
+    def get_server(id)
+      CloudServers::Server.new(self,id)
+    end
+    alias :server :get_server
+    
+    # Returns an array of hashes, one for each server that exists under this account.  The hash keys are :name and :id.
+    #
+    #   >> cs.list_servers
+    #   => [{:name=>"MyServer", :id=>110917}]
+    def list_servers(options = {})
+      url_params = "?limit=#{URI.escape(options[:limit].to_s)}&offset=#{URI.escape(options[:offset].to_s)}" if options[:limit] && options[:offset]
+      response = csreq("GET",svrmgmthost,"#{svrmgmtpath}/servers",svrmgmtport,svrmgmtscheme)
+      CloudServers::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      CloudServers.symbolize_keys(JSON.parse(response.body)["servers"])
+    end
+    alias :servers :list_servers
+    
+    # Returns an array of hashes with more details about each server that exists under this account.  Additional information
+    # includes public and private IP addresses, status, hostID, and more.  All hash keys are symbols except for the metadata
+    # hash, which are verbatim strings.
+    #
+    #   >> cs.list_servers_detail
+    #   => [{:name=>"MyServer", :addresses=>{:public=>["67.23.42.37"], :private=>["10.176.241.237"]}, :metadata=>{"MyData" => "Valid"}, :imageId=>10, :progress=>100, :hostId=>"36143b12e9e48998c2aef79b50e144d2", :flavorId=>1, :id=>110917, :status=>"ACTIVE"}]
+    def list_servers_detail
+      response = csreq("GET",svrmgmthost,"#{svrmgmtpath}/servers/detail",svrmgmtport,svrmgmtscheme)
+      CloudServers::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      CloudServers.symbolize_keys(JSON.parse(response.body)["servers"])
+    end
+    alias :servers_detail :list_servers_detail
+    
+    # Creates a new server instance on Cloud Servers
+    # 
+    # The argument is a hash of options.  The keys :name, :flavorId, and :imageId are required, :metadata and :personality are optional.
+    #
+    # :flavorId and :imageId are numbers identifying a particular server flavor and image to use when building the server.  The :imageId can either
+    # be a stock Cloud Servers image, or one of your own created with the server.create_image method.
+    #
+    # The :metadata argument will take a hash of up to five key/value pairs.  This metadata will be applied to the server at the Cloud Servers
+    # API level.
+    #
+    # The "Personality" option allows you to include up to five files, of 10Kb or less in size, that will be placed on the created server.
+    # For :personality, pass a hash of the form {'local_path' => 'server_path'}.  The file located at local_path will be base64-encoded
+    # and placed at the location identified by server_path on the new server.
+    #
+    # Returns a CloudServers::Server object.  The root password is available in the adminPass instance method.
+    #
+    #   >> server = cs.create_server(:name => "New Server", :imageId => 2, :flavorId => 2, :metadata => {'Racker' => 'Fanatical'}, :personality => {'/Users/me/Pictures/wedding.jpg' => '/root/me.jpg'})
+    #   => #<CloudServers::Server:0x101229eb0 ...>
+    #   >> server.name
+    #   => "NewServer"
+    #   >> server.status
+    #   => "BUILD"
+    #   >> server.adminPass
+    #   => "NewServerSHMGpvI"
+    def create_server(options)
+      raise CloudServers::Exception::MissingArgument, "Server name, flavor ID, and image ID must be supplied" unless (options[:name] && options[:flavorId] && options[:imageId])
+      options[:personality] = get_personality(options[:personality])
+      raise TooManyMetadataItems, "Metadata is limited to a total of #{MAX_PERSONALITY_METADATA_ITEMS} key/value pairs" if options[:metadata].is_a?(Hash) && options[:metadata].keys.size > MAX_PERSONALITY_METADATA_ITEMS
+      data = JSON.generate(:server => options)
+      response = csreq("POST",svrmgmthost,"#{svrmgmtpath}/servers",svrmgmtport,svrmgmtscheme,{'content-type' => 'application/json'},data)
+      CloudServers::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      server_info = JSON.parse(response.body)['server']
+      server = CloudServers::Server.new(self,server_info['id'])
+      server.adminPass = server_info['adminPass']
+      return server
+    end
+    
+    # Returns an array of hashes listing available server images that you have access too, including stock Cloud Servers images and 
+    # any that you have created.  The "id" key in the hash can be used where imageId is required.
+    #
+    #   >> cs.list_images
+    #   => [{:name=>"CentOS 5.2", :id=>2, :updated=>"2009-07-20T09:16:57-05:00", :status=>"ACTIVE", :created=>"2009-07-20T09:16:57-05:00"}, 
+    #       {:name=>"Gentoo 2008.0", :id=>3, :updated=>"2009-07-20T09:16:57-05:00", :status=>"ACTIVE", :created=>"2009-07-20T09:16:57-05:00"},...
+    def list_images
+      response = csreq("GET",svrmgmthost,"#{svrmgmtpath}/images/detail",svrmgmtport,svrmgmtscheme)
+      CloudServers::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      CloudServers.symbolize_keys(JSON.parse(response.body)['images'])
+    end
+    alias :images :list_images
+    
+    # Returns a CloudServers::Image object for the image identified by the provided id.
+    #
+    #   >> image = cs.get_image(8)
+    #   => #<CloudServers::Image:0x101659698 ...>
+    def get_image(id)
+      CloudServers::Image.new(self,id)
+    end
+    alias :image :get_image
+    
+    # Returns an array of hashes listing all available server flavors.  The :id key in the hash can be used when flavorId is required.
+    #
+    #   >> cs.list_flavors
+    #   => [{:name=>"256 server", :id=>1, :ram=>256, :disk=>10}, 
+    #       {:name=>"512 server", :id=>2, :ram=>512, :disk=>20},...
+    def list_flavors
+      response = csreq("GET",svrmgmthost,"#{svrmgmtpath}/flavors/detail",svrmgmtport,svrmgmtscheme)
+      CloudServers::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      CloudServers.symbolize_keys(JSON.parse(response.body)['flavors'])
+    end
+    alias :flavors :list_flavors
+    
+    # Returns a CloudServers::Flavor object for the flavor identified by the provided ID.
+    #
+    #   >> flavor = cs.flavor(1)
+    #   => #<CloudServers::Flavor:0x10156dcc0 @name="256 server", @disk=10, @id=1, @ram=256>
+    def get_flavor(id)
+      CloudServers::Flavor.new(self,id)
+    end
+    alias :flavor :get_flavor
+    
+    # Returns an array of hashes for all Shared IP Groups that are available.  The :id key can be used to find that specific object.
+    #
+    #   >> cs.list_shared_ip_groups
+    #   => [{:name=>"New Group", :id=>127}]
+    def list_shared_ip_groups
+      response = csreq("GET",svrmgmthost,"#{svrmgmtpath}/shared_ip_groups/detail",svrmgmtport,svrmgmtscheme)
+      CloudServers::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      CloudServers.symbolize_keys(JSON.parse(response.body)['sharedIpGroups'])
+    end
+    alias :shared_ip_groups :list_shared_ip_groups
+    
+    # Returns a CloudServers::SharedIPGroup object for the IP group identified by the provided ID.
+    #
+    #   >> sig = cs.get_shared_ip_group(127)
+    #   => #<CloudServers::SharedIPGroup:0x10153ca30  ...>
+    def get_shared_ip_group(id)
+      CloudServers::SharedIPGroup.new(self,id)
+    end
+    alias :shared_ip_group :get_shared_ip_group
+    
+    # Creates a new Shared IP group.  Takes a hash as an argument.  
+    #
+    # Valid hash keys are :name (required) and :server (optional), which indicates the one server to place into this group by default.
+    #
+    #   >> sig = cs.create_shared_ip_group(:name => "Production Web", :server => 110917) 
+    #   => #<CloudServers::SharedIPGroup:0x101501d18 ...>
+    #   >> sig.name
+    #   => "Production Web"
+    #   >> sig.servers
+    #   => [110917]
+    def create_shared_ip_group(options)
+      data = JSON.generate(:sharedIpGroup => options)
+      response = csreq("POST",svrmgmthost,"#{svrmgmtpath}/shared_ip_groups",svrmgmtport,svrmgmtscheme,{'content-type' => 'application/json'},data)
+      CloudServers::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      ip_group = JSON.parse(response.body)['sharedIpGroup']
+      CloudServers::SharedIPGroup.new(self,ip_group['id'])
+    end
+    
+    # Returns the current state of the programatic API limits.  Each account has certain limits on the number of resources
+    # allowed in the account, and a rate of API operations.
+    #
+    # The operation returns a hash.  The :absolute hash key reveals the account resource limits, including the maxmimum 
+    # amount of total RAM that can be allocated (combined among all servers), the maximum members of an IP group, and the 
+    # maximum number of IP groups that can be created.
+    #
+    # The :rate hash key returns an array of hashes indicating the limits on the number of operations that can be performed in a 
+    # given amount of time.  An entry in this array looks like:
+    #
+    #   {:regex=>"^/servers", :value=>50, :verb=>"POST", :remaining=>50, :unit=>"DAY", :resetTime=>1272399820, :URI=>"/servers*"}
+    #
+    # This indicates that you can only run 50 POST operations against URLs in the /servers URI space per day, we have not run
+    # any operations today (50 remaining), and gives the Unix time that the limits reset.
+    #
+    # Another example is:
+    # 
+    #   {:regex=>".*", :value=>10, :verb=>"PUT", :remaining=>10, :unit=>"MINUTE", :resetTime=>1272399820, :URI=>"*"}
+    #
+    # This says that you can run 10 PUT operations on all possible URLs per minute, and also gives the number remaining and the
+    # time that the limit resets.
+    #
+    # Use this information as you're building your applications to put in relevant pauses if you approach your API limitations.
+    def limits
+      response = csreq("GET",svrmgmthost,"#{svrmgmtpath}/limits",svrmgmtport,svrmgmtscheme)
+      CloudServers::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      CloudServers.symbolize_keys(JSON.parse(response.body)['limits'])
+    end
+    
+    private
+    
+    # Sets up standard HTTP headers
+    def headerprep(headers = {}) # :nodoc:
+      default_headers = {}
+      default_headers["X-Auth-Token"] = @authtoken if (authok? && @account.nil?)
+      default_headers["X-Storage-Token"] = @authtoken if (authok? && !@account.nil?)
+      default_headers["Connection"] = "Keep-Alive"
+      default_headers["User-Agent"] = "CloudServers Ruby API #{VERSION}"
+      default_headers["Accept"] = "application/json"
+      default_headers.merge(headers)
+    end
+    
+    # Starts (or restarts) the HTTP connection
+    def start_http(server,path,port,scheme,headers) # :nodoc:
+      if (@http[server].nil?)
+        begin
+          @http[server] = Net::HTTP::Proxy(self.proxy_host, self.proxy_port).new(server,port)
+          if scheme == "https"
+            @http[server].use_ssl = true
+            @http[server].verify_mode = OpenSSL::SSL::VERIFY_NONE
+          end
+          @http[server].start
+        rescue
+          raise ConnectionException, "Unable to connect to #{server}"
+        end
+      end
+    end
+    
+    # Handles parsing the Personality hash to load it up with Base64-encoded data.
+    def get_personality(options)
+      return if options.nil?
+      require 'base64'
+      data = []
+      itemcount = 0
+      options.each do |localpath,svrpath|
+        raise CloudServers::Exception::TooManyPersonalityItems, "Personality files are limited to a total of #{MAX_PERSONALITY_ITEMS} items" if itemcount >= MAX_PERSONALITY_ITEMS
+        raise CloudServers::Exception::PersonalityFilePathTooLong, "Server-side path of #{svrpath} exceeds the maximum length of #{MAX_SERVER_PATH_LENGTH} characters" if svrpath.size > MAX_SERVER_PATH_LENGTH
+        raise CloudServers::Exception::PersonalityFileTooLarge, "Local file #{localpath} exceeds the maximum size of #{MAX_PERSONALITY_FILE_SIZE} bytes" if File.size(localpath) > MAX_PERSONALITY_FILE_SIZE
+        b64 = Base64.encode64(IO.read(localpath))
+        data.push({:path => svrpath, :contents => b64})
+        itemcount += 1
+      end
+      return data
+    end
+        
+  end
+end

data/lib/cloudservers/entity_manager.rb

@@ -0,0 +1,4 @@
+module CloudServers
+  class EntityManager
+  end
+end

data/lib/cloudservers/exception.rb

@@ -0,0 +1,66 @@
+module CloudServers
+  class Exception
+    
+    class CloudServersFault           < StandardError # :nodoc:
+    end
+    class ServiceUnavailable          < StandardError # :nodoc:
+    end
+    class Unauthorized                < StandardError # :nodoc:
+    end
+    class BadRequest                  < StandardError # :nodoc:
+    end
+    class OverLimit                   < StandardError # :nodoc:
+    end
+    class BadMediaType                < StandardError # :nodoc:
+    end
+    class BadMethod                   < StandardError # :nodoc:
+    end
+    class ItemNotFound                < StandardError # :nodoc:
+    end
+    class BuildInProgress             < StandardError # :nodoc:
+    end
+    class ServerCapacityUnavailable   < StandardError # :nodoc:
+    end
+    class BackupOrResizeInProgress    < StandardError # :nodoc:
+    end
+    class ResizeNotAllowed            < StandardError # :nodoc:
+    end
+    class NotImplemented              < StandardError # :nodoc:
+    end
+    
+    # Plus some others that we define here
+    
+    class Other                       < StandardError # :nodoc:
+    end
+    class ExpiredAuthToken            < StandardError # :nodoc:
+    end
+    class MissingArgument             < StandardError # :nodoc:
+    end
+    class TooManyPersonalityItems     < StandardError # :nodoc:
+    end
+    class PersonalityFilePathTooLong  < StandardError # :nodoc:
+    end
+    class PersonalityFileTooLarge     < StandardError # :nodoc:
+    end
+    class Authentication              < StandardError # :nodoc:
+    end
+    class Connection                  < StandardError # :nodoc:
+    end
+        
+    # In the event of a non-200 HTTP status code, this method takes the HTTP response, parses
+    # the JSON from the body to get more information about the exception, then raises the
+    # proper error.  Note that all exceptions are scoped in the CloudServers::Exception namespace.
+    def self.raise_exception(response)
+      return if response.code =~ /^20.$/
+      fault,info = JSON.parse(response.body).first
+      begin
+        exception_class = self.const_get(fault[0,1].capitalize+fault[1,fault.length])
+        raise exception_class, info["message"]
+      rescue NameError
+        raise CloudServers::Exception::Other, "The server returned status #{response.code}"
+      end
+    end
+    
+  end
+end
+

data/lib/cloudservers/flavor.rb

@@ -0,0 +1,31 @@
+module CloudServers
+  class Flavor
+  
+    attr_reader :id
+    attr_reader :name
+    attr_reader :ram
+    attr_reader :disk
+
+    # This class provides an object for the "Flavor" of a server.  The Flavor can generally be taken as the server specification,
+    # providing information on things like memory and disk space.
+    #
+    # The disk attribute is an integer representing the disk space in GB.  The memory attribute is an integer representing the RAM in MB.
+    #
+    # This is called from the get_flavor method on a CloudServers::Connection object, returns a CloudServers::Flavor object, and will likely not be called directly.
+    #
+    #   >> flavor = cs.get_flavor(1)
+    #   => #<CloudServers::Flavor:0x1014f8bc8 @name="256 server", @disk=10, @id=1, @ram=256>
+    #   >> flavor.name
+    #   => "256 server"
+    def initialize(connection,id)
+      response = connection.csreq("GET",connection.svrmgmthost,"#{connection.svrmgmtpath}/flavors/#{URI.escape(id.to_s)}",connection.svrmgmtport,connection.svrmgmtscheme)
+      CloudServers::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      data = JSON.parse(response.body)['flavor']
+      @id   = data['id']
+      @name = data['name']
+      @ram  = data['ram']
+      @disk = data['disk']
+    end
+    
+  end
+end

data/lib/cloudservers/image.rb

@@ -0,0 +1,60 @@
+module CloudServers
+  class Image
+
+    attr_reader :id
+    attr_reader :name
+    attr_reader :serverId
+    attr_reader :updated
+    attr_reader :created
+    attr_reader :status
+    attr_reader :progress
+    
+    # This class provides an object for the "Image" of a server.  The Image refers to the Operating System type and version.
+    #
+    # Returns the Image object identifed by the supplied ID number.  Called from the get_image instance method of CloudServers::Connection,
+    # it will likely not be called directly from user code.
+    #
+    #   >> cs = CloudServers::Connection.new(USERNAME,API_KEY)
+    #   >> image = cs.get_image(2)
+    #   => #<CloudServers::Image:0x1015371c0 ...>
+    #   >> image.name
+    #   => "CentOS 5.2"    
+    def initialize(connection,id)
+      @id = id
+      @connection = connection
+      populate
+    end
+    
+    # Makes the HTTP call to load information about the provided image.  Can also be called directly on the Image object to refresh data.
+    # Returns true if the refresh call succeeds.
+    #
+    #   >> image.populate
+    #   => true
+    def populate
+      response = @connection.csreq("GET",@connection.svrmgmthost,"#{@connection.svrmgmtpath}/images/#{URI.escape(self.id.to_s)}",@connection.svrmgmtport,@connection.svrmgmtscheme)
+      CloudServers::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      data = JSON.parse(response.body)['image']
+      @id = data['id']
+      @name = data['name']
+      @serverId = data['serverId']
+      @updated = DateTime.parse(data['updated'])
+      @created = DateTime.parse(data['created'])
+      @status = data['status']
+      @progress = data['progress']
+      return true
+    end
+    alias :refresh :populate
+    
+    # Delete an image.  This should be returning invalid permissions when attempting to delete system images, but it's not.
+    # Returns true if the deletion succeeds.
+    #
+    #   >> image.delete!
+    #   => true
+    def delete!
+      response = @connection.csreq("DELETE",@connection.svrmgmthost,"#{@connection.svrmgmtpath}/images/#{URI.escape(self.id.to_s)}",@connection.svrmgmtport,@connection.svrmgmtscheme)
+      CloudServers::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      true
+    end
+    
+  end
+end

data/lib/cloudservers/server.rb

@@ -0,0 +1,254 @@
+module CloudServers
+  class Server
+    
+    attr_reader   :id
+    attr_reader   :name
+    attr_reader   :status
+    attr_reader   :progress
+    attr_reader   :addresses
+    attr_reader   :metadata
+    attr_reader   :hostId
+    attr_reader   :imageId
+    attr_reader   :flavorId
+    attr_reader   :metadata
+    attr_accessor :adminPass
+    
+    # This class is the representation of a single Cloud Server object.  The constructor finds the server identified by the specified
+    # ID number, accesses the API via the populate method to get information about that server, and returns the object.
+    #
+    # Will be called via the get_server or create_server methods on the CloudServers::Connection object, and will likely not be called directly.
+    #
+    #   >> server = cs.get_server(110917)
+    #   => #<CloudServers::Server:0x1014e5438 ....>
+    #   >> server.name
+    #   => "RenamedRubyTest"
+    def initialize(connection,id)
+      @connection    = connection
+      @id            = id
+      @svrmgmthost   = connection.svrmgmthost
+      @svrmgmtpath   = connection.svrmgmtpath
+      @svrmgmtport   = connection.svrmgmtport
+      @svrmgmtscheme = connection.svrmgmtscheme
+      populate
+      return self
+    end
+    
+    # Makes the actual API call to get information about the given server object.  If you are attempting to track the status or project of
+    # a server object (for example, when rebuilding, creating, or resizing a server), you will likely call this method within a loop until 
+    # the status becomes "ACTIVE" or other conditions are met.
+    #
+    # Returns true if the API call succeeds.
+    #
+    #  >> server.refresh
+    #  => true
+    def populate
+      response = @connection.csreq("GET",@svrmgmthost,"#{@svrmgmtpath}/servers/#{URI.encode(@id.to_s)}",@svrmgmtport,@svrmgmtscheme)
+      CloudServers::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      data = JSON.parse(response.body)["server"]
+      @id        = data["id"]
+      @name      = data["name"]
+      @status    = data["status"]
+      @progress  = data["progress"]
+      @addresses = CloudServers.symbolize_keys(data["addresses"])
+      @metadata  = data["metadata"]
+      @hostId    = data["hostId"]
+      @imageId   = data["imageId"]
+      @flavorId  = data["flavorId"]
+      @metadata  = data["metadata"]
+      true
+    end
+    alias :refresh :populate
+    
+    # Returns a new CloudServers::Flavor object for the flavor assigned to this server.
+    #
+    #   >> flavor = server.flavor
+    #   => #<CloudServers::Flavor:0x1014aac20 @name="256 server", @disk=10, @id=1, @ram=256>
+    #   >> flavor.name
+    #   => "256 server"
+    def flavor
+      CloudServers::Flavor.new(@connection,self.flavorId)
+    end
+    
+    # Returns a new CloudServers::Image object for the image assigned to this server.
+    #
+    #   >> image = server.image
+    #   => #<CloudServers::Image:0x10149a960 ...>
+    #   >> image.name
+    #   => "Ubuntu 8.04.2 LTS (hardy)"
+    def image
+      CloudServers::Image.new(@connection,self.imageId)
+    end
+    
+    # Sends an API request to reboot this server.  Takes an optional argument for the type of reboot, which can be "SOFT" (graceful shutdown)
+    # or "HARD" (power cycle).  The hard reboot is also triggered by server.reboot!, so that may be a better way to call it.
+    #
+    # Returns true if the API call succeeds.
+    #
+    #   >> server.reboot
+    #   => true
+    def reboot(type="SOFT")
+      data = JSON.generate(:reboot => {:type => type})
+      response = @connection.csreq("POST",@svrmgmthost,"#{@svrmgmtpath}/servers/#{URI.encode(self.id.to_s)}/action",@svrmgmtport,@svrmgmtscheme,{'content-type' => 'application/json'},data)
+      CloudServers::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      true
+    end
+    
+    # Sends an API request to hard-reboot (power cycle) the server.  See the reboot method for more information.
+    #
+    # Returns true if the API call succeeds.
+    #
+    #   >> server.reboot!
+    #   => true
+    def reboot!
+      self.reboot("HARD")
+    end
+    
+    # Updates various parameters about the server.  Currently, the only operations supported are changing the server name (not the actual hostname
+    # on the server, but simply the label in the Cloud Servers API) and the administrator password (note: changing the admin password will trigger
+    # a reboot of the server).  Other options are ignored.  One or both key/value pairs may be provided.  Keys are case-sensitive.
+    #
+    # Input hash key values are :name and :adminPass.  Returns true if the API call succeeds.
+    #
+    #   >> server.update(:name => "MyServer", :adminPass => "12345")
+    #   => true
+    #   >> server.name
+    #   => "MyServer"
+    def update(options)
+      data = JSON.generate(:server => options)
+      response = @connection.csreq("PUT",@svrmgmthost,"#{@svrmgmtpath}/servers/#{URI.encode(self.id.to_s)}",@svrmgmtport,@svrmgmtscheme,{'content-type' => 'application/json'},data)
+      CloudServers::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      # If we rename the instance, repopulate the object
+      self.populate if options[:name]
+      true
+    end
+    
+    # Deletes the server from Cloud Servers.  The server will be shut down, data deleted, and billing stopped.
+    #
+    # Returns true if the API call succeeds.
+    #
+    #   >> server.delete!
+    #   => true
+    def delete!
+      response = @connection.csreq("DELETE",@svrmgmthost,"#{@svrmgmtpath}/servers/#{URI.encode(self.id.to_s)}",@svrmgmtport,@svrmgmtscheme)
+      CloudServers::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      true
+    end
+    
+    # Takes the existing server and rebuilds it with the image identified by the imageId argument.  If no imageId is provided, the current image
+    # will be used.
+    #
+    # This will wipe and rebuild the server, but keep the server ID number, name, and IP addresses the same.
+    #
+    # Returns true if the API call succeeds.
+    #
+    #   >> server.rebuild!
+    #   => true
+    def rebuild!(imageId = self.imageId)
+      data = JSON.generate(:rebuild => {:imageId => imageId})
+      response = @connection.csreq("POST",@svrmgmthost,"#{@svrmgmtpath}/servers/#{URI.encode(self.id.to_s)}/action",@svrmgmtport,@svrmgmtscheme,{'content-type' => 'application/json'},data)
+      CloudServers::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      self.populate
+      true
+    end
+    
+    # Takes a snapshot of the server and creates a server image from it.  That image can then be used to build new servers.  The
+    # snapshot is saved asynchronously.  Check the image status to make sure that it is ACTIVE before attempting to perform operations
+    # on it.
+    # 
+    # A name string for the saved image must be provided.  A new CloudServers::Image object for the saved image is returned.
+    #
+    # The image is saved as a backup, of which there are only three available slots.  If there are no backup slots available, 
+    # A CloudServers::Exception::CloudServersFault will be raised.
+    #
+    #   >> image = server.create_image("My Rails Server")
+    #   => 
+    def create_image(name)
+      data = JSON.generate(:image => {:serverId => self.id, :name => name})
+      response = @connection.csreq("POST",@svrmgmthost,"#{@svrmgmtpath}/images",@svrmgmtport,@svrmgmtscheme,{'content-type' => 'application/json'},data)
+      CloudServers::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      CloudServers::Image.new(@connection,JSON.parse(response.body)['image']['id'])
+    end
+    
+    # Resizes the server to the size contained in the server flavor found at ID flavorId.  The server name, ID number, and IP addresses 
+    # will remain the same.  After the resize is done, the server.status will be set to "VERIFY_RESIZE" until the resize is confirmed or reverted.
+    #
+    # Refreshes the CloudServers::Server object, and returns true if the API call succeeds.
+    # 
+    #   >> server.resize!(1)
+    #   => true
+    def resize!(flavorId)
+      data = JSON.generate(:resize => {:flavorId => flavorId})
+      response = @connection.csreq("POST",@svrmgmthost,"#{@svrmgmtpath}/servers/#{URI.encode(self.id.to_s)}/action",@svrmgmtport,@svrmgmtscheme,{'content-type' => 'application/json'},data)
+      CloudServers::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      self.populate
+      true
+    end
+    
+    # After a server resize is complete, calling this method will confirm the resize with the Cloud Servers API, and discard the fallback/original image.
+    #
+    # Returns true if the API call succeeds.
+    #
+    #   >> server.confirm_resize!
+    #   => true
+    def confirm_resize!
+      # If the resize bug gets figured out, should put a check here to make sure that it's in the proper state for this.
+      data = JSON.generate(:confirmResize => nil)
+      response = @connection.csreq("POST",@svrmgmthost,"#{@svrmgmtpath}/servers/#{URI.encode(self.id.to_s)}/action",@svrmgmtport,@svrmgmtscheme,{'content-type' => 'application/json'},data)
+      CloudServers::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      self.populate
+      true
+    end
+    
+    # After a server resize is complete, calling this method will reject the resized server with the Cloud Servers API, destroying
+    # the new image and replacing it with the pre-resize fallback image.
+    #
+    # Returns true if the API call succeeds.
+    #
+    #   >> server.confirm_resize!
+    #   => true
+    def revert_resize!
+      # If the resize bug gets figured out, should put a check here to make sure that it's in the proper state for this.
+      data = JSON.generate(:revertResize => nil)
+      response = @connection.csreq("POST",@svrmgmthost,"#{@svrmgmtpath}/servers/#{URI.encode(self.id.to_s)}/action",@svrmgmtport,@svrmgmtscheme,{'content-type' => 'application/json'},data)
+      CloudServers::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      self.populate
+      true
+    end
+    
+    # Provides information about the backup schedule for this server.  Returns a hash of the form 
+    # {"weekly" => state, "daily" => state, "enabled" => boolean}
+    #
+    #   >> server.backup_schedule
+    #   => {"weekly"=>"THURSDAY", "daily"=>"H_0400_0600", "enabled"=>true}
+    def backup_schedule
+      response = @connection.csreq("GET",@svrmgmthost,"#{@svrmgmtpath}/servers/#{URI.encode(@id.to_s)}/backup_schedule",@svrmgmtport,@svrmgmtscheme)
+      CloudServers::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      JSON.parse(response.body)['backupSchedule']
+    end
+    
+    # Updates the backup schedule for the server.  Takes a hash of the form: {:weekly => state, :daily => state, :enabled => boolean} as an argument.
+    # All three keys (:weekly, :daily, :enabled) must be provided or an exception will get raised.
+    #
+    #   >> server.backup_schedule=({:weekly=>"THURSDAY", :daily=>"H_0400_0600", :enabled=>true})
+    #   => {:weekly=>"THURSDAY", :daily=>"H_0400_0600", :enabled=>true}
+    def backup_schedule=(options)
+      data = JSON.generate('backupSchedule' => options)
+      response = @connection.csreq("POST",@svrmgmthost,"#{@svrmgmtpath}/servers/#{URI.encode(self.id.to_s)}/backup_schedule",@svrmgmtport,@svrmgmtscheme,{'content-type' => 'application/json'},data)
+      CloudServers::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      true
+    end
+    
+    # Removes the existing backup schedule for the server, setting the backups to disabled.
+    #
+    # Returns true if the API call succeeds.
+    #
+    #   >> server.disable_backup_schedule!
+    #   => true
+    def disable_backup_schedule!
+      response = @connection.csreq("DELETE",@svrmgmthost,"#{@svrmgmtpath}/servers/#{URI.encode(self.id.to_s)}/backup_schedule",@svrmgmtport,@svrmgmtscheme)
+      CloudServers::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      true
+    end
+    
+  end
+end

data/lib/cloudservers/shared_ip_group.rb

@@ -0,0 +1,52 @@
+module CloudServers
+  class SharedIPGroup
+    
+    attr_reader :id
+    attr_reader :name
+    attr_reader :servers
+    
+    # Creates a new Shared IP Group object, with information on the group identified by the ID number.  Will most likely be called 
+    # by the get_shared_ip_group method on a CloudServers::Connection object.
+    #
+    #   >> sig = cs.get_shared_ip_group(127)
+    #   => #<CloudServers::SharedIPGroup:0x101513798 ...>
+    #   >> sig.name
+    #   => "New Group"
+    def initialize(connection,id)
+      @connection = connection
+      @id = id
+      populate
+    end
+    
+    # Makes the API call that populates the CloudServers::SharedIPGroup object with information on the group.  Can also be called directly on
+    # an existing object to update its information.
+    # 
+    # Returns true if the API call succeeds.
+    #
+    #   >> sig.populate
+    #   => true
+    def populate
+      response = @connection.csreq("GET",@connection.svrmgmthost,"#{@connection.svrmgmtpath}/shared_ip_groups/#{URI.escape(self.id.to_s)}",@connection.svrmgmtport,@connection.svrmgmtscheme)
+      CloudServers::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      data = JSON.parse(response.body)['sharedIpGroup']
+      @id = data['id']
+      @name = data['name']
+      @servers = data['servers']
+      true
+    end
+    alias :refresh :populate
+    
+    # Deletes the Shared IP Group identified by the current object.
+    #
+    # Returns true if the API call succeeds.
+    #
+    #   >> sig.delete!
+    #   => true
+    def delete!
+      response = @connection.csreq("DELETE",@connection.svrmgmthost,"#{@connection.svrmgmtpath}/shared_ip_groups/#{URI.escape(self.id.to_s)}",@connection.svrmgmtport,@connection.svrmgmtscheme)
+      CloudServers::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      true
+    end
+    
+  end
+end

data/lib/cloudservers.rb

@@ -0,0 +1,83 @@
+#!/usr/bin/env ruby
+# 
+# == Cloud Servers API
+# ==== Connects Ruby Applications to Rackspace's {Cloud Servers service}[http://www.rackspacecloud.com/cloud_hosting_products/servers]
+# By H. Wade Minter <wade.minter@rackspace.com> and Mike Mayo <mike.mayo@rackspace.com>
+#
+# See COPYING for license information.
+# Copyright (c) 2009, Rackspace US, Inc.
+# ----
+# 
+# === Documentation & Examples
+# To begin reviewing the available methods and examples, peruse the README.rodc file, or begin by looking at documentation for the 
+# CloudServers::Connection class.
+#
+# The CloudServers class is the base class.  Not much of note aside from housekeeping happens here.
+# To create a new CloudServers connection, use the CloudServers::Connection.new('user_name', 'api_key') method.
+
+module CloudServers
+
+  VERSION = IO.read(File.dirname(__FILE__) + '/../VERSION')
+  require 'net/http'
+  require 'net/https'
+  require 'uri'
+  require 'rubygems'
+  require 'json'
+
+  unless "".respond_to? :each_char
+    require "jcode"
+    $KCODE = 'u'
+  end
+
+  $:.unshift(File.dirname(__FILE__))
+  require 'cloudservers/authentication'
+  require 'cloudservers/connection'
+  require 'cloudservers/server'
+  require 'cloudservers/image'
+  require 'cloudservers/flavor'
+  require 'cloudservers/shared_ip_group'
+  require 'cloudservers/exception'
+  
+  # Constants that set limits on server creation
+  MAX_PERSONALITY_ITEMS = 5
+  MAX_PERSONALITY_FILE_SIZE = 10240
+  MAX_SERVER_PATH_LENGTH = 255
+  MAX_PERSONALITY_METADATA_ITEMS = 5
+  
+  # Helper method to recursively symbolize hash keys.
+  def self.symbolize_keys(obj)
+    case obj
+    when Array
+      obj.inject([]){|res, val|
+        res << case val
+        when Hash, Array
+          symbolize_keys(val)
+        else
+          val
+        end
+        res
+      }
+    when Hash
+      obj.inject({}){|res, (key, val)|
+        nkey = case key
+        when String
+          key.to_sym
+        else
+          key
+        end
+        nval = case val
+        when Hash, Array
+          symbolize_keys(val)
+        else
+          val
+        end
+        res[nkey] = nval
+        res
+      }
+    else
+      obj
+    end
+  end
+  
+
+end

data/test/cloudservers_authentication_test.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class CloudserversAuthenticationTest < Test::Unit::TestCase
+  
+
+  def test_good_authentication
+    response = {'x-cdn-management-url' => 'http://cdn.example.com/path', 'x-storage-url' => 'http://cdn.example.com/storage', 'authtoken' => 'dummy_token'}
+    response.stubs(:code).returns('204')
+    server = mock(:use_ssl= => true, :verify_mode= => true, :start => true, :finish => true)
+    server.stubs(:get).returns(response)
+    Net::HTTP.stubs(:new).returns(server)
+    @connection = stub(:authuser => 'dummy_user', :authkey => 'dummy_key', :cdnmgmthost= => true, :cdnmgmtpath= => true, :cdnmgmtport= => true, :cdnmgmtscheme= => true, :storagehost= => true, :storagepath= => true, :storageport= => true, :storagescheme= => true, :authtoken= => true, :authok= => true)
+    result = CloudServers::Authentication.new(@connection)
+    assert_equal result.class, CloudServers::Authentication
+  end
+  
+  def test_bad_authentication
+    response = mock()
+    response.stubs(:code).returns('499')
+    server = mock(:use_ssl= => true, :verify_mode= => true, :start => true)
+    server.stubs(:get).returns(response)
+    Net::HTTP.stubs(:new).returns(server)
+    @connection = stub(:authuser => 'bad_user', :authkey => 'bad_key', :authok= => true, :authtoken= => true)
+    assert_raises(AuthenticationException) do
+      result = CloudServers::Authentication.new(@connection)
+    end
+  end
+    
+  def test_bad_hostname
+    Net::HTTP.stubs(:new).raises(ConnectionException)
+    @connection = stub(:authuser => 'bad_user', :authkey => 'bad_key', :authok= => true, :authtoken= => true)
+    assert_raises(ConnectionException) do
+      result = CloudServers::Authentication.new(@connection)
+    end
+  end
+    
+end

data/test/test_helper.rb

@@ -0,0 +1,5 @@
+require 'test/unit'
+$:.unshift File.dirname(__FILE__) + '/../lib'
+require 'cloudservers'
+require 'rubygems'
+require 'mocha'

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification 
+name: cloudservers
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 0
+  version: 0.2.0
+platform: ruby
+authors: 
+- H. Wade Minter
+- Mike Mayo
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-06 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: A Ruby API to version 1.0 of the Rackspace Cloud Servers product.
+email: wade.minter@rackspace.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- TODO
+files: 
+- .gitignore
+- COPYING
+- README.rdoc
+- Rakefile
+- TODO
+- VERSION
+- cloudservers.gemspec
+- lib/cloudservers.rb
+- lib/cloudservers/authentication.rb
+- lib/cloudservers/connection.rb
+- lib/cloudservers/entity_manager.rb
+- lib/cloudservers/exception.rb
+- lib/cloudservers/flavor.rb
+- lib/cloudservers/image.rb
+- lib/cloudservers/server.rb
+- lib/cloudservers/shared_ip_group.rb
+- test/cloudservers_authentication_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/rackspace/cloudservers
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Rackspace Cloud Servers Ruby API
+test_files: 
+- test/cloudservers_authentication_test.rb
+- test/test_helper.rb