openstack-compute 1.0.2 → 1.1.0.pre0

data/README.rdoc

@@ -2,9 +2,7 @@
 
 == Description
 
-Ruby Openstack Compute binding for the v1.0 OSAPI.
-
-Currently supports both v1.0 and v2.0 (keystone) auth.
+Ruby Openstack Compute binding.
 
 == Examples
 
@@ -12,7 +10,7 @@ See the class definitions for documentation on specific methods and operations.
 
   require 'openstack/compute'
 
-  cs = OpenStack::Compute::Connection.new(:username => USERNAME, :api_key => API_KEY, :auth_url => API_URL)	
+  cs = OpenStack::Compute::Connection.new(:username => USERNAME, :api_key => API_KEY, :api_url => API_URL)	
 
   # Get a listing of all current servers
   >> cs.servers

data/VERSION

@@ -1 +1 @@
-1.0.2
+1.1.0.pre0

data/lib/openstack/compute.rb

@@ -9,7 +9,7 @@
 # To begin reviewing the available methods and examples, view the README.rdoc file, or begin by looking at documentation for the OpenStack::Compute::Connection class.
 #
 # Example:
-# OpenStack::Compute::Connection.new(:username => USERNAME, :api_key => API_KEY, :auth_url => API_URL) method.
+# OpenStack::Compute::Connection.new(:username => USERNAME, :api_key => API_KEY, :api_url => API_URL) method.
 module OpenStack
 module Compute
 
@@ -38,7 +38,6 @@ module Compute
   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)

data/lib/openstack/compute/authentication.rb

@@ -1,70 +1,19 @@
 module OpenStack
 module Compute
-
   class Authentication
-
-    # Performs an authentication to the OpenStack auth server.
-    # If it succeeds, it sets the svrmgmthost, svrmgtpath, svrmgmtport,
-    # svrmgmtscheme, authtoken, and authok variables on the connection.
-    # If it fails, it raises an exception.
-    def self.init(conn)
-      if conn.auth_path =~ /.*v2.0\/?$/
-        AuthV20.new(conn)
-      else
-        AuthV10.new(conn)
-      end
-    end
-
-  end
-
-  private
-  class AuthV20
-    
-    def initialize(connection)
-      begin
-        server = Net::HTTP::Proxy(connection.proxy_host, connection.proxy_port).new(connection.auth_host, connection.auth_port)
-        if connection.auth_scheme == "https"
-          server.use_ssl = true
-          server.verify_mode = OpenSSL::SSL::VERIFY_NONE
-        end
-        server.start
-      rescue
-        raise OpenStack::Compute::Exception::Connection, "Unable to connect to #{server}"
-      end
-
-      auth_data = JSON.generate({ "passwordCredentials" => { "username" => connection.authuser, "password" => connection.authkey }})
-      response = server.post(connection.auth_path.chomp("/")+"/tokens", auth_data, {'Content-Type' => 'application/json'})
-      if (response.code =~ /^20./)
-        resp_data=JSON.parse(response.body)
-        connection.authtoken = resp_data['auth']['token']['id']
-        if resp_data['auth']['serviceCatalog'] and resp_data['auth']['serviceCatalog'][connection.service_name] and resp_data['auth']['serviceCatalog'][connection.service_name][0] then
-          uri = URI.parse(resp_data['auth']['serviceCatalog'][connection.service_name][0]['publicURL'])
-          connection.svrmgmthost = uri.host
-          connection.svrmgmtpath = uri.path
-          # Force the path into the v1.0 URL space
-          connection.svrmgmtpath.sub!(/\/.*\/?/, '/v1.0/')
-          connection.svrmgmtport = uri.port
-          connection.svrmgmtscheme = uri.scheme
-          connection.authok = true
-        else
-          connection.authok = false
-        end
-      else
-        connection.authtoken = false
-        raise OpenStack::Compute::Exception::Authentication, "Authentication failed with response code #{response.code}"
-      end
-      server.finish
-    end
-  end
-
-  class AuthV10
     
+    # Performs an authentication to the OpenStack 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'
+      path = connection.api_path
       hdrhash = { "X-Auth-User" => connection.authuser, "X-Auth-Key" => connection.authkey }
       begin
-        server = Net::HTTP::Proxy(connection.proxy_host, connection.proxy_port).new(connection.auth_host, connection.auth_port)
-        if connection.auth_scheme == "https"
+        server = Net::HTTP::Proxy(connection.proxy_host, connection.proxy_port).new(connection.api_host, connection.api_port)
+        if connection.api_scheme == "https"
           server.use_ssl = true
           server.verify_mode = OpenSSL::SSL::VERIFY_NONE
         end
@@ -75,13 +24,11 @@ module Compute
       response = server.get(path,hdrhash)
       if (response.code =~ /^20./)
         connection.authtoken = response["x-auth-token"]
-        uri = URI.parse(response["x-server-management-url"])
-        connection.svrmgmthost = uri.host
-        connection.svrmgmtpath = uri.path
+        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.port
-        connection.svrmgmtscheme = uri.scheme
+        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
@@ -90,6 +37,5 @@ module Compute
       server.finish
     end
   end
-
 end
 end

data/lib/openstack/compute/connection.rb

@@ -10,11 +10,10 @@ module Compute
     attr_accessor :svrmgmtpath
     attr_accessor :svrmgmtport
     attr_accessor :svrmgmtscheme
-    attr_reader   :auth_host
-    attr_reader   :auth_port
-    attr_reader   :auth_scheme
-    attr_reader   :auth_path
-    attr_accessor :service_name
+    attr_reader   :api_host
+    attr_reader   :api_port
+    attr_reader   :api_scheme
+    attr_reader   :api_path
     attr_reader   :proxy_host
     attr_reader   :proxy_port
     
@@ -24,37 +23,36 @@ module Compute
     #
     #   :username - Your Openstack username *required*
     #   :api_key - Your Openstack API key *required*
-    #   :auth_url - Configurable auth_url endpoint.
-    #   :service_name - (Optional for v2.0 auth only). The name of the compute service to use. Defaults to 'nova'.
+    #   :api_url - The url of the Openstack Compute API server.
     #   :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 = OpenStack::Compute::Connection.new(:username => 'USERNAME', :api_key => 'API_KEY', :auth_url => 'AUTH_URL')
+    #   cf = OpenStack::Compute::Connection.new(:username => 'USERNAME', :api_key => 'API_KEY', :api_url => 'API_URL')
     def initialize(options = {:retry_auth => true}) 
       @authuser = options[:username] || (raise Exception::MissingArgument, "Must supply a :username")
       @authkey = options[:api_key] || (raise Exception::MissingArgument, "Must supply an :api_key")
-      @auth_url = options[:auth_url] || (raise Exception::MissingArgument, "Must supply an :auth_url")
-      @service_name = options[:service_name] || "nova"
+      @api_url = options[:api_url] || (raise Exception::MissingArgument, "Must supply an :api_url")
+      @is_debug = options[:is_debug]
 
-      auth_uri=nil
+      api_uri=nil
       begin
-        auth_uri=URI.parse(@auth_url)
+        api_uri=URI.parse(@api_url)
       rescue Exception => e
-        raise Exception::InvalidArgument, "Invalid :auth_url parameter: #{e.message}"
+        raise Exception::InvalidArgument, "Invalid :api_url parameter: #{e.message}"
       end
-      raise Exception::InvalidArgument, "Invalid :auth_url parameter." if auth_uri.nil? or auth_uri.host.nil?
-      @auth_host = auth_uri.host
-      @auth_port = auth_uri.port
-      @auth_scheme = auth_uri.scheme
-      @auth_path = auth_uri.path
+      raise Exception::InvalidArgument, "Invalid :api_url parameter." if api_uri.nil? or api_uri.host.nil?
+      @api_host = api_uri.host
+      @api_port = api_uri.port
+      @api_scheme = api_uri.scheme
+      @api_path = api_uri.path.sub(/\/$/, '')
 
       @retry_auth = options[:retry_auth]
       @proxy_host = options[:proxy_host]
       @proxy_port = options[:proxy_port]
       @authok = false
       @http = {}
-      OpenStack::Compute::Authentication.init(self)
+      OpenStack::Compute::Authentication.new(self)
     end
     
     # Returns true if the authentication was successful and returns false otherwise.
@@ -64,7 +62,7 @@ module Compute
     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
@@ -73,6 +71,12 @@ module Compute
       request = Net::HTTP.const_get(method.to_s.capitalize).new(path,hdrhash)
       request.body = data
       response = @http[server].request(request)
+      if @is_debug
+          puts "REQUEST: #{method} => #{path}"
+          puts data if data
+          puts "RESPONSE: #{response.body}"
+          puts '----------------------------------------'
+      end
       raise OpenStack::Compute::Exception::ExpiredAuthToken if response.code == "401"
       response
     rescue Errno::EPIPE, Timeout::Error, Errno::EINVAL, EOFError
@@ -84,10 +88,27 @@ module Compute
       retry
     rescue OpenStack::Compute::Exception::ExpiredAuthToken
       raise OpenStack::Compute::Exception::Connection, "Authentication token expired and you have requested not to retry" if @retry_auth == false
-      OpenStack::Compute::Authentication.init(self)
+      OpenStack::Compute::Authentication.new(self)
       retry
     end
-    
+
+    # This is a much more sane way to make a http request to the api.
+    # Example: res = conn.req('GET', "/servers/#{id}")
+    def req(method, path, options = {})
+      server   = options[:server]   || @svrmgmthost
+      port     = options[:port]     || @svrmgmtport
+      scheme   = options[:scheme]   || @svrmgmtscheme
+      headers  = options[:headers]  || {'content-type' => 'application/json'}
+      data     = options[:data]
+      attempts = options[:attempts] || 0
+      path = @svrmgmtpath + path
+      res = csreq(method,server,path,port,scheme,headers,data,attempts)
+      if not res.code.match(/^20.$/)
+        OpenStack::Compute::Exception.raise_exception(res)
+      end
+      return res
+    end;
+
     # Returns the OpenStack::Compute::Server object identified by the given id.
     #
     #   >> server = cs.get_server(110917)
@@ -139,21 +160,32 @@ module Compute
     
     # Creates a new server instance on OpenStack Compute
     # 
-    # The argument is a hash of options.  The keys :name, :flavorId, and :imageId are required, :metadata and :personality are optional.
+    # The argument is a hash of options.  The keys :name, :flavorRef,
+    # and :imageRef 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 image, or one of your own created with the server.create_image method.
+    # :flavorRef and :imageRef are href strings identifying a particular
+    # server flavor and image to use when building the server.  The :imageRef
+    # can either be a stock 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 OpenStack Compute
-    # API level.
+    # The :metadata argument should be a hash of key/value pairs.  This
+    # metadata will be applied to the server at the OpenStack Compute 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.
+    # 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 OpenStack::Compute::Server object.  The root password is available in the adminPass instance method.
+    # Returns a OpenStack::Compute::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'})
+    #   >> server = cs.create_server(
+    #        :name        => 'NewServer',
+    #        :imageRef    => 'http://172.19.0.3/v1.1/images/3',
+    #        :flavorRef   => 'http://172.19.0.3/v1.1/flavors/1',
+    #        :metadata    => {'Racker' => 'Fanatical'},
+    #        :personality => {'/home/bob/wedding.jpg' => '/root/wedding.jpg'})
     #   => #<OpenStack::Compute::Server:0x101229eb0 ...>
     #   >> server.name
     #   => "NewServer"
@@ -162,9 +194,8 @@ module Compute
     #   >> server.adminPass
     #   => "NewServerSHMGpvI"
     def create_server(options)
-      raise OpenStack::Compute::Exception::MissingArgument, "Server name, flavor ID, and image ID must be supplied" unless (options[:name] && options[:flavorId] && options[:imageId])
+      raise OpenStack::Compute::Exception::MissingArgument, "Server name, flavorRef, and imageRef, must be supplied" unless (options[:name] && options[:flavorRef] && options[:imageRef])
       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)
       OpenStack::Compute::Exception.raise_exception(response) unless response.code.match(/^20.$/)

data/lib/openstack/compute/image.rb

@@ -2,6 +2,8 @@ module OpenStack
 module Compute
   class Image
 
+    require 'compute/metadata'
+
     attr_reader :id
     attr_reader :name
     attr_reader :serverId
@@ -9,6 +11,7 @@ module Compute
     attr_reader :created
     attr_reader :status
     attr_reader :progress
+    attr_reader :metadata
     
     # This class provides an object for the "Image" of a server.  The Image refers to the Operating System type and version.
     #
@@ -23,6 +26,7 @@ module Compute
     def initialize(connection,id)
       @id = id
       @connection = connection
+      @metadata  = OpenStack::Compute::ImageMetadata.new(connection, id)
       populate
     end
     

data/lib/openstack/compute/metadata.rb

@@ -0,0 +1,52 @@
+module OpenStack
+module Compute
+
+  class AbstractMetadata
+
+    def initialize(connection, server_id)
+      @connection = connection
+      @server_id  = server_id
+    end
+
+    def get_item(key)
+      response = @connection.req('GET', "#{@base_url}/#{key}")
+      return JSON.parse(response.body)['meta'][key]
+    end
+
+    def set_item(key, value)
+      json = JSON.generate(:meta => { key => value })
+      @connection.req('PUT', "#{@base_url}/#{key}", :data => json)
+    end
+
+    def delete_item(key)
+      @connection.req('DELETE', "#{@base_url}/#{key}")
+    end
+
+    def get_data()
+      response = @connection.req('GET', @base_url)
+      return JSON.parse(response.body)['metadata']
+    end
+
+    def set_data(data = {})
+      json = JSON.generate(:metadata => data)
+      @connection.req('POST', @base_url, :data => json)
+    end
+
+  end
+
+  class ServerMetadata < AbstractMetadata
+    def initialize(connection, server_id)
+      super(connection, server_id)
+      @base_url = "/servers/#{@server_id}/metadata"
+    end
+  end
+
+  class ImageMetadata < AbstractMetadata
+    def initialize(connection, server_id)
+      super(connection, server_id)
+      @base_url = "/images/#{@server_id}/metadata"
+    end
+  end
+
+end
+end

data/lib/openstack/compute/server.rb

@@ -2,15 +2,17 @@ module OpenStack
 module Compute
   class Server
     
+    require 'compute/metadata'
+
     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 Server object.  The constructor finds the server identified by the specified
@@ -50,10 +52,10 @@ module Compute
       @status    = data["status"]
       @progress  = data["progress"]
       @addresses = OpenStack::Compute.symbolize_keys(data["addresses"])
-      @metadata  = data["metadata"]
+      @metadata  = OpenStack::Compute::ServerMetadata.new(@connection, @id)
       @hostId    = data["hostId"]
-      @imageId   = data["imageId"]
-      @flavorId  = data["flavorId"]
+      @imageId   = data["image"]["id"]
+      @flavorId  = data["flavor"]["id"]
       true
     end
     alias :refresh :populate
@@ -65,7 +67,7 @@ module Compute
     #   >> flavor.name
     #   => "256 server"
     def flavor
-      OpenStack::Compute::Flavor.new(@connection,self.flavorId)
+      OpenStack::Compute::Flavor.new(@connection, self.flavorId)
     end
     
     # Returns a new OpenStack::Compute::Image object for the image assigned to this server.
@@ -75,7 +77,7 @@ module Compute
     #   >> image.name
     #   => "Ubuntu 8.04.2 LTS (hardy)"
     def image
-      OpenStack::Compute::Image.new(@connection,self.imageId)
+      OpenStack::Compute::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)
@@ -133,19 +135,36 @@ module Compute
       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.
+    # The rebuild function removes all data on the server and replaces it with
+    # the specified image. The serverRef and all IP addresses will remain the
+    # same. If name and metadata are specified, they will replace existing
+    # values, otherwise they will not change. A rebuild operation always
+    # removes data injected into the file system via server personality. You
+    # may reinsert data into the filesystem during the rebuild.
+    #
+    # This method expects a hash of the form:
+    # {
+    #   :imageId => "https://foo.com/v1.1/images/2",
+    #   :name => "newName",
+    #   :metadata => { :values => { :foo : "bar" } },
+    #   :personality => [
+    #     {
+    #       :path => "/etc/banner.txt",
+    #       :contents => : "ICAgpY2hhcmQgQmFjaA=="
+    #     }
+    #   ]
+    # }
+    #
+    # 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)
-      OpenStack::Compute::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+    def rebuild!(options)
+      json = JSON.generate(:rebuild => options)
+      @connection.req('POST', "/servers/#{@id}/action", :data => json)
       self.populate
       true
     end
@@ -214,6 +233,14 @@ module Compute
       true
     end
     
+    # Changes the admin password.
+    # Returns the password if it succeeds.
+    def change_password!(password)
+      json = JSON.generate(:changePassword => { :adminPass => password })
+      @connection.req('POST', "/servers/#{@id}/action", :data => json)
+      @adminPass = password
+    end
+
   end
 end
 end

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: openstack-compute
 version: !ruby/object:Gem::Version 
-  hash: 19
-  prerelease: false
+  hash: -1876988165
+  prerelease: true
   segments: 
   - 1
+  - 1
   - 0
-  - 2
-  version: 1.0.2
+  - pre0
+  version: 1.1.0.pre0
 platform: ruby
 authors: 
 - Dan Prince
@@ -15,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-07 00:00:00 -04:00
+date: 2011-10-13 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -50,19 +51,15 @@ files:
 - lib/openstack/compute/exception.rb
 - lib/openstack/compute/flavor.rb
 - lib/openstack/compute/image.rb
+- lib/openstack/compute/metadata.rb
 - lib/openstack/compute/server.rb
-- test/authentication_test.rb
-- test/exception_test.rb
-- test/test_helper.rb
-- test/connection_test.rb
-- test/servers_test.rb
 has_rdoc: true
 homepage: https://launchpad.net/ruby-openstack-compute
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -77,12 +74,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version 
-      hash: 3
+      hash: 25
       segments: 
-      - 0
-      version: "0"
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
 requirements: []
 
 rubyforge_project: 
@@ -90,9 +89,5 @@ rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: OpenStack Compute Ruby API
-test_files: 
-- test/authentication_test.rb
-- test/exception_test.rb
-- test/test_helper.rb
-- test/connection_test.rb
-- test/servers_test.rb
+test_files: []
+

data/test/authentication_test.rb

@@ -1,36 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-class AuthenticationTest < Test::Unit::TestCase
- 
-  def test_good_authentication
-    response = {'x-server-management-url' => 'http://server-manage.example.com/path', 'x-auth-token' => '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 => 'bad_user', :authkey => 'bad_key', :auth_host => "a.b.c", :auth_port => "443", :auth_scheme => "https", :auth_path => "/v1.0", :authok= => true, :authtoken= => true, :svrmgmthost= => "", :svrmgmtpath= => "", :svrmgmtpath => "", :svrmgmtport= => "", :svrmgmtscheme= => "", :proxy_host => nil, :proxy_port => nil)
-    result = OpenStack::Compute::Authentication.init(connection)
-    assert_equal result.class, OpenStack::Compute::AuthV10
-  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', :auth_host => "a.b.c", :auth_port => "443", :auth_scheme => "https", :auth_path => "/v1.0", :authok= => true, :authtoken= => true, :proxy_host => nil, :proxy_port => nil)
-    assert_raises(OpenStack::Compute::Exception::Authentication) do
-      result = OpenStack::Compute::Authentication.init(connection)
-    end
-  end
-    
-  def test_bad_hostname
-    Net::HTTP.stubs(:new).raises(OpenStack::Compute::Exception::Connection)
-    connection = stub(:authuser => 'bad_user', :authkey => 'bad_key', :auth_host => "a.b.c", :auth_port => "443", :auth_scheme => "https", :auth_path => "/v1.0", :authok= => true, :authtoken= => true, :proxy_host => nil, :proxy_port => nil)
-    assert_raises(OpenStack::Compute::Exception::Connection) do
-      result = OpenStack::Compute::Authentication.init(connection)
-    end
-  end
-    
-end

data/test/connection_test.rb

@@ -1,39 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-class ComputeConnectionTest < Test::Unit::TestCase
-
-  def setup
-    connection = stub()
-    OpenStack::Compute::Authentication.stubs(:init).returns(connection)
-  end
-  
-  def test_init_connection_no_credentials
-    assert_raises(OpenStack::Compute::Exception::MissingArgument) do
-      conn = OpenStack::Compute::Connection.new(:api_key => "AABBCCDD11", :auth_url => "a.b.c")
-    end
-  end
-
-  def test_init_connection_no_password
-    assert_raises(OpenStack::Compute::Exception::MissingArgument) do
-      conn = OpenStack::Compute::Connection.new(:username => "test_account", :auth_url => "a.b.c")
-    end
-  end
-
-  def test_init_connection_no_auth_url
-    assert_raises(OpenStack::Compute::Exception::MissingArgument) do
-      conn = OpenStack::Compute::Connection.new(:username => "test_account", :api_key => "AABBCCDD11")
-    end
-  end
-
-  def test_init_connection_bad_auth_url
-    assert_raises(OpenStack::Compute::Exception::InvalidArgument) do
-      conn = OpenStack::Compute::Connection.new(:username => "test_account", :api_key => "AABBCCDD11", :auth_url => "***")
-    end
-  end
-
-  def test_init_connection
-      conn = OpenStack::Compute::Connection.new(:username => "test_account", :api_key => "AABBCCDD11", :auth_url => "https://a.b.c")
-      assert_not_nil conn, "Connection.new returned nil."
-  end
-    
-end

data/test/exception_test.rb

@@ -1,49 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-class ExceptionTest < Test::Unit::TestCase
-  
-  def test_400_cloud_servers_fault
-    response = mock()
-    response.stubs(:code => "400", :body => "{\"ComputeFault\":{\"message\":\"422 Unprocessable Entity: We could not process your request at this time. We have been notified and are looking into the issue.  [E03]\",\"details\":\"com.rackspace.cloud.service.servers.OpenStack::ComputeFault: Fault occured\",\"code\":400}}" )
-    exception=nil
-    begin
-      OpenStack::Compute::Exception.raise_exception(response)
-    rescue Exception => e
-      exception=e
-    end
-    assert_equal(OpenStack::Compute::Exception::ComputeFault, e.class)
-    assert_equal("400", e.response_code)
-    assert_not_nil(e.response_body)
-  end
-
-  def test_413_over_limit
-    response = mock()
-    response.stubs(:code => "413", :body => "{\"overLimit\":{\"message\":\"Too many requests...\",\"code\":413,\"retryAfter\":\"2010-08-25T10:47:57.890-05:00\"}}")
-    exception=nil
-    begin
-      OpenStack::Compute::Exception.raise_exception(response)
-    rescue Exception => e
-      exception=e
-    end
-    assert_equal(OpenStack::Compute::Exception::OverLimit, e.class)
-    assert_equal("413", e.response_code)
-    assert_not_nil(e.response_body)
-  end
-
-  def test_other
-    response = mock()
-    body="{\"blahblah\":{\"message\":\"Failed...\",\"code\":500}}"
-    response.stubs(:code => "500", :body => body)
-    exception=nil
-    begin
-      OpenStack::Compute::Exception.raise_exception(response)
-    rescue Exception => e
-      exception=e
-    end
-    assert_equal(OpenStack::Compute::Exception::Other, exception.class)
-    assert_equal("500", exception.response_code)
-    assert_not_nil(exception.response_body)
-    assert_equal(body, exception.response_body)
-  end
-
-end

data/test/servers_test.rb

@@ -1,123 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-class ServersTest < Test::Unit::TestCase
-
-  include TestConnection
-
-  def setup
-    @conn=get_test_connection
-  end
-  
-  def test_list_servers
-
-json_response = %{{
-  "servers" : [
-      {
-     "id" : 1234,
-      "name" : "sample-server",
-      "imageId" : 2,
-      "flavorId" : 1,
-      "hostId" : "e4d909c290d0fb1ca068ffaddf22cbd0",
-      "status" : "BUILD",
-      "progress" : 60,
-      "addresses" : {
-          "public" : [
-              "67.23.10.132",
-              "67.23.10.131"
-          ],
-          "private" : [
-              "10.176.42.16"
-          ]
-      },
-      "metadata" : {
-          "Server Label" : "Web Head 1",
-          "Image Version" : "2.1"
-      }
-      },
-      {
-    "id" : 5678,
-      "name" : "sample-server2",
-      "imageId" : 2,
-      "flavorId" : 1,
-      "hostId" : "9e107d9d372bb6826bd81d3542a419d6",
-      "status" : "ACTIVE",
-      "addresses" : {
-          "public" : [
-              "67.23.10.133"
-          ],
-          "private" : [
-              "10.176.42.17"
-          ]
-      },
-      "metadata" : {
-          "Server Label" : "DB 1"
-      }
-      }
-  ]
-}}
-    response = mock()
-    response.stubs(:code => "200", :body => json_response)
-
-    @conn.stubs(:csreq).returns(response)
-    servers=@conn.list_servers
-
-    assert_equal 2, servers.size
-    assert_equal 1234, servers[0][:id]
-    assert_equal "sample-server", servers[0][:name]
-
-  end
-
-  def test_get_server
-
-    server=get_test_server
-    assert "sample-server", server.name
-    assert "2", server.imageId
-    assert "1", server.flavorId
-    assert "e4d909c290d0fb1ca068ffaddf22cbd0", server.hostId
-    assert "BUILD", server.status
-    assert "60", server.progress
-    assert "67.23.10.132", server.addresses[:public][0]
-    assert "67.23.10.131", server.addresses[:public][1]
-    assert "10.176.42.16", server.addresses[:private][1]
-
-  end
-
-private
-  def get_test_server
-
-json_response = %{{
-  "server" : {
-      "id" : 1234,
-      "name" : "sample-server",
-      "imageId" : 2,
-      "flavorId" : 1,
-      "hostId" : "e4d909c290d0fb1ca068ffaddf22cbd0",
-      "status" : "BUILD",
-      "progress" : 60,
-      "addresses" : {
-          "public" : [
-               "67.23.10.132",
-               "67.23.10.131"
-          ],
-          "private" : [
-               "10.176.42.16"
-          ]
-      },
-      "metadata" : {
-          "Server Label" : "Web Head 1",
-          "Image Version" : "2.1"
-      }
-  }
-}}
-
-    response = mock()
-    response.stubs(:code => "200", :body => json_response)
-
-    @conn=get_test_connection
-
-    @conn.stubs(:csreq).returns(response)
-    return @conn.server(1234) 
-
-  end
-
-end

data/test/test_helper.rb

@@ -1,23 +0,0 @@
-require 'test/unit'
-$:.unshift File.dirname(__FILE__) + '/../lib'
-require 'openstack/compute'
-require 'rubygems'
-require 'mocha'
-
-module TestConnection
-
-def get_test_connection 
-
-    conn_response = {'x-server-management-url' => 'http://server-manage.example.com/path', 'x-auth-token' => 'dummy_token'}
-    conn_response.stubs(:code).returns('204')
-    #server = mock(:use_ssl= => true, :verify_mode= => true, :start => true, :finish => true)
-    server = mock(:start => true, :finish => true)
-    server.stubs(:get => conn_response, :use_ssl= => true, :verify_mode= => true)
-    #server.stubs(:get).returns(conn_response)
-    Net::HTTP.stubs(:new).returns(server)
-
-    OpenStack::Compute::Connection.new(:username => "test_account", :api_key => "AABBCCDD11", :auth_url => "http://a.b.c")
-
-end
-
-end