fog-maestrodev 1.7.0.20121114190951 → 1.8.0.20130109172219

data/lib/fog/openstack.rb

@@ -15,6 +15,9 @@ module Fog
           else
             data = Fog::JSON.decode(error.response.body)
             message = data['message']
+            if message.nil? and !data.values.first.nil?
+              message = data.values.first['message']
+            end
           end
 
           new_error = super(error, message)
@@ -23,9 +26,6 @@ module Fog
         end
       end
 
-      class InternalServerError < ServiceError; end
-      class Conflict < ServiceError; end
-      class NotFound < ServiceError; end
       class ServiceUnavailable < ServiceError; end
 
       class BadRequest < ServiceError
@@ -33,8 +33,8 @@ module Fog
 
         def self.slurp(error)
           new_error = super(error)
-          unless new_error.response_data.nil?
-            new_error.instance_variable_set(:@validation_errors, new_error.response_data['validationErrors'])
+          unless new_error.response_data.nil? or new_error.response_data['badRequest'].nil?
+            new_error.instance_variable_set(:@validation_errors, new_error.response_data['badRequest']['validationErrors'])
           end
           new_error
         end
@@ -72,48 +72,27 @@ module Fog
 
     # Keystone Style Auth
     def self.authenticate_v2(options, connection_options = {})
-      uri = options[:openstack_auth_uri]
-      connection = Fog::Connection.new(uri.to_s, false, connection_options)
-      @openstack_api_key  = options[:openstack_api_key]
-      @openstack_username = options[:openstack_username]
-      @openstack_tenant   = options[:openstack_tenant]
-      @openstack_auth_token = options[:openstack_auth_token]
-      @service_name         = options[:openstack_service_name]
-      @identity_service_name = options[:openstack_identity_service_name]
-      @endpoint_type         = options[:openstack_endpoint_type] || 'publicURL'
-      @openstack_region      = options[:openstack_region]
-
-      if @openstack_auth_token
-        req_body = {
-          'auth' => {
-            'token' => {
-              'id' => @openstack_auth_token
-            }
-          }
-        }
-      else
-        req_body = {
-          'auth' => {
-            'passwordCredentials'  => {
-              'username' => @openstack_username.to_s,
-              'password' => @openstack_api_key.to_s
-            }
-          }
-        }
-      end
-      req_body['auth']['tenantName'] = @openstack_tenant if @openstack_tenant
+      uri                   = options[:openstack_auth_uri]
+      tenant_name           = options[:openstack_tenant]
+      service_type          = options[:openstack_service_type]
+      service_name          = options[:openstack_service_name]
+      identity_service_type = options[:openstack_identity_service_type]
+      endpoint_type         = (options[:openstack_endpoint_type] || 'publicURL').to_s
+      openstack_region      = options[:openstack_region]
 
-      body = retrieve_tokens_v2(connection, req_body, uri)
 
-      svc = body['access']['serviceCatalog'].
-        detect{|x| @service_name.include?(x['type']) }
+      body = retrieve_tokens_v2(options, connection_options)
+      service = get_service(body, service_type, service_name)
 
-      unless svc
-        unless @openstack_tenant
+      options[:unscoped_token] = body['access']['token']['id']
+
+      unless service
+        unless tenant_name
           response = Fog::Connection.new(
             "#{uri.scheme}://#{uri.host}:#{uri.port}/v2.0/tenants", false, connection_options).request({
             :expects => [200, 204],
             :headers => {'Content-Type' => 'application/json',
+                         'Accept' => 'application/json',
                          'X-Auth-Token' => body['access']['token']['id']},
             :host    => uri.host,
             :method  => 'GET'
@@ -121,56 +100,101 @@ module Fog
 
           body = Fog::JSON.decode(response.body)
           if body['tenants'].empty?
-            raise Errors::NotFound.new('No Tenant Found')
+            raise Fog::Errors::NotFound.new('No Tenant Found')
           else
-            req_body['auth']['tenantName'] = body['tenants'].first['name']
+            options[:openstack_tenant] = body['tenants'].first['name']
           end
         end
 
-        body = retrieve_tokens_v2(connection, req_body, uri)
-        if body['access']['token']['tenant'].nil?
-          raise Errors::NotFound.new("Invalid Tenant '#{@openstack_tenant}'")
-        end
-        svc = body['access']['serviceCatalog'].
-          detect{|x| @service_name.include?(x['type']) }
+        body = retrieve_tokens_v2(options, connection_options)
+        service = get_service(body, service_type, service_name)
+
       end
 
-      # Rackspace doesn't return the region in the endpoints if we already include it in the query
-      svc['endpoints'] = svc['endpoints'].select{ |x| x['region'].nil? or x['region'] == @openstack_region } if @openstack_region
-      if svc['endpoints'].count > 1
-         regions = svc["endpoints"].map { |x| x['region'] }.uniq.join(',')
-         raise Errors::NotFound.new("Multiple regions available choose one of these '#{regions}'")
+      service['endpoints'] = service['endpoints'].select do |endpoint|
+        endpoint['region'] == openstack_region
+      end if openstack_region
+
+      if service['endpoints'].empty?
+        raise Errors::NotFound.new("No endpoints available for region '#{openstack_region}'")
+      end if openstack_region
+
+      unless service
+        available = body['access']['serviceCatalog'].map { |endpoint|
+          endpoint['type']
+        }.sort.join ', '
+
+        missing = service_type.join ', '
+
+        message = "Could not find service #{missing}.  Have #{available}"
+
+        raise Fog::Errors::NotFound, message
       end
 
-      identity_svc = body['access']['serviceCatalog'].
-        detect{|x| @identity_service_name.include?(x['type']) } if @identity_service_name
+      if service['endpoints'].count > 1
+        regions = service["endpoints"].map{ |e| e['region'] }.uniq.join(',')
+        raise Fog::Errors::NotFound.new("Multiple regions available choose one of these '#{regions}'")
+      end
+
+      identity_service = get_service(body, identity_service_type) if identity_service_type
       tenant = body['access']['token']['tenant']
       user = body['access']['user']
 
-      mgmt_url = svc['endpoints'].detect{|x| x[@endpoint_type]}[@endpoint_type]
-      identity_url = identity_svc['endpoints'].detect{|x| x['publicURL']}['publicURL'] if identity_svc
-      token = body['access']['token']['id']
-      expires = body['access']['token']['expires']
+      management_url = service['endpoints'].detect{|s| s[endpoint_type]}[endpoint_type]
+      identity_url   = identity_service['endpoints'].detect{|s| s['publicURL']}['publicURL'] if identity_service
 
       {
         :user                     => user,
         :tenant                   => tenant,
-        :token                    => token,
-        :expires                  => expires,
-        :server_management_url    => mgmt_url,
         :identity_public_endpoint => identity_url,
-        :current_user_id          => body['access']['user']['id']
+        :server_management_url    => management_url,
+        :token                    => body['access']['token']['id'],
+        :expires                  => body['access']['token']['expires'],
+        :current_user_id          => body['access']['user']['id'],
+        :unscoped_token           => options[:unscoped_token]
       }
+
+    end
+
+    def self.get_service(body, service_type=[], service_name=nil)
+      body['access']['serviceCatalog'].detect do |s|
+        if service_name.nil? or service_name.empty?
+          service_type.include?(s['type'])
+        else
+          service_type.include?(s['type']) and s['name'] == service_name
+        end
+      end
     end
 
-    def self.retrieve_tokens_v2(connection, request_body, uri)
+    def self.retrieve_tokens_v2(options, connection_options = {})
+      api_key     = options[:openstack_api_key].to_s
+      username    = options[:openstack_username].to_s
+      tenant_name = options[:openstack_tenant].to_s
+      auth_token  = options[:openstack_auth_token] || options[:unscoped_token]
+      uri         = options[:openstack_auth_uri]
+
+      connection = Fog::Connection.new(uri.to_s, false, connection_options)
+      request_body = {:auth => Hash.new}
+
+      if auth_token
+        request_body[:auth][:token] = {
+          :id => auth_token
+        }
+      else
+        request_body[:auth][:passwordCredentials] = {
+          :username => username,
+          :password => api_key
+        }
+      end
+      request_body[:auth][:tenantName] = tenant_name if tenant_name
+
       response = connection.request({
         :expects  => [200, 204],
         :headers  => {'Content-Type' => 'application/json'},
         :body     => Fog::JSON.encode(request_body),
         :host     => uri.host,
         :method   => 'POST',
-        :path     =>  (uri.path and not uri.path.empty?) ? uri.path : 'v2.0'
+        :path     => (uri.path and not uri.path.empty?) ? uri.path : 'v2.0'
       })
 
       Fog::JSON.decode(response.body)

data/lib/fog/openstack/README.identity.md

@@ -0,0 +1,69 @@
+# OpenStack Identity Service (Keystone) Example
+
+    require 'fog'
+    require 'pp'
+    
+    auth_url = "https://example.net/v2.0/tokens"
+    username = 'admin@example.net'
+    password = 'secret'
+    
+    keystone = Fog::Identity.new :provider           => 'OpenStack',
+                                 :openstack_auth_url => auth_url,
+                                 :openstack_username => username,
+                                 :openstack_api_key  => password
+                                 # Optional, self-signed certs
+                                 #:connection_options => { :ssl_verify_peer => false }
+    
+    #
+    # Listing keystone tenants
+    #
+    keystone.tenants.each do |tenant|
+      # <Fog::Identity::OpenStack::Tenant
+      #   id="46b4ab...",
+      #   description=nil,
+      #   enabled=1,
+      #   name="admin@example.net"
+      # >
+      #pp tenant
+    end
+    
+    #
+    # List users
+    #
+    keystone.users.each do |user|
+      # <Fog::Identity::OpenStack::User
+      #   id="c975f...",
+      #   email="quantum@example.net",
+      #   enabled=true,
+      #   name="quantum",
+      #   tenant_id="00928...",
+      #   password=nil
+      # >
+      # ...
+      #pp user
+    end
+    
+    #
+    # Create a new tenant
+    #
+    tenant = keystone.tenants.create :name        => 'rubiojr@example.net',
+                                     :description => 'My foo tenant'
+    
+    #
+    # Create a new user
+    #
+    user = keystone.users.create :name      => 'rubiojr@example.net',
+                                 :tenant_id => tenant.id,
+                                 :password  => 'rubiojr@example.net',
+                                 :email     => 'rubiojr@example.net'
+    
+    
+    # Find the recently created tenant
+    tenant = keystone.tenants.find { |t| t.name == 'rubiojr@example.net' }
+    # Destroy the tenant
+    tenant.destroy
+    
+    # Find the recently created user 
+    user = keystone.users.find { |u| u.name == 'rubiojr@example.net' }
+    # Destroy the user
+    user.destroy

data/lib/fog/openstack/compute.rb

@@ -7,7 +7,8 @@ module Fog
 
       requires :openstack_auth_url
       recognizes :openstack_auth_token, :openstack_management_url,
-                 :persistent, :openstack_service_name, :openstack_tenant,
+                 :persistent, :openstack_service_type, :openstack_service_name,
+                 :openstack_tenant,
                  :openstack_api_key, :openstack_username, :openstack_identity_endpoint,
                  :current_user, :current_tenant, :openstack_region
 
@@ -69,6 +70,7 @@ module Fog
       request :remove_fixed_ip
       request :server_diagnostics
       request :boot_from_snapshot
+      request :reset_server_state
 
       # Server Extenstions
       request :get_console_output
@@ -125,6 +127,7 @@ module Fog
       # Tenant
       request :list_tenants
       request :set_tenant
+      request :get_limits
 
       # Volume
       request :list_volumes
@@ -185,18 +188,39 @@ module Fog
               },
               :servers => {},
               :key_pairs => {},
-              :security_groups => {},
+              :security_groups => {
+                0 => {
+                  "id"          => 0,
+                  "tenant_id"   => Fog::Mock.random_hex(8),
+                  "name"        => "default",
+                  "description" => "default",
+                  "rules"       => [
+                    { "id"              => 0,
+                      "parent_group_id" => 0,
+                      "from_port"       => 68,
+                      "to_port"         => 68,
+                      "ip_protocol"     => "udp",
+                      "ip_range"        => { "cidr" => "0.0.0.0/0" },
+                      "group"           => {}, },
+                  ],
+                },
+              },
+              :server_security_group_map => {},
               :addresses => {},
               :quota => {
-                'metadata_items' => 128,
+                'security_group_rules' => 20,
+                'security_groups' => 10,
                 'injected_file_content_bytes' => 10240,
+                'injected_file_path_bytes' => 256,
                 'injected_files' => 5,
-                'gigabytes' => 1000,
-                'ram' => 51200,
-                'floating_ips' => 10,
-                'instances' => 10,
-                'volumes' => 10,
-                'cores' => 20,
+                'metadata_items' => 128,
+                'floating_ips'   => 10,
+                'instances'      => 10,
+                'key_pairs'      => 10,
+                'gigabytes'      => 5000,
+                'volumes'        => 10,
+                'cores'          => 20,
+                'ram'            => 51200
               }
             }
           end
@@ -208,9 +232,10 @@ module Fog
 
         def initialize(options={})
           @openstack_username = options[:openstack_username]
-          @openstack_tenant   = options[:openstack_tenant]
           @openstack_auth_uri = URI.parse(options[:openstack_auth_url])
 
+          @current_tenant = options[:openstack_tenant]
+
           @auth_token = Fog::Mock.random_base64(64)
           @auth_token_expiration = (Time.now.utc + 86400).iso8601
 
@@ -225,11 +250,11 @@ module Fog
         end
 
         def data
-          self.class.data["#{@openstack_username}-#{@openstack_tenant}"]
+          self.class.data["#{@openstack_username}-#{@current_tenant}"]
         end
 
         def reset_data
-          self.class.data.delete("#{@openstack_username}-#{@openstack_tenant}")
+          self.class.data.delete("#{@openstack_username}-#{@current_tenant}")
         end
 
         def credentials
@@ -249,9 +274,10 @@ module Fog
 
         def initialize(options={})
           @openstack_auth_token = options[:openstack_auth_token]
+          @auth_token        = options[:openstack_auth_token]
           @openstack_identity_public_endpoint = options[:openstack_identity_endpoint]
 
-          unless @openstack_auth_token
+          unless @auth_token
             missing_credentials = Array.new
             @openstack_api_key  = options[:openstack_api_key]
             @openstack_username = options[:openstack_username]
@@ -265,8 +291,9 @@ module Fog
           @openstack_auth_uri   = URI.parse(options[:openstack_auth_url])
           @openstack_management_url       = options[:openstack_management_url]
           @openstack_must_reauthenticate  = false
-          @openstack_service_name = options[:openstack_service_name] || ['nova', 'compute']
-          @openstack_identity_service_name = options[:openstack_identity_service_name] || 'identity'
+          @openstack_service_type = options[:openstack_service_type] || ['nova', 'compute']
+          @openstack_service_name = options[:openstack_service_name]
+          @openstack_identity_service_type = options[:openstack_identity_service_type] || 'identity'
           @openstack_region      = options[:openstack_region]
 
           @connection_options = options[:connection_options] || {}
@@ -300,6 +327,7 @@ module Fog
             response = @connection.request(params.merge({
               :headers  => {
                 'Content-Type' => 'application/json',
+                'Accept' => 'application/json',
                 'X-Auth-Token' => @auth_token
               }.merge!(params[:headers] || {}),
               :host     => @host,
@@ -333,19 +361,21 @@ module Fog
         private
 
         def authenticate
-          if @openstack_must_reauthenticate || @openstack_auth_token.nil?
+          if !@openstack_management_url || @openstack_must_reauthenticate
             options = {
-              :openstack_api_key  => @openstack_api_key,
-              :openstack_username => @openstack_username,
-              :openstack_auth_token => @openstack_auth_token,
-              :openstack_auth_uri => @openstack_auth_uri,
-              :openstack_region   => @openstack_region,
-              :openstack_tenant   => @openstack_tenant,
+              :openstack_api_key    => @openstack_api_key,
+              :openstack_username   => @openstack_username,
+              :openstack_auth_token => @auth_token,
+              :openstack_auth_uri   => @openstack_auth_uri,
+              :openstack_region     => @openstack_region,
+              :openstack_tenant     => @openstack_tenant,
+              :openstack_service_type => @openstack_service_type,
               :openstack_service_name => @openstack_service_name,
-              :openstack_identity_service_name => @openstack_identity_service_name
+              :openstack_identity_service_type => @openstack_identity_service_type
             }
 
             if @openstack_auth_uri.path =~ /\/v2.0\//
+
               credentials = Fog::OpenStack.authenticate_v2(options, @connection_options)
             else
               credentials = Fog::OpenStack.authenticate_v1(options, @connection_options)
@@ -358,29 +388,29 @@ module Fog
             @auth_token               = credentials[:token]
             @auth_token_expiration    = credentials[:expires]
             @openstack_management_url = credentials[:server_management_url]
-            # identity_public_endpoint is returned nil in Rackspace
-            @openstack_identity_public_endpoint  = credentials[:identity_public_endpoint] || @openstack_management_url.scan(/(.*)\/.*/).flatten.first
-
-            uri = URI.parse(@openstack_management_url)
+            @openstack_identity_public_endpoint  = credentials[:identity_public_endpoint]
+          end
 
-            @host   = uri.host
-            @path, @tenant_id = uri.path.scan(/(\/.*)\/(.*)/).flatten
+          uri = URI.parse(@openstack_management_url)
+          @host   = uri.host
+          @path, @tenant_id = uri.path.scan(/(\/.*)\/(.*)/).flatten
 
-            @path.sub!(/\/$/, '')
-            unless @path.match(/1\.1|v2/)
-              raise Fog::OpenStack::Errors::ServiceUnavailable.new(
-                      "OpenStack binding only supports version 2 (a.k.a. 1.1). Credentials returned: #{credentials.inspect}")
-            end
+          @path.sub!(/\/$/, '')
+          unless @path.match(/1\.1|v2/)
+            raise Fog::OpenStack::Errors::ServiceUnavailable.new(
+                    "OpenStack binding only supports version 2 (a.k.a. 1.1)")
+          end
 
-            @port   = uri.port
-            @scheme = uri.scheme
-          else
-            @auth_token = @openstack_auth_token
+          @port   = uri.port
+          @scheme = uri.scheme
+           
+          # Not all implementations have identity service in the catalog
+          if @openstack_identity_public_endpoint
+            @identity_connection = Fog::Connection.new(
+              @openstack_identity_public_endpoint,
+              false, @connection_options)
           end
 
-          @identity_connection = Fog::Connection.new(
-            @openstack_identity_public_endpoint,
-            false, @connection_options)
           true
         end