Merge from trunk

7 files changed, 126 insertions, 71 deletions

diff --git a/nova/api/ec2/__init__.py b/nova/api/ec2/__init__.py
index 238cb0f38..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
 
 
@@ -131,9 +132,11 @@ class Lockout(wsgi.Middleware):
                 # NOTE(vish): To use incr, failures has to be a string.
                 self.mc.set(failures_key, '1', time=FLAGS.lockout_window * 60)
             elif failures >= FLAGS.lockout_attempts:
-                LOG.warn(_('Access key %s has had %d failed authentications'
-                           ' and will be locked out for %d minutes.'),
-                         access_key, failures, FLAGS.lockout_minutes)
+                lock_mins = FLAGS.lockout_minutes
+                msg = _('Access key %(access_key)s has had %(failures)d'
+                        ' failed authentications and will be locked out'
+                        ' for %(lock_mins)d minutes.') % locals()
+                LOG.warn(msg)
                 self.mc.set(failures_key, str(failures),
                             time=FLAGS.lockout_minutes * 60)
         return res
@@ -168,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!
@@ -179,8 +182,10 @@ class Authenticate(wsgi.Middleware):
                                       project=project,
                                       remote_address=remote_address)
         req.environ['ec2.context'] = ctxt
-        LOG.audit(_('Authenticated Request For %s:%s)'), user.name,
-                  project.name, context=req.environ['ec2.context'])
+        uname = user.name
+        pname = project.name
+        msg = _('Authenticated Request For %(uname)s:%(pname)s)') % locals()
+        LOG.audit(msg, context=req.environ['ec2.context'])
         return self.application
 
 
@@ -206,10 +211,11 @@ class Requestify(wsgi.Middleware):
 
         LOG.debug(_('action: %s'), action)
         for key, value in args.items():
-            LOG.debug(_('arg: %s\t\tval: %s'), key, value)
+            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
@@ -277,8 +283,8 @@ class Authorizer(wsgi.Middleware):
         if self._matches_any_role(context, allowed_roles):
             return self.application
         else:
-            LOG.audit(_("Unauthorized request for controller=%s "
-                        "and action=%s"), controller, action, context=context)
+            LOG.audit(_('Unauthorized request for controller=%(controller)s '
+                        'and action=%(action)s') % locals(), context=context)
             raise webob.exc.HTTPUnauthorized()
 
     def _matches_any_role(self, context, roles):
@@ -309,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,
@@ -343,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 758b612e8..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))
@@ -111,19 +124,23 @@ class AdminController(object):
         """Add or remove a role for a user and project."""
         if operation == 'add':
             if project:
-                LOG.audit(_("Adding role %s to user %s for project %s"), role,
-                          user, project, context=context)
+                msg = _("Adding role %(role)s to user %(user)s"
+                        " for project %(project)s") % locals()
+                LOG.audit(msg, context=context)
             else:
-                LOG.audit(_("Adding sitewide role %s to user %s"), role, user,
-                          context=context)
+                msg = _("Adding sitewide role %(role)s to"
+                        " user %(user)s") % locals()
+                LOG.audit(msg, context=context)
             manager.AuthManager().add_role(user, role, project)
         elif operation == 'remove':
             if project:
-                LOG.audit(_("Removing role %s from user %s for project %s"),
-                          role, user, project, context=context)
+                msg = _("Removing role %(role)s from user %(user)s"
+                        " for project %(project)s") % locals()
+                LOG.audit(msg, context=context)
             else:
-                LOG.audit(_("Removing sitewide role %s from user %s"), role,
-                          user, context=context)
+                msg = _("Removing sitewide role %(role)s"
+                        " from user %(user)s") % locals()
+                LOG.audit(msg, context=context)
             manager.AuthManager().remove_role(user, role, project)
         else:
             raise exception.ApiError(_('operation must be add or remove'))
@@ -139,8 +156,9 @@ class AdminController(object):
             project = name
         project = manager.AuthManager().get_project(project)
         user = manager.AuthManager().get_user(name)
-        LOG.audit(_("Getting x509 for user: %s on project: %s"), name,
-                  project, context=context)
+        msg = _("Getting x509 for user: %(name)s"
+                " on project: %(project)s") % locals()
+        LOG.audit(msg, context=context)
         return user_dict(user, base64.b64encode(project.get_credentials(user)))
 
     def describe_project(self, context, name, **kwargs):
@@ -156,8 +174,9 @@ class AdminController(object):
     def register_project(self, context, name, manager_user, description=None,
                          member_users=None, **kwargs):
         """Creates a new project"""
-        LOG.audit(_("Create project %s managed by %s"), name, manager_user,
-                  context=context)
+        msg = _("Create project %(name)s managed by"
+                " %(manager_user)s") % locals()
+        LOG.audit(msg, context=context)
         return project_dict(
             manager.AuthManager().create_project(
                 name,
@@ -181,12 +200,13 @@ class AdminController(object):
                               **kwargs):
         """Add or remove a user from a project."""
         if operation == 'add':
-            LOG.audit(_("Adding user %s to project %s"), user, project,
-                      context=context)
+            msg = _("Adding user %(user)s to project %(project)s") % locals()
+            LOG.audit(msg, context=context)
             manager.AuthManager().add_to_project(user, project)
         elif operation == 'remove':
-            LOG.audit(_("Removing user %s from project %s"), user, project,
-                      context=context)
+            msg = _("Removing user %(user)s from"
+                    " project %(project)s") % locals()
+            LOG.audit(msg, context=context)
             manager.AuthManager().remove_from_project(user, project)
         else:
             raise exception.ApiError(_('operation must be add or remove'))
diff --git a/nova/api/ec2/apirequest.py b/nova/api/ec2/apirequest.py
index 78576470a..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):
@@ -93,8 +94,10 @@ class APIRequest(object):
             method = getattr(self.controller,
                              _camelcase_to_underscore(self.action))
         except AttributeError:
-            _error = _('Unsupported API request: controller = %s,'
-                       'action = %s') % (self.controller, self.action)
+            controller = self.controller
+            action = self.action
+            _error = _('Unsupported API request: controller = %(controller)s,'
+                    ' action = %(action)s') % locals()
             LOG.exception(_error)
             # TODO: Raise custom exception, trap in apiserver,
             #       and reraise as 400 error.
@@ -130,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 434a1921f..e2012066f 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -59,7 +59,7 @@ def _gen_key(context, user_id, key_name):
     #             creation before creating key_pair
     try:
         db.key_pair_get(context, user_id, key_name)
-        raise exception.Duplicate("The key_pair %s already exists"
+        raise exception.Duplicate(_("The key_pair %s already exists")
                                   % key_name)
     except exception.NotFound:
         pass
@@ -133,7 +133,7 @@ class CloudController(object):
         return result
 
     def _get_availability_zone_by_host(self, context, host):
-        services = db.service_get_all_by_host(context, host)
+        services = db.service_get_all_by_host(context.elevated(), host)
         if len(services) > 0:
             return services[0]['availability_zone']
         return 'unknown zone'
@@ -252,18 +252,18 @@ class CloudController(object):
             regions = []
             for region in FLAGS.region_list:
                 name, _sep, host = region.partition('=')
-                endpoint = '%s://%s:%s%s' % (FLAGS.ec2_prefix,
+                endpoint = '%s://%s:%s%s' % (FLAGS.ec2_scheme,
                                              host,
                                              FLAGS.ec2_port,
-                                             FLAGS.ec2_suffix)
+                                             FLAGS.ec2_path)
                 regions.append({'regionName': name,
                                 'regionEndpoint': endpoint})
         else:
             regions = [{'regionName': 'nova',
-                        'regionEndpoint': '%s://%s:%s%s' % (FLAGS.ec2_prefix,
+                        'regionEndpoint': '%s://%s:%s%s' % (FLAGS.ec2_scheme,
                                                             FLAGS.ec2_host,
                                                             FLAGS.ec2_port,
-                                                            FLAGS.ec2_suffix)}]
+                                                            FLAGS.ec2_path)}]
         return {'regionInfo': regions}
 
     def describe_snapshots(self,
@@ -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):
@@ -601,8 +604,9 @@ class CloudController(object):
     def attach_volume(self, context, volume_id, instance_id, device, **kwargs):
         volume_id = ec2_id_to_id(volume_id)
         instance_id = ec2_id_to_id(instance_id)
-        LOG.audit(_("Attach volume %s to instance %s at %s"), volume_id,
-                  instance_id, device, context=context)
+        msg = _("Attach volume %(volume_id)s to instance %(instance_id)s"
+                " at %(device)s") % locals()
+        LOG.audit(msg, context=context)
         self.compute_api.attach_volume(context,
                                        instance_id=instance_id,
                                        volume_id=volume_id,
@@ -657,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:
@@ -756,8 +763,8 @@ class CloudController(object):
         return {'releaseResponse': ["Address released."]}
 
     def associate_address(self, context, instance_id, public_ip, **kwargs):
-        LOG.audit(_("Associate address %s to instance %s"), public_ip,
-                  instance_id, context=context)
+        LOG.audit(_("Associate address %(public_ip)s to"
+                " instance %(instance_id)s") % locals(), context=context)
         instance_id = ec2_id_to_id(instance_id)
         self.compute_api.associate_floating_ip(context,
                                                instance_id=instance_id,
@@ -845,8 +852,9 @@ class CloudController(object):
         if image_location is None and 'name' in kwargs:
             image_location = kwargs['name']
         image_id = self.image_service.register(context, image_location)
-        LOG.audit(_("Registered image %s with id %s"), image_location,
-                  image_id, context=context)
+        msg = _("Registered image %(image_location)s with"
+                " id %(image_id)s") % locals()
+        LOG.audit(msg, context=context)
         return {'imageId': image_id}
 
     def describe_image_attribute(self, context, image_id, attribute, **kwargs):
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 8cbcebed2..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())
 
-        raise exception.NotFound(
-            _("No entry for image '%s' in mapping file '%s'") %
-                (image_id, mapping_filename))
+        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']),