Merge from trunk

7 files changed, 73 insertions, 33 deletions

diff --git a/nova/api/ec2/__init__.py b/nova/api/ec2/__init__.py
index 9938b23f8..e25943a13 100644
--- a/nova/api/ec2/__init__.py
+++ b/nova/api/ec2/__init__.py
@@ -33,6 +33,7 @@ from nova import log as logging
 from nova import utils
 from nova import wsgi
 from nova.api.ec2 import apirequest
+from nova.api.ec2 import cloud
 from nova.auth import manager
 
 
@@ -170,7 +171,7 @@ class Authenticate(wsgi.Middleware):
                     req.path)
         # Be explicit for what exceptions are 403, the rest bubble as 500
         except (exception.NotFound, exception.NotAuthorized) as ex:
-            LOG.audit(_("Authentication Failure: %s"), str(ex))
+            LOG.audit(_("Authentication Failure: %s"), ex.args[0])
             raise webob.exc.HTTPForbidden()
 
         # Authenticated!
@@ -213,7 +214,8 @@ class Requestify(wsgi.Middleware):
             LOG.debug(_('arg: %(key)s\t\tval: %(value)s') % locals())
 
         # Success!
-        api_request = apirequest.APIRequest(self.controller, action, args)
+        api_request = apirequest.APIRequest(self.controller, action,
+                                            req.params['Version'], args)
         req.environ['ec2.request'] = api_request
         req.environ['ec2.action_args'] = args
         return self.application
@@ -313,18 +315,31 @@ class Executor(wsgi.Application):
         result = None
         try:
             result = api_request.invoke(context)
+        except exception.InstanceNotFound as ex:
+            LOG.info(_('InstanceNotFound raised: %s'), ex.args[0],
+                     context=context)
+            ec2_id = cloud.id_to_ec2_id(ex.instance_id)
+            message = _('Instance %s not found') % ec2_id
+            return self._error(req, context, type(ex).__name__, message)
+        except exception.VolumeNotFound as ex:
+            LOG.info(_('VolumeNotFound raised: %s'), ex.args[0],
+                     context=context)
+            ec2_id = cloud.id_to_ec2_id(ex.volume_id, 'vol-%08x')
+            message = _('Volume %s not found') % ec2_id
+            return self._error(req, context, type(ex).__name__, message)
         except exception.NotFound as ex:
-            LOG.info(_('NotFound raised: %s'), str(ex),  context=context)
-            return self._error(req, context, type(ex).__name__, str(ex))
+            LOG.info(_('NotFound raised: %s'), ex.args[0], context=context)
+            return self._error(req, context, type(ex).__name__, ex.args[0])
         except exception.ApiError as ex:
-            LOG.exception(_('ApiError raised: %s'), str(ex), context=context)
+            LOG.exception(_('ApiError raised: %s'), ex.args[0],
+                          context=context)
             if ex.code:
-                return self._error(req, context, ex.code, str(ex))
+                return self._error(req, context, ex.code, ex.args[0])
             else:
-                return self._error(req, context, type(ex).__name__, str(ex))
+                return self._error(req, context, type(ex).__name__, ex.args[0])
         except Exception as ex:
             extra = {'environment': req.environ}
-            LOG.exception(_('Unexpected error raised: %s'), str(ex),
+            LOG.exception(_('Unexpected error raised: %s'), ex.args[0],
                           extra=extra, context=context)
             return self._error(req,
                                context,
@@ -347,7 +362,8 @@ class Executor(wsgi.Application):
                          '<Response><Errors><Error><Code>%s</Code>'
                          '<Message>%s</Message></Error></Errors>'
                          '<RequestID>%s</RequestID></Response>' %
-                         (code, message, context.request_id))
+                         (utils.utf8(code), utils.utf8(message),
+                         utils.utf8(context.request_id)))
         return resp
 
 
diff --git a/nova/api/ec2/admin.py b/nova/api/ec2/admin.py
index 78ff1b3e0..d7e899d12 100644
--- a/nova/api/ec2/admin.py
+++ b/nova/api/ec2/admin.py
@@ -26,6 +26,7 @@ from nova import db
 from nova import exception
 from nova import log as logging
 from nova.auth import manager
+from nova.compute import instance_types
 
 
 LOG = logging.getLogger('nova.api.ec2.admin')
@@ -62,6 +63,14 @@ def host_dict(host):
         return {}
 
 
+def instance_dict(name, inst):
+    return {'name': name,
+            'memory_mb': inst['memory_mb'],
+            'vcpus': inst['vcpus'],
+            'disk_gb': inst['local_gb'],
+            'flavor_id': inst['flavorid']}
+
+
 class AdminController(object):
     """
     API Controller for users, hosts, nodes, and workers.
@@ -70,6 +79,10 @@ class AdminController(object):
     def __str__(self):
         return 'AdminController'
 
+    def describe_instance_types(self, _context, **_kwargs):
+        return {'instanceTypeSet': [instance_dict(n, v) for n, v in
+                                    instance_types.INSTANCE_TYPES.iteritems()]}
+
     def describe_user(self, _context, name, **_kwargs):
         """Returns user data, including access and secret keys."""
         return user_dict(manager.AuthManager().get_user(name))
diff --git a/nova/api/ec2/apirequest.py b/nova/api/ec2/apirequest.py
index d8a2b5f53..7e72d67fb 100644
--- a/nova/api/ec2/apirequest.py
+++ b/nova/api/ec2/apirequest.py
@@ -83,9 +83,10 @@ def _try_convert(value):
 
 
 class APIRequest(object):
-    def __init__(self, controller, action, args):
+    def __init__(self, controller, action, version, args):
         self.controller = controller
         self.action = action
+        self.version = version
         self.args = args
 
     def invoke(self, context):
@@ -132,7 +133,7 @@ class APIRequest(object):
 
         response_el = xml.createElement(self.action + 'Response')
         response_el.setAttribute('xmlns',
-                                 'http://ec2.amazonaws.com/doc/2009-11-30/')
+                             'http://ec2.amazonaws.com/doc/%s/' % self.version)
         request_id_el = xml.createElement('requestId')
         request_id_el.appendChild(xml.createTextNode(request_id))
         response_el.appendChild(request_id_el)
diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 3b228bf1a..9683e2ebd 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -529,11 +529,14 @@ class CloudController(object):
 
     def describe_volumes(self, context, volume_id=None, **kwargs):
         if volume_id:
-            volume_id = [ec2_id_to_id(x) for x in volume_id]
-        volumes = self.volume_api.get_all(context)
-        # NOTE(vish): volume_id is an optional list of volume ids to filter by.
-        volumes = [self._format_volume(context, v) for v in volumes
-                   if volume_id is None or v['id'] in volume_id]
+            volumes = []
+            for ec2_id in volume_id:
+                internal_id = ec2_id_to_id(ec2_id)
+                volume = self.volume_api.get(context, internal_id)
+                volumes.append(volume)
+        else:
+            volumes = self.volume_api.get_all(context)
+        volumes = [self._format_volume(context, v) for v in volumes]
         return {'volumeSet': volumes}
 
     def _format_volume(self, context, volume):
@@ -658,8 +661,11 @@ class CloudController(object):
         reservations = {}
         # NOTE(vish): instance_id is an optional list of ids to filter by
         if instance_id:
-            instance_id = [ec2_id_to_id(x) for x in instance_id]
-            instances = [self.compute_api.get(context, x) for x in instance_id]
+            instances = []
+            for ec2_id in instance_id:
+                internal_id = ec2_id_to_id(ec2_id)
+                instance = self.compute_api.get(context, internal_id)
+                instances.append(instance)
         else:
             instances = self.compute_api.get_all(context, **kwargs)
         for instance in instances:
diff --git a/nova/api/openstack/__init__.py b/nova/api/openstack/__init__.py
index f2caac483..c70bb39ed 100644
--- a/nova/api/openstack/__init__.py
+++ b/nova/api/openstack/__init__.py
@@ -38,9 +38,6 @@ from nova.api.openstack import shared_ip_groups
 
 LOG = logging.getLogger('nova.api.openstack')
 FLAGS = flags.FLAGS
-flags.DEFINE_string('os_krm_mapping_file',
-    'krm_mapping.json',
-    'Location of OpenStack Flavor/OS:EC2 Kernel/Ramdisk/Machine JSON file.')
 flags.DEFINE_bool('allow_admin_api',
     False,
     'When True, this API service will accept admin operations.')
diff --git a/nova/api/openstack/common.py b/nova/api/openstack/common.py
index 037ed47a0..6d2fa16e8 100644
--- a/nova/api/openstack/common.py
+++ b/nova/api/openstack/common.py
@@ -54,7 +54,7 @@ def get_image_id_from_image_hash(image_service, context, image_hash):
     except NotImplementedError:
         items = image_service.index(context)
     for image in items:
-        image_id = image['imageId']
+        image_id = image['id']
         if abs(hash(image_id)) == int(image_hash):
             return image_id
     raise exception.NotFound(image_hash)
diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 22b4797c9..17c5519a1 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -124,17 +124,23 @@ class Controller(wsgi.Controller):
             return faults.Fault(exc.HTTPNotFound())
         return exc.HTTPAccepted()
 
-    def _get_kernel_ramdisk_from_image(self, image_id):
-        mapping_filename = FLAGS.os_krm_mapping_file
-
-        with open(mapping_filename) as f:
-            mapping = json.load(f)
-            if image_id in mapping:
-                return mapping[image_id]
+    def _get_kernel_ramdisk_from_image(self, req, image_id):
+        """
+        Machine images are associated with Kernels and Ramdisk images via
+        metadata stored in Glance as 'image_properties'
+        """
+        def lookup(param):
+            _image_id = image_id
+            try:
+                return image['properties'][param]
+            except KeyError:
+                raise exception.NotFound(
+                    _("%(param)s property not found for image %(_image_id)s") %
+                      locals())
 
-        msg = _("No entry for image '%(image_id)s'"
-                " in mapping file '%(mapping_filename)s'") % locals()
-        raise exception.NotFound(msg)
+        image_id = str(image_id)
+        image = self._image_service.show(req.environ['nova.context'], image_id)
+        return lookup('kernel_id'), lookup('ramdisk_id')
 
     def create(self, req):
         """ Creates a new server for a given user """
@@ -146,7 +152,8 @@ class Controller(wsgi.Controller):
             req.environ['nova.context'])[0]
         image_id = common.get_image_id_from_image_hash(self._image_service,
             req.environ['nova.context'], env['server']['imageId'])
-        kernel_id, ramdisk_id = self._get_kernel_ramdisk_from_image(image_id)
+        kernel_id, ramdisk_id = self._get_kernel_ramdisk_from_image(
+            req, image_id)
         instances = self.compute_api.create(
             req.environ['nova.context'],
             instance_types.get_by_flavor_id(env['server']['flavorId']),