openstack-compute 1.0.0 → 1.0.1

data/README.rdoc

@@ -1,8 +1,10 @@
-= Ruby OpenStack
+= Ruby OpenStack Compute
 
 == Description
 
-Ruby Openstack Compute binding.
+Ruby Openstack Compute binding for the v1.0 OSAPI.
+
+Currently supports both v1.0 and v2.0 (keystone) auth.
 
 == Examples
 
@@ -10,7 +12,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, :api_url => API_URL)	
+  cs = OpenStack::Compute::Connection.new(:username => USERNAME, :api_key => API_KEY, :auth_url => API_URL)	
 
   # Get a listing of all current servers
   >> cs.servers
@@ -63,7 +65,7 @@ See the class definitions for documentation on specific methods and operations.
 
 == Authors
 
-By Dan Prince <dan.prince@rackspace.com>.
+By Dan Prince <dan.prince@rackspace.com>, Naveed Massjouni <naveedm9@gmail.com>
 
 Based on the Rackspace Cloud Servers Ruby API.
 

data/VERSION

@@ -1 +1 @@
-1.0.0
+1.0.1

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, :api_url => API_URL) method.
+# OpenStack::Compute::Connection.new(:username => USERNAME, :api_key => API_KEY, :auth_url => API_URL) method.
 module OpenStack
 module Compute
 

data/lib/openstack/compute/authentication.rb

@@ -1,19 +1,70 @@
 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\/tokens$/
+        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, 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'
       hdrhash = { "X-Auth-User" => connection.authuser, "X-Auth-Key" => connection.authkey }
       begin
-        server = Net::HTTP::Proxy(connection.proxy_host, connection.proxy_port).new(connection.api_host, connection.api_port)
-        if connection.api_scheme == "https"
+        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
@@ -24,12 +75,13 @@ module Compute
       response = server.get(path,hdrhash)
       if (response.code =~ /^20./)
         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
+        uri = URI.parse(response["x-server-management-url"])
+        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.parse(response["x-server-management-url"]).port
-        connection.svrmgmtscheme = URI.parse(response["x-server-management-url"]).scheme
+        connection.svrmgmtpath.sub!(/\/.*\/?/, '/v1.0/')
+        connection.svrmgmtport = uri.port
+        connection.svrmgmtscheme = uri.scheme
         connection.authok = true
       else
         connection.authtoken = false
@@ -38,5 +90,6 @@ module Compute
       server.finish
     end
   end
+
 end
 end

data/lib/openstack/compute/connection.rb

@@ -10,9 +10,11 @@ module Compute
     attr_accessor :svrmgmtpath
     attr_accessor :svrmgmtport
     attr_accessor :svrmgmtscheme
-    attr_reader   :api_host
-    attr_reader   :api_port
-    attr_reader   :api_scheme
+    attr_reader   :auth_host
+    attr_reader   :auth_port
+    attr_reader   :auth_scheme
+    attr_reader   :auth_path
+    attr_accessor :service_name
     attr_reader   :proxy_host
     attr_reader   :proxy_port
     
@@ -22,34 +24,37 @@ module Compute
     #
     #   :username - Your Openstack username *required*
     #   :api_key - Your Openstack API key *required*
-    #   :api_url - The url of the Openstack Compute API server.
+    #   :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'.
     #   :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', :api_url => 'API_URL')
+    #   cf = OpenStack::Compute::Connection.new(:username => 'USERNAME', :api_key => 'API_KEY', :auth_url => 'AUTH_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")
-      @api_url = options[:api_url] || (raise Exception::MissingArgument, "Must supply an :api_url")
+      @auth_url = options[:auth_url] || (raise Exception::MissingArgument, "Must supply an :auth_url")
+      @service_name = options[:service_name] || "nova"
 
-      api_uri=nil
+      auth_uri=nil
       begin
-        api_uri=URI.parse(@api_url)
+        auth_uri=URI.parse(@auth_url)
       rescue Exception => e
-        raise Exception::InvalidArgument, "Invalid :api_url parameter: #{e.message}"
+        raise Exception::InvalidArgument, "Invalid :auth_url parameter: #{e.message}"
       end
-      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
+      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
 
       @retry_auth = options[:retry_auth]
       @proxy_host = options[:proxy_host]
       @proxy_port = options[:proxy_port]
       @authok = false
       @http = {}
-      OpenStack::Compute::Authentication.new(self)
+      OpenStack::Compute::Authentication.init(self)
     end
     
     # Returns true if the authentication was successful and returns false otherwise.
@@ -79,7 +84,7 @@ 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.new(self)
+      OpenStack::Compute::Authentication.init(self)
       retry
     end
     

data/test/authentication_test.rb

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,123 @@
+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

@@ -0,0 +1,23 @@
+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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: openstack-compute
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 21
   prerelease: false
   segments: 
   - 1
   - 0
-  - 0
-  version: 1.0.0
+  - 1
+  version: 1.0.1
 platform: ruby
 authors: 
 - Dan Prince
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-08-12 00:00:00 -04:00
+date: 2011-08-29 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -51,6 +51,11 @@ files:
 - lib/openstack/compute/flavor.rb
 - lib/openstack/compute/image.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: []
@@ -85,5 +90,9 @@ rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: OpenStack Compute Ruby API
-test_files: []
-
+test_files: 
+- test/authentication_test.rb
+- test/exception_test.rb
+- test/test_helper.rb
+- test/connection_test.rb
+- test/servers_test.rb