Merge lp:~rackspace-titan/nova/instance-uuids into lp:~hudson-openstack/nova/trunk

[Brian Lamar]

This needs to be updated. This is a work in progress.

[lp:~rackspace-titan/nova/instance-uuids]

1568. By Brian Lamar on 2011-09-15

Merged trunk.

1569. By Brian Lamar on 2011-09-15

Merged trunk.

1570. By Brian Lamar on 2011-09-20

SQLite migrations.

1571. By Brian Waldon on 2011-09-20

merging trunk

1572. By Brian Waldon on 2011-09-20

fixing typo

1573. By Brian Waldon on 2011-09-20

removing useless stub

1574. By Brian Lamar on 2011-09-20

Compute API fix.

1575. By Brian Waldon on 2011-09-20

tests passing!

1576. By Brian Waldon on 2011-09-20

merging Lamar

1577. By Brian Waldon on 2011-09-20

fixing delete test

1578. By Brian Waldon on 2011-09-20

most compute tests work

1579. By Brian Waldon on 2011-09-20

merging lamar

1580. By Brian Lamar on 2011-09-20

Fixed notifier

1581. By Brian Lamar on 2011-09-20

instance_id -> instance_uuid change batch

1582. By Brian Lamar on 2011-09-20

More ID -> UUID updates.

1583. By Brian Lamar on 2011-09-20

Merged with Waldon.

1584. By Brian Lamar on 2011-09-20

Added instance_actions table to all migrations.

1585. By Brian Waldon on 2011-09-21

fixing tests

1586. By Brian Waldon on 2011-09-21

merging lamar

1587. By Brian Waldon on 2011-09-21

merging trunk

1588. By Brian Waldon on 2011-09-21

merging lamar

1589. By Brian Lamar on 2011-09-21

Updated instance_id -> instance_uuid in new 'soft delete' functionality.

1590. By Brian Lamar on 2011-09-21

fixes?

1591. By Brian Lamar on 2011-09-21

Merged with Waldon.

1592. By Brian Lamar on 2011-09-21

Arg, last two XenAPI tests working.

1593. By Brian Lamar on 2011-09-21

Small compute layer fix

1594. By Brian Lamar on 2011-09-21

Merged trunk.

1595. By Brian Lamar on 2011-09-21

Moved migrations

1596. By Brian Lamar on 2011-09-21

Making test_get_instance_mapping not as hacky.

1597. By Brian Lamar on 2011-09-21

Merged trunk and resolved conflicts.

1598. By Brian Lamar on 2011-09-21

Updated migration numbers.

1599. By Brian Lamar on 2011-09-21

Bad merge.

1600. By Brian Lamar on 2011-09-21

Fixed xen_api tests.

1601. By Brian Lamar on 2011-09-21

Libvirt tests running

1602. By Brian Lamar on 2011-09-22

Fix for test_ip_association_and_allocation_of_other_project

1603. By Brian Lamar on 2011-09-22

ID -> UUID updates.

1604. By Brian Lamar on 2011-09-22

Merged Trunk.

1605. By Brian Lamar on 2011-09-22

Can't have chain name use the UUID, it will be too long.

1606. By Brian Lamar on 2011-09-22

Update xenapi_conn.py to use UUIDs where needed.

Unmerged revisions

1606. By Brian Lamar on 2011-09-22

Update xenapi_conn.py to use UUIDs where needed.

1605. By Brian Lamar on 2011-09-22

Can't have chain name use the UUID, it will be too long.

1604. By Brian Lamar on 2011-09-22

Merged Trunk.

1603. By Brian Lamar on 2011-09-22

ID -> UUID updates.

1602. By Brian Lamar on 2011-09-22

Fix for test_ip_association_and_allocation_of_other_project

1601. By Brian Lamar on 2011-09-21

Libvirt tests running

1600. By Brian Lamar on 2011-09-21

Fixed xen_api tests.

1599. By Brian Lamar on 2011-09-21

Bad merge.

1598. By Brian Lamar on 2011-09-21

Updated migration numbers.

1597. By Brian Lamar on 2011-09-21

Merged trunk and resolved conflicts.

=== modified file 'bin/nova-manage'
--- bin/nova-manage	2011-09-20 09:55:56 +0000
+++ bin/nova-manage	2011-09-22 19:29:25 +0000
@@ -669,7 +669,7 @@
         try:
             fixed_ip = db.fixed_ip_get_by_address(ctxt, address)
             if fixed_ip is None:
-                raise exception.NotFound('Could not find address')
+                raise exception.NotFound()
             db.fixed_ip_update(ctxt, fixed_ip['address'],
                                 {'reserved': reserved})
         except exception.NotFound as ex:

=== modified file 'nova/api/ec2/__init__.py'
--- nova/api/ec2/__init__.py	2011-09-21 09:00:18 +0000
+++ nova/api/ec2/__init__.py	2011-09-22 19:29:25 +0000
@@ -348,8 +348,8 @@
         except exception.InstanceNotFound as ex:
             LOG.info(_('InstanceNotFound raised: %s'), unicode(ex),
                      context=context)
-            ec2_id = ec2utils.id_to_ec2_id(ex.kwargs['instance_id'])
-            message = ex.message % {'instance_id': ec2_id}
+            ec2_id = ec2utils.id_to_ec2_id(ex.kwargs['instance_uuid'])
+            message = ex.message % {'instance_uuid': ec2_id}
             return self._error(req, context, type(ex).__name__, message)
         except exception.VolumeNotFound as ex:
             LOG.info(_('VolumeNotFound raised: %s'), unicode(ex),

=== modified file 'nova/api/ec2/cloud.py'
--- nova/api/ec2/cloud.py	2011-09-21 15:54:30 +0000
+++ nova/api/ec2/cloud.py	2011-09-22 19:29:25 +0000
@@ -283,7 +283,7 @@
 
         # 'ephemeralN', 'swap' and ebs
         for bdm in db.block_device_mapping_get_all_by_instance(
-            ctxt, instance_ref['id']):
+            ctxt, instance_ref['uuid']):
             if bdm['no_device']:
                 continue
 
@@ -324,18 +324,18 @@
 
         # This ensures that all attributes of the instance
         # are populated.
-        instance_ref = db.instance_get(ctxt, instance_ref[0]['id'])
+        instance_ref = db.instance_get(ctxt, instance_ref[0]['uuid'])
 
         mpi = self._get_mpi_data(ctxt, instance_ref['project_id'])
         hostname = instance_ref['hostname']
         host = instance_ref['host']
         availability_zone = self._get_availability_zone_by_host(ctxt, host)
         floating_ip = db.instance_get_floating_address(ctxt,
-                                                       instance_ref['id'])
+                                                       instance_ref['uuid'])
         ec2_id = ec2utils.id_to_ec2_id(instance_ref['id'])
         image_ec2_id = self.image_ec2_id(instance_ref['image_ref'])
         security_groups = db.security_group_get_by_instance(ctxt,
-                                                            instance_ref['id'])
+                                                            instance_ref['uuid'])
         security_groups = [x['name'] for x in security_groups]
         mappings = self._format_instance_mapping(ctxt, instance_ref)
         data = {
@@ -916,8 +916,10 @@
         else:
             ec2_id = instance_id
         instance_id = ec2utils.ec2_id_to_id(ec2_id)
+        instance_uuid = self.compute_api.get_instance_uuid(context,
+                                                           instance_id)
         output = self.compute_api.get_console_output(
-                context, instance_id=instance_id)
+                context, instance_uuid=instance_uuid)
         now = utils.utcnow()
         return {"InstanceId": ec2_id,
                 "Timestamp": now,
@@ -926,15 +928,19 @@
     def get_ajax_console(self, context, instance_id, **kwargs):
         ec2_id = instance_id[0]
         instance_id = ec2utils.ec2_id_to_id(ec2_id)
+        instance_uuid = self.compute_api.get_instance_uuid(context,
+                                                           instance_id)
         return self.compute_api.get_ajax_console(context,
-                                                 instance_id=instance_id)
+                                                 instance_uuid=instance_uuid)
 
     def get_vnc_console(self, context, instance_id, **kwargs):
         """Returns vnc browser url.  Used by OS dashboard."""
         ec2_id = instance_id
         instance_id = ec2utils.ec2_id_to_id(ec2_id)
+        instance_uuid = self.compute_api.get_instance_uuid(context,
+                                                           instance_id)
         return self.compute_api.get_vnc_console(context,
-                                                instance_id=instance_id)
+                                                instance_uuid=instance_uuid)
 
     def describe_volumes(self, context, volume_id=None, **kwargs):
         if volume_id:
@@ -1029,11 +1035,13 @@
     def attach_volume(self, context, volume_id, instance_id, device, **kwargs):
         volume_id = ec2utils.ec2_id_to_id(volume_id)
         instance_id = ec2utils.ec2_id_to_id(instance_id)
-        msg = _("Attach volume %(volume_id)s to instance %(instance_id)s"
+        instance_uuid = self.compute_api.get_instance_uuid(context,
+                                                           instance_id)
+        msg = _("Attach volume %(volume_id)s to instance %(instance_uuid)s"
                 " at %(device)s") % locals()
         LOG.audit(msg, context=context)
         self.compute_api.attach_volume(context,
-                                       instance_id=instance_id,
+                                       instance_uuid=instance_uuid,
                                        volume_id=volume_id,
                                        device=device)
         volume = self.volume_api.get(context, volume_id=volume_id)
@@ -1140,7 +1148,9 @@
 
         ec2_instance_id = instance_id
         instance_id = ec2utils.ec2_id_to_id(ec2_instance_id)
-        instance = self.compute_api.get(context, instance_id)
+        instance_uuid = self.compute_api.get_instance_uuid(context,
+                                                           instance_id)
+        instance = self.compute_api.get(context, instance_uuid)
         result = {'instance_id': ec2_instance_id}
         fn(instance, result)
         return result
@@ -1169,9 +1179,11 @@
                              result):
         """Format InstanceBlockDeviceMappingResponseItemType"""
         root_device_type = 'instance-store'
+        instance_uuid = self.compute_api.get_instance_uuid(context,
+                                                           instance_id)
         mapping = []
         for bdm in db.block_device_mapping_get_all_by_instance(context,
-                                                               instance_id):
+                                                               instance_uuid):
             volume_id = bdm['volume_id']
             if (volume_id is None or bdm['no_device']):
                 continue
@@ -1228,9 +1240,11 @@
         if instance_id:
             instances = []
             for ec2_id in instance_id:
-                internal_id = ec2utils.ec2_id_to_id(ec2_id)
+                instance_id = ec2utils.ec2_id_to_id(ec2_id)
+                instance_uuid = self.compute_api.get_instance_uuid(context,
+                                                                  instance_id)
                 try:
-                    instance = self.compute_api.get(context, internal_id)
+                    instance = self.compute_api.get(context, instance_uuid)
                 except exception.NotFound:
                     continue
                 instances.append(instance)
@@ -1285,7 +1299,7 @@
             self._format_instance_type(instance, i)
             i['launchTime'] = instance['created_at']
             i['amiLaunchIndex'] = instance['launch_index']
-            i['displayName'] = instance['display_name']
+            i['displayName'] = "Server %s" % instance_id
             i['displayDescription'] = instance['display_description']
             self._format_instance_root_device_name(instance, i)
             self._format_instance_bdm(context, instance_id,
@@ -1353,8 +1367,10 @@
         LOG.audit(_("Associate address %(public_ip)s to"
                 " instance %(instance_id)s") % locals(), context=context)
         instance_id = ec2utils.ec2_id_to_id(instance_id)
+        instance_uuid = self.compute_api.get_instance_uuid(context,
+                                                           instance_id)
         self.compute_api.associate_floating_ip(context,
-                                               instance_id=instance_id,
+                                               instance_uuid=instance_uuid,
                                                address=public_ip)
         return {'associateResponse': ["Address associated."]}
 
@@ -1405,10 +1421,12 @@
 
     def _do_instance(self, action, context, ec2_id):
         instance_id = ec2utils.ec2_id_to_id(ec2_id)
-        action(context, instance_id=instance_id)
+        instance_uuid = self.compute_api.get_instance_uuid(context,
+                                                           instance_id)
+        action(context, instance_uuid=instance_uuid)
 
-    def _do_instances(self, action, context, instance_id):
-        for ec2_id in instance_id:
+    def _do_instances(self, action, context, ec2_id_list):
+        for ec2_id in ec2_id_list:
             self._do_instance(action, context, ec2_id)
 
     def terminate_instances(self, context, instance_id, **kwargs):
@@ -1456,7 +1474,9 @@
                 changes[field] = kwargs[field]
         if changes:
             instance_id = ec2utils.ec2_id_to_id(instance_id)
-            self.compute_api.update(context, instance_id=instance_id,
+            instance_uuid = self.compute_api.get_instance_uuid(context,
+                                                               instance_id)
+            self.compute_api.update(context, instance_uuid=instance_uuid,
                                     **changes)
         return True
 
@@ -1670,7 +1690,9 @@
 
         ec2_instance_id = instance_id
         instance_id = ec2utils.ec2_id_to_id(ec2_instance_id)
-        instance = self.compute_api.get(context, instance_id)
+        instance_uuid = self.compute_api.get_instance_uuid(context,
+                                                           instance_id)
+        instance = self.compute_api.get(context, instance_uuid)
 
         # stop the instance if necessary
         restart_instance = False
@@ -1683,7 +1705,7 @@
 
             if vm_state == vm_states.ACTIVE:
                 restart_instance = True
-                self.compute_api.stop(context, instance_id=instance_id)
+                self.compute_api.stop(context, instance_uuid=instance_uuid)
 
             # wait instance for really stopped
             start_time = time.time()
@@ -1706,7 +1728,7 @@
 
         mapping = []
         bdms = db.block_device_mapping_get_all_by_instance(context,
-                                                           instance_id)
+                                                           instance_uuid)
         for bdm in bdms:
             if bdm.no_device:
                 continue
@@ -1759,6 +1781,6 @@
         image_id = self._register_image(context, src_image)
 
         if restart_instance:
-            self.compute_api.start(context, instance_id=instance_id)
+            self.compute_api.start(context, instance_uuid=instance_uuid)
 
         return {'imageId': image_id}

=== modified file 'nova/api/ec2/ec2utils.py'
--- nova/api/ec2/ec2utils.py	2011-09-21 16:34:59 +0000
+++ nova/api/ec2/ec2utils.py	2011-09-22 19:29:25 +0000
@@ -18,11 +18,28 @@
 
 import re
 
+from nova import context
+from nova import db
 from nova import exception
+import nova.compute.api
+
+
+def ec2_id_to_uuid(_context, ec2_id):
+    """convert an ec2 id (i-[base 16 number]) to an instance uuid (string)"""
+    ctx = context.get_admin_context()
+    try:
+        instance_id = int(ec2_id.split('-')[-1], 16)
+    except valueerror:
+        raise exception.InvalidEc2Id(ec2_id=ec2_id)
+
+    for instance in  db.instance_get_all(ctx):
+        raise Exception(instance.__dict__)
+
+    return compute_api.get_instance_uuid(ctx, instance_id)
 
 
 def ec2_id_to_id(ec2_id):
-    """Convert an ec2 ID (i-[base 16 number]) to an instance id (int)"""
+    """convert an ec2 id (i-[base 16 number]) to an instance id (int)"""
     try:
         return int(ec2_id.split('-')[-1], 16)
     except ValueError:

=== modified file 'nova/api/openstack/contrib/volumes.py'
--- nova/api/openstack/contrib/volumes.py	2011-09-14 19:33:51 +0000
+++ nova/api/openstack/contrib/volumes.py	2011-09-22 19:29:25 +0000
@@ -200,8 +200,8 @@
     d['id'] = volume_id
 
     d['volumeId'] = volume_id
-    if vol.get('instance_id'):
-        d['serverId'] = vol['instance_id']
+    if vol.get('instance_uuid'):
+        d['serverId'] = vol['instance_uuid']
     if vol.get('mountpoint'):
         d['device'] = vol['mountpoint']
 
@@ -245,8 +245,8 @@
             LOG.debug("volume_id not found")
             return faults.Fault(exc.HTTPNotFound())
 
-        if str(vol['instance_id']) != server_id:
-            LOG.debug("instance_id != server_id")
+        if str(vol['instance_uuid']) != server_id:
+            LOG.debug("instance_uuid != server_id")
             return faults.Fault(exc.HTTPNotFound())
 
         return {'volumeAttachment': _translate_attachment_detail_view(context,
@@ -259,7 +259,7 @@
         if not body:
             return faults.Fault(exc.HTTPUnprocessableEntity())
 
-        instance_id = server_id
+        instance_uuid = server_id
         volume_id = body['volumeAttachment']['volumeId']
         device = body['volumeAttachment']['device']
 
@@ -269,7 +269,7 @@
 
         try:
             self.compute_api.attach_volume(context,
-                                           instance_id=instance_id,
+                                           instance_uuid=instance_uuid,
                                            volume_id=volume_id,
                                            device=device)
         except exception.NotFound:
@@ -307,8 +307,8 @@
         except exception.NotFound:
             return faults.Fault(exc.HTTPNotFound())
 
-        if str(vol['instance_id']) != server_id:
-            LOG.debug("instance_id != server_id")
+        if str(vol['instance_uuid']) != server_id:
+            LOG.debug("instance_uuid != server_id")
             return faults.Fault(exc.HTTPNotFound())
 
         self.compute_api.detach_volume(context,

=== modified file 'nova/api/openstack/images.py'
--- nova/api/openstack/images.py	2011-09-20 21:11:49 +0000
+++ nova/api/openstack/images.py	2011-09-22 19:29:25 +0000
@@ -124,9 +124,12 @@
             raise webob.exc.HTTPBadRequest(explanation=msg)
 
         context = req.environ["nova.context"]
+        instance_uuid = self._compute_service.get_instance_uuid(context,
+                                                                instance_id)
+        #NOTE(bcwaldon): purposefully use instance id here instead of uuid
         props = {'instance_id': instance_id}
         image = self._compute_service.snapshot(context,
-                                          instance_id,
+                                          instance_uuid,
                                           image_name,
                                           extra_properties=props)
 

=== modified file 'nova/api/openstack/schemas/v1.1/server.rng'
--- nova/api/openstack/schemas/v1.1/server.rng	2011-09-08 17:44:37 +0000
+++ nova/api/openstack/schemas/v1.1/server.rng	2011-09-22 19:29:25 +0000
@@ -4,7 +4,6 @@
   <attribute name="userId">      <text/> </attribute>
   <attribute name="tenantId">      <text/> </attribute>
   <attribute name="id">      <text/> </attribute>
-  <attribute name="uuid"> <text/> </attribute>
   <attribute name="updated">   <text/> </attribute>
   <attribute name="created">   <text/> </attribute>
   <attribute name="hostId">   <text/> </attribute>

=== modified file 'nova/api/openstack/servers.py'
--- nova/api/openstack/servers.py	2011-09-22 15:41:34 +0000
+++ nova/api/openstack/servers.py	2011-09-22 19:29:25 +0000
@@ -74,6 +74,9 @@
         self.compute_api = compute.API()
         self.helper = helper.CreateInstanceHelper(self)
 
+    def _convert_id(self, _context, instance_uuid):
+        return instance_uuid
+
     def index(self, req):
         """ Returns a list of server names and ids for a given user """
         try:
@@ -103,7 +106,7 @@
     def _limit_items(self, items, req):
         raise NotImplementedError()
 
-    def _action_rebuild(self, info, request, instance_id):
+    def _action_rebuild(self, info, request, instance_uuid):
         raise NotImplementedError()
 
     def _get_servers(self, req, is_detail):
@@ -161,9 +164,10 @@
     @scheduler_api.redirect_handler
     def show(self, req, id):
         """ Returns server details by server id """
+        context = req.environ['nova.context']
+        uuid = self._convert_id(context, id)
         try:
-            instance = self.compute_api.routing_get(
-                req.environ['nova.context'], id)
+            instance = self.compute_api.routing_get(context, uuid)
             return self._build_view(req, instance, is_detail=True)
         except exception.NotFound:
             raise exc.HTTPNotFound()
@@ -208,6 +212,8 @@
             raise exc.HTTPUnprocessableEntity()
 
         ctxt = req.environ['nova.context']
+        uuid = self._convert_id(ctxt, id)
+
         update_dict = {}
 
         if 'name' in body['server']:
@@ -224,13 +230,13 @@
             update_dict['access_ip_v6'] = access_ipv6.strip()
 
         try:
-            self.compute_api.update(ctxt, id, **update_dict)
+            self.compute_api.update(ctxt, uuid, **update_dict)
         except exception.NotFound:
             raise exc.HTTPNotFound()
 
-        return self._update(ctxt, req, id, body)
+        return self._update(ctxt, req, uuid, body)
 
-    def _update(self, context, req, id, inst_dict):
+    def _update(self, context, req, uuid, inst_dict):
         return exc.HTTPNotImplemented()
 
     @novaclient_exception_converter
@@ -264,7 +270,7 @@
         msg = _("Invalid request body")
         raise exc.HTTPBadRequest(explanation=msg)
 
-    def _action_create_backup(self, input_dict, req, instance_id):
+    def _action_create_backup(self, input_dict, req, instance_uuid):
         """Backup a server instance.
 
         Images now have an `image_type` associated with them, which can be
@@ -277,6 +283,9 @@
         """
         entity = input_dict["createBackup"]
 
+        context = req.environ["nova.context"]
+        uuid = self._convert_id(context, instance_uuid)
+
         try:
             image_name = entity["name"]
             backup_type = entity["backup_type"]
@@ -297,13 +306,10 @@
             raise webob.exc.HTTPBadRequest(explanation=msg)
 
         # preserve link to server in image properties
-        server_ref = os.path.join(req.application_url,
-                                  'servers',
-                                  str(instance_id))
+        server_ref = os.path.join(req.application_url, 'servers', uuid)
         props = {'instance_ref': server_ref}
 
         metadata = entity.get('metadata', {})
-        context = req.environ["nova.context"]
         common.check_img_metadata_quota_limit(context, metadata)
         try:
             props.update(metadata)
@@ -312,7 +318,7 @@
             raise webob.exc.HTTPBadRequest(explanation=msg)
 
         image = self.compute_api.backup(context,
-                                        instance_id,
+                                        uuid,
                                         image_name,
                                         backup_type,
                                         rotation,
@@ -327,32 +333,36 @@
         return resp
 
     @common.check_snapshots_enabled
-    def _action_create_image(self, input_dict, req, id):
-        return exc.HTTPNotImplemented()
-
-    def _action_change_password(self, input_dict, req, id):
-        return exc.HTTPNotImplemented()
-
-    def _action_confirm_resize(self, input_dict, req, id):
+    def _action_create_image(self, input_dict, req, instance_uuid):
+        return exc.HTTPNotImplemented()
+
+    def _action_change_password(self, input_dict, req, instance_uuid):
+        return exc.HTTPNotImplemented()
+
+    def _action_confirm_resize(self, input_dict, req, instance_uuid):
+        context = req.environ['nova.context']
+        uuid = self._convert_id(context, instance_uuid)
         try:
-            self.compute_api.confirm_resize(req.environ['nova.context'], id)
+            self.compute_api.confirm_resize(context, uuid)
         except Exception, e:
             LOG.exception(_("Error in confirm-resize %s"), e)
             raise exc.HTTPBadRequest()
         return exc.HTTPNoContent()
 
-    def _action_revert_resize(self, input_dict, req, id):
+    def _action_revert_resize(self, input_dict, req, instance_uuid):
+        context = req.environ['nova.context']
+        uuid = self._convert_id(context, instance_uuid)
         try:
-            self.compute_api.revert_resize(req.environ['nova.context'], id)
+            self.compute_api.revert_resize(context, uuid)
         except Exception, e:
             LOG.exception(_("Error in revert-resize %s"), e)
             raise exc.HTTPBadRequest()
         return webob.Response(status_int=202)
 
-    def _action_resize(self, input_dict, req, id):
+    def _action_resize(self, input_dict, req, instance_uuid):
         return exc.HTTPNotImplemented()
 
-    def _action_reboot(self, input_dict, req, id):
+    def _action_reboot(self, input_dict, req, instance_uuid):
         if 'reboot' in input_dict and 'type' in input_dict['reboot']:
             valid_reboot_types = ['HARD', 'SOFT']
             reboot_type = input_dict['reboot']['type'].upper()
@@ -364,9 +374,12 @@
             msg = _("Missing argument 'type' for reboot")
             LOG.exception(msg)
             raise exc.HTTPBadRequest(explanation=msg)
+
+        context = req.environ['nova.context']
+        uuid = self._convert_id(context, instance_uuid)
+
         try:
-            self.compute_api.reboot(req.environ['nova.context'], id,
-                    reboot_type)
+            self.compute_api.reboot(context, uuid, reboot_type)
         except Exception, e:
             LOG.exception(_("Error in reboot %s"), e)
             raise exc.HTTPUnprocessableEntity()
@@ -381,8 +394,9 @@
 
         """
         context = req.environ['nova.context']
+        uuid = self._convert_id(context, id)
         try:
-            self.compute_api.lock(context, id)
+            self.compute_api.lock(context, uuid)
         except Exception:
             readable = traceback.format_exc()
             LOG.exception(_("Compute.api::lock %s"), readable)
@@ -398,8 +412,9 @@
 
         """
         context = req.environ['nova.context']
+        uuid = self._convert_id(context, id)
         try:
-            self.compute_api.unlock(context, id)
+            self.compute_api.unlock(context, uuid)
         except Exception:
             readable = traceback.format_exc()
             LOG.exception(_("Compute.api::unlock %s"), readable)
@@ -414,8 +429,9 @@
 
         """
         context = req.environ['nova.context']
+        uuid = self._convert_id(context, id)
         try:
-            self.compute_api.get_lock(context, id)
+            self.compute_api.get_lock(context, uuid)
         except Exception:
             readable = traceback.format_exc()
             LOG.exception(_("Compute.api::get_lock %s"), readable)
@@ -430,8 +446,9 @@
 
         """
         context = req.environ['nova.context']
+        uuid = self._convert_id(context, id)
         try:
-            self.compute_api.reset_network(context, id)
+            self.compute_api.reset_network(context, uuid)
         except Exception:
             readable = traceback.format_exc()
             LOG.exception(_("Compute.api::reset_network %s"), readable)
@@ -446,8 +463,9 @@
 
         """
         context = req.environ['nova.context']
+        uuid = self._convert_id(context, id)
         try:
-            self.compute_api.inject_network_info(context, id)
+            self.compute_api.inject_network_info(context, uuid)
         except Exception:
             readable = traceback.format_exc()
             LOG.exception(_("Compute.api::inject_network_info %s"), readable)
@@ -459,8 +477,9 @@
     def pause(self, req, id):
         """ Permit Admins to Pause the server. """
         ctxt = req.environ['nova.context']
+        uuid = self._convert_id(ctxt, id)
         try:
-            self.compute_api.pause(ctxt, id)
+            self.compute_api.pause(ctxt, uuid)
         except Exception:
             readable = traceback.format_exc()
             LOG.exception(_("Compute.api::pause %s"), readable)
@@ -472,8 +491,9 @@
     def unpause(self, req, id):
         """ Permit Admins to Unpause the server. """
         ctxt = req.environ['nova.context']
+        uuid = self._convert_id(ctxt, id)
         try:
-            self.compute_api.unpause(ctxt, id)
+            self.compute_api.unpause(ctxt, uuid)
         except Exception:
             readable = traceback.format_exc()
             LOG.exception(_("Compute.api::unpause %s"), readable)
@@ -485,8 +505,9 @@
     def suspend(self, req, id):
         """permit admins to suspend the server"""
         context = req.environ['nova.context']
+        uuid = self._convert_id(context, id)
         try:
-            self.compute_api.suspend(context, id)
+            self.compute_api.suspend(context, uuid)
         except Exception:
             readable = traceback.format_exc()
             LOG.exception(_("compute.api::suspend %s"), readable)
@@ -498,8 +519,9 @@
     def resume(self, req, id):
         """permit admins to resume the server from suspend"""
         context = req.environ['nova.context']
+        uuid = self._convert_id(context, id)
         try:
-            self.compute_api.resume(context, id)
+            self.compute_api.resume(context, uuid)
         except Exception:
             readable = traceback.format_exc()
             LOG.exception(_("compute.api::resume %s"), readable)
@@ -509,8 +531,10 @@
     @novaclient_exception_converter
     @scheduler_api.redirect_handler
     def migrate(self, req, id):
+        context = req.environ['nova.context']
+        uuid = self._convert_id(context, id)
         try:
-            self.compute_api.resize(req.environ['nova.context'], id)
+            self.compute_api.resize(context, id)
         except Exception, e:
             LOG.exception(_("Error in migrate %s"), e)
             raise exc.HTTPBadRequest()
@@ -521,13 +545,14 @@
     def rescue(self, req, id, body={}):
         """Permit users to rescue the server."""
         context = req.environ["nova.context"]
+        uuid = self._convert_id(context, id)
         try:
             if 'rescue' in body and body['rescue'] and \
                     'adminPass' in body['rescue']:
                 password = body['rescue']['adminPass']
             else:
                 password = utils.generate_password(FLAGS.password_length)
-            self.compute_api.rescue(context, id, rescue_password=password)
+            self.compute_api.rescue(context, uuid, rescue_password=password)
         except Exception:
             readable = traceback.format_exc()
             LOG.exception(_("compute.api::rescue %s"), readable)
@@ -540,6 +565,7 @@
     def unrescue(self, req, id):
         """Permit users to unrescue the server."""
         context = req.environ["nova.context"]
+        uuid = self._convert_id(context, id)
         try:
             self.compute_api.unrescue(context, id)
         except Exception:
@@ -552,9 +578,10 @@
     @scheduler_api.redirect_handler
     def get_ajax_console(self, req, id):
         """Returns a url to an instance's ajaxterm console."""
+        context = req.environ['nova.context']
+        uuid = self._convert_id(context, id)
         try:
-            self.compute_api.get_ajax_console(req.environ['nova.context'],
-                int(id))
+            self.compute_api.get_ajax_console(context, uuid)
         except exception.NotFound:
             raise exc.HTTPNotFound()
         return webob.Response(status_int=202)
@@ -563,9 +590,10 @@
     @scheduler_api.redirect_handler
     def get_vnc_console(self, req, id):
         """Returns a url to an instance's ajaxterm console."""
+        context = req.environ['nova.context']
+        uuid = self._convert_id(context, id)
         try:
-            self.compute_api.get_vnc_console(req.environ['nova.context'],
-                                             int(id))
+            self.compute_api.get_vnc_console(context, uuid)
         except exception.NotFound:
             raise exc.HTTPNotFound()
         return webob.Response(status_int=202)
@@ -575,12 +603,14 @@
     def diagnostics(self, req, id):
         """Permit Admins to retrieve server diagnostics."""
         ctxt = req.environ["nova.context"]
-        return self.compute_api.get_diagnostics(ctxt, id)
+        uuid = self._convert_id(ctxt, id)
+        return self.compute_api.get_diagnostics(ctxt, uuid)
 
     def actions(self, req, id):
         """Permit Admins to retrieve server actions."""
         ctxt = req.environ["nova.context"]
-        items = self.compute_api.get_actions(ctxt, id)
+        uuid = self._convert_id(ctxt, id)
+        items = self.compute_api.get_actions(ctxt, uuid)
         actions = []
         # TODO(jk0): Do not do pre-serialization here once the default
         # serializer is updated
@@ -591,12 +621,12 @@
                 error=item.error))
         return dict(actions=actions)
 
-    def resize(self, req, instance_id, flavor_id):
+    def resize(self, req, instance_uuid, flavor_id):
         """Begin the resize process with given instance/flavor."""
         context = req.environ["nova.context"]
 
         try:
-            self.compute_api.resize(context, instance_id, flavor_id)
+            self.compute_api.resize(context, instance_uuid, flavor_id)
         except exception.FlavorNotFound:
             msg = _("Unable to locate requested flavor.")
             raise exc.HTTPBadRequest(explanation=msg)
@@ -613,12 +643,20 @@
 class ControllerV10(Controller):
     """v1.0 OpenStack API controller"""
 
+    def _convert_id(self, context, instance_id):
+        try:
+            return self.compute_api.get_instance_uuid(context, instance_id)
+        except exception.NotFound:
+            raise exc.HTTPNotFound()
+
     @novaclient_exception_converter
     @scheduler_api.redirect_handler
     def delete(self, req, id):
         """ Destroys a server """
+        context = req.environ['nova.context']
+        uuid = self._convert_id(context, id)
         try:
-            self._delete(req.environ['nova.context'], id)
+            self._delete(req.environ['nova.context'], uuid)
         except exception.NotFound:
             raise exc.HTTPNotFound()
         return webob.Response(status_int=202)
@@ -649,25 +687,27 @@
     def _limit_items(self, items, req):
         return common.limited(items, req)
 
-    def _update(self, context, req, id, inst_dict):
+    def _update(self, context, req, uuid, inst_dict):
         if 'adminPass' in inst_dict['server']:
-            self.compute_api.set_admin_password(context, id,
-                    inst_dict['server']['adminPass'])
+            admin_pass = inst_dict['server']['adminPass']
+            self.compute_api.set_admin_password(context, uuid, admin_pass)
         return exc.HTTPNoContent()
 
-    def _action_resize(self, input_dict, req, id):
+    def _action_resize(self, input_dict, req, instance_id):
         """ Resizes a given instance to the flavor size requested """
+        context = req.environ['nova.context']
+        uuid = self._convert_id(context, instance_id)
         try:
             flavor_id = input_dict["resize"]["flavorId"]
         except (KeyError, TypeError):
             msg = _("Resize requests require 'flavorId' attribute.")
             raise exc.HTTPBadRequest(explanation=msg)
 
-        return self.resize(req, id, flavor_id)
+        return self.resize(req, uuid, flavor_id)
 
     def _action_rebuild(self, info, request, instance_id):
         context = request.environ['nova.context']
-
+        uuid = self._convert_id(context, instance_id)
         try:
             image_id = info["rebuild"]["imageId"]
         except (KeyError, TypeError):
@@ -678,9 +718,9 @@
         password = utils.generate_password(FLAGS.password_length)
 
         try:
-            self.compute_api.rebuild(context, instance_id, image_id, password)
+            self.compute_api.rebuild(context, uuid, image_id, password)
         except exception.RebuildRequiresActiveInstance:
-            msg = _("Instance %s must be active to rebuild.") % instance_id
+            msg = _("Instance %s must be active to rebuild.") % uuid
             raise exc.HTTPConflict(explanation=msg)
 
         return webob.Response(status_int=202)
@@ -806,11 +846,11 @@
                 LOG.info(msg)
                 raise exc.HTTPBadRequest(explanation=msg)
 
-    def _update(self, context, req, id, inst_dict):
-        instance = self.compute_api.routing_get(context, id)
+    def _update(self, context, req, uuid, inst_dict):
+        instance = self.compute_api.routing_get(context, uuid)
         return self._build_view(req, instance, is_detail=True)
 
-    def _action_resize(self, input_dict, req, id):
+    def _action_resize(self, input_dict, req, instance_uuid):
         """ Resizes a given instance to the flavor size requested """
         try:
             flavor_ref = input_dict["resize"]["flavorRef"]
@@ -821,9 +861,9 @@
             msg = _("Resize requests require 'flavorRef' attribute.")
             raise exc.HTTPBadRequest(explanation=msg)
 
-        return self.resize(req, id, flavor_ref)
+        return self.resize(req, instance_uuid, flavor_ref)
 
-    def _action_rebuild(self, info, request, instance_id):
+    def _action_rebuild(self, info, request, instance_uuid):
         context = request.environ['nova.context']
 
         try:
@@ -847,24 +887,24 @@
             password = utils.generate_password(FLAGS.password_length)
 
         try:
-            self.compute_api.rebuild(context, instance_id, image_href,
+            self.compute_api.rebuild(context, instance_uuid, image_href,
                                      password, name=name, metadata=metadata,
                                      files_to_inject=personalities)
         except exception.RebuildRequiresActiveInstance:
-            msg = _("Instance %s must be active to rebuild.") % instance_id
+            msg = _("Instance %s must be active to rebuild.") % instance_uuid
             raise exc.HTTPConflict(explanation=msg)
         except exception.InstanceNotFound:
-            msg = _("Instance %s could not be found") % instance_id
+            msg = _("Instance %s could not be found") % instance_uuid
             raise exc.HTTPNotFound(explanation=msg)
 
-        instance = self.compute_api.routing_get(context, instance_id)
+        instance = self.compute_api.routing_get(context, instance_uuid)
         view = self._build_view(request, instance, is_detail=True)
         view['server']['adminPass'] = password
 
         return view
 
     @common.check_snapshots_enabled
-    def _action_create_image(self, input_dict, req, instance_id):
+    def _action_create_image(self, input_dict, req, instance_uuid):
         """Snapshot a server instance."""
         entity = input_dict.get("createImage", {})
 
@@ -882,7 +922,7 @@
         # preserve link to server in image properties
         server_ref = os.path.join(req.application_url,
                                   'servers',
-                                  str(instance_id))
+                                  instance_uuid)
         props = {'instance_ref': server_ref}
 
         metadata = entity.get('metadata', {})
@@ -895,7 +935,7 @@
             raise webob.exc.HTTPBadRequest(explanation=msg)
 
         image = self.compute_api.snapshot(context,
-                                          instance_id,
+                                          instance_uuid,
                                           image_name,
                                           extra_properties=props)
 
@@ -977,8 +1017,8 @@
 
         server_elem.set('name', server_dict['name'])
         server_elem.set('id', str(server_dict['id']))
+
         if detailed:
-            server_elem.set('uuid', str(server_dict['uuid']))
             server_elem.set('userId', str(server_dict['user_id']))
             server_elem.set('tenantId', str(server_dict['tenant_id']))
             server_elem.set('updated', str(server_dict['updated']))

=== modified file 'nova/api/openstack/views/servers.py'
--- nova/api/openstack/views/servers.py	2011-09-22 15:41:34 +0000
+++ nova/api/openstack/views/servers.py	2011-09-22 19:29:25 +0000
@@ -66,7 +66,12 @@
 
     def _build_simple(self, inst):
         """Return a simple model of a server."""
-        return dict(server=dict(id=inst['id'], name=inst['display_name']))
+        return {
+            'server': {
+                'id': self._get_instance_id(inst),
+                'name': inst['display_name'],
+            },
+        }
 
     def _build_detail(self, inst):
         """Returns a detailed model of a server."""
@@ -74,7 +79,7 @@
         task_state = inst.get('task_state')
 
         inst_dict = {
-            'id': inst['id'],
+            'id': self._get_instance_id(inst),
             'name': inst['display_name'],
             'user_id': inst.get('user_id', ''),
             'tenant_id': inst.get('project_id', ''),
@@ -111,13 +116,13 @@
     def _build_extra(self, response, inst):
         pass
 
+    def _get_instance_id(self, inst):
+        raise NotImplementedError()
+
 
 class ViewBuilderV10(ViewBuilder):
     """Model an Openstack API V1.0 server response."""
 
-    def _build_extra(self, response, inst):
-        response['uuid'] = inst['uuid']
-
     def _build_image(self, response, inst):
         if inst.get('image_ref', None):
             image_ref = inst['image_ref']
@@ -132,6 +137,9 @@
     def _build_addresses(self, response, inst):
         response['addresses'] = self.addresses_builder.build(inst)
 
+    def _get_instance_id(self, inst):
+        return inst.get('id')
+
 
 class ViewBuilderV11(ViewBuilder):
     """Model an Openstack API V1.0 server response."""
@@ -196,11 +204,10 @@
 
     def _build_extra(self, response, inst):
         self._build_links(response, inst)
-        response['uuid'] = inst['uuid']
 
     def _build_links(self, response, inst):
-        href = self.generate_href(inst["id"])
-        bookmark = self.generate_bookmark(inst["id"])
+        href = self.generate_href(inst["uuid"])
+        bookmark = self.generate_bookmark(inst["uuid"])
 
         links = [
             {
@@ -249,3 +256,6 @@
         """Create an url that refers to a specific flavor id."""
         return os.path.join(common.remove_version_from_href(self.base_url),
             self.project_id, "servers", str(server_id))
+
+    def _get_instance_id(self, inst):
+        return inst.get('uuid')

=== modified file 'nova/compute/api.py'
--- nova/compute/api.py	2011-09-21 21:00:53 +0000
+++ nova/compute/api.py	2011-09-22 19:29:25 +0000
@@ -74,7 +74,7 @@
     return display_name.translate(table, deletions)
 
 
-def _is_able_to_shutdown(instance, instance_id):
+def _is_able_to_shutdown(instance, instance_uuid):
     vm_state = instance["vm_state"]
     task_state = instance["task_state"]
 
@@ -85,19 +85,20 @@
     ]
 
     if vm_state not in valid_shutdown_states:
-        LOG.warn(_("Instance %(instance_id)s is not in an 'active' state. It "
-                   "is currently %(vm_state)s. Shutdown aborted.") % locals())
+        LOG.warn(_("Instance %(instance_uuid)s is not in an 'active' "
+                   "state. It is currently %(vm_state)s. Shutdown "
+                   "aborted.") % locals())
         return False
 
     return True
 
 
-def _is_queued_delete(instance, instance_id):
+def _is_queued_delete(instance, instance_uuid):
     vm_state = instance["vm_state"]
     task_state = instance["task_state"]
 
     if vm_state != vm_states.SOFT_DELETE:
-        LOG.warn(_("Instance %(instance_id)s is not in a 'soft delete' "
+        LOG.warn(_("Instance %(instance_uuid)s is not in a 'soft delete' "
                    "state. It is currently %(vm_state)s. Action aborted.") %
                  locals())
         return False
@@ -320,7 +321,7 @@
         return size
 
     def _update_image_block_device_mapping(self, elevated_context,
-                                           instance_type, instance_id,
+                                           instance_type, instance_uuid,
                                            mappings):
         """tell vm driver to create ephemeral/swap device at boot time by
         updating BlockDeviceMapping
@@ -343,7 +344,7 @@
                 continue
 
             values = {
-                'instance_id': instance_id,
+                'instance_uuid': instance_uuid,
                 'device_name': bdm['device'],
                 'virtual_name': virtual_name,
                 'volume_size': size}
@@ -351,7 +352,7 @@
                                                           values)
 
     def _update_block_device_mapping(self, elevated_context,
-                                     instance_type, instance_id,
+                                     instance_type, instance_uuid,
                                      block_device_mapping):
         """tell vm driver to attach volume at boot time by updating
         BlockDeviceMapping
@@ -360,7 +361,7 @@
         for bdm in block_device_mapping:
             assert 'device_name' in bdm
 
-            values = {'instance_id': instance_id}
+            values = {'instance_uuid': instance_uuid}
             for key in ('device_name', 'delete_on_termination', 'virtual_name',
                         'snapshot_id', 'volume_id', 'volume_size',
                         'no_device'):
@@ -413,47 +414,55 @@
 
         instance = dict(launch_index=num, **base_options)
         instance = self.db.instance_create(context, instance)
-        instance_id = instance['id']
+        instance_uuid = instance['uuid']
 
         for security_group_id in security_groups:
             self.db.instance_add_security_group(elevated,
-                                                instance_id,
+                                                instance_uuid,
                                                 security_group_id)
 
-        # BlockDeviceMapping table
-        self._update_image_block_device_mapping(elevated, instance_type,
-            instance_id, image['properties'].get('mappings', []))
-        self._update_block_device_mapping(elevated, instance_type, instance_id,
-            image['properties'].get('block_device_mapping', []))
-        # override via command line option
-        self._update_block_device_mapping(elevated, instance_type, instance_id,
+        mappings = image['properties'].get('mappings', [])
+        self._update_image_block_device_mapping(elevated,
+                                                instance_type,
+                                                instance_uuid,
+                                                mappings)
+
+        device_mapping = image['properties'].get('block_device_mapping', [])
+        self._update_block_device_mapping(elevated,
+                                          instance_type,
+                                          instance_uuid,
+                                          device_mapping)
+
+        self._update_block_device_mapping(elevated,
+                                          instance_type,
+                                          instance_uuid,
                                           block_device_mapping)
 
         # Set sane defaults if not specified
         updates = {}
         if (not hasattr(instance, 'display_name') or
                 instance.display_name is None):
-            updates['display_name'] = "Server %s" % instance_id
+            updates['display_name'] = "Server %s" % instance_uuid
             instance['display_name'] = updates['display_name']
         updates['hostname'] = self.hostname_factory(instance)
         updates['vm_state'] = vm_states.BUILDING
         updates['task_state'] = task_states.SCHEDULING
 
-        instance = self.update(context, instance_id, **updates)
+        instance = self.update(context, instance_uuid, **updates)
         return instance
 
     def _ask_scheduler_to_create_instance(self, context, base_options,
                                           instance_type, zone_blob,
                                           availability_zone, injected_files,
                                           admin_password, image,
-                                          instance_id=None, num_instances=1,
+                                          instance_uuid=None, num_instances=1,
                                           requested_networks=None):
         """Send the run_instance request to the schedulers for processing."""
         pid = context.project_id
         uid = context.user_id
-        if instance_id:
+        if instance_uuid:
             LOG.debug(_("Casting to scheduler for %(pid)s/%(uid)s's"
-                    " instance %(instance_id)s (single-shot)") % locals())
+                    " instance %(instance_uuid)s (single-shot)") % locals())
         else:
             LOG.debug(_("Casting to scheduler for %(pid)s/%(uid)s's"
                     " (all-at-once)") % locals())
@@ -471,7 +480,7 @@
                  FLAGS.scheduler_topic,
                  {"method": "run_instance",
                   "args": {"topic": FLAGS.compute_topic,
-                           "instance_id": instance_id,
+                           "instance_uuid": instance_uuid,
                            "request_spec": request_spec,
                            "availability_zone": availability_zone,
                            "admin_password": admin_password,
@@ -560,13 +569,13 @@
                                     base_options, security_group,
                                     block_device_mapping, num=num)
             instances.append(instance)
-            instance_id = instance['id']
+            instance_uuid = instance['uuid']
 
             self._ask_scheduler_to_create_instance(context, base_options,
                                         instance_type, zone_blob,
                                         availability_zone, injected_files,
                                         admin_password, image,
-                                        instance_id=instance_id,
+                                        instance_uuid=instance_uuid,
                                         requested_networks=requested_networks)
 
         return [dict(x.iteritems()) for x in instances]
@@ -670,7 +679,7 @@
                      {'method': 'refresh_provider_fw_rules', 'args': {}})
 
     def _is_security_group_associated_with_server(self, security_group,
-                                                instance_id):
+                                                instance_uuid):
         """Check if the security group is already associated
            with the instance. If Yes, return True.
         """
@@ -683,58 +692,59 @@
             return False
 
         inst_id = None
-        for inst_id in (instance['id'] for instance in instances \
-                        if instance_id == instance['id']):
+        for inst_uuid in (instance['id'] for instance in instances \
+                        if instance_uuid == instance['id']):
             return True
 
         return False
 
-    def add_security_group(self, context, instance_id, security_group_name):
+    def add_security_group(self, context, instance_uuid, security_group_name):
         """Add security group to the instance"""
         security_group = self.db.security_group_get_by_name(context,
                 context.project_id,
                 security_group_name)
         # check if the server exists
-        inst = self.db.instance_get(context, instance_id)
+        inst = self.db.instance_get(context, instance_uuid)
         #check if the security group is associated with the server
         if self._is_security_group_associated_with_server(security_group,
-                                                        instance_id):
+                                                        instance_uuid):
             raise exception.SecurityGroupExistsForInstance(
                                         security_group_id=security_group['id'],
-                                        instance_id=instance_id)
+                                        instance_uuid=instance_uuid)
 
         #check if the instance is in running state
         if inst['state'] != power_state.RUNNING:
-            raise exception.InstanceNotRunning(instance_id=instance_id)
+            raise exception.InstanceNotRunning(instance_uuid=instance_uuid)
 
         self.db.instance_add_security_group(context.elevated(),
-                                            instance_id,
+                                            instance_uuid,
                                             security_group['id'])
         rpc.cast(context,
              self.db.queue_get_for(context, FLAGS.compute_topic, inst['host']),
              {"method": "refresh_security_group_rules",
               "args": {"security_group_id": security_group['id']}})
 
-    def remove_security_group(self, context, instance_id, security_group_name):
+    def remove_security_group(self, context, instance_uuid,
+                              security_group_name):
         """Remove the security group associated with the instance"""
         security_group = self.db.security_group_get_by_name(context,
                 context.project_id,
                 security_group_name)
         # check if the server exists
-        inst = self.db.instance_get(context, instance_id)
+        inst = self.db.instance_get(context, instance_uuid)
         #check if the security group is associated with the server
         if not self._is_security_group_associated_with_server(security_group,
-                                                        instance_id):
+                                                        instance_uuid):
             raise exception.SecurityGroupNotExistsForInstance(
                                     security_group_id=security_group['id'],
-                                    instance_id=instance_id)
+                                    instance_uuid=instance_uuid)
 
         #check if the instance is in running state
         if inst['state'] != power_state.RUNNING:
-            raise exception.InstanceNotRunning(instance_id=instance_id)
+            raise exception.InstanceNotRunning(instance_uuid=instance_uuid)
 
         self.db.instance_remove_security_group(context.elevated(),
-                                               instance_id,
+                                               instance_uuid,
                                                security_group['id'])
         rpc.cast(context,
              self.db.queue_get_for(context, FLAGS.compute_topic, inst['host']),
@@ -742,36 +752,35 @@
               "args": {"security_group_id": security_group['id']}})
 
     @scheduler_api.reroute_compute("update")
-    def update(self, context, instance_id, **kwargs):
+    def update(self, context, instance_uuid, **kwargs):
         """Updates the instance in the datastore.
 
         :param context: The security context
-        :param instance_id: ID of the instance to update
+        :param instance_uuid: UUID of the instance to update
         :param kwargs: All additional keyword args are treated
                        as data fields of the instance to be
                        updated
 
         :returns: None
         """
-        rv = self.db.instance_update(context, instance_id, kwargs)
+        rv = self.db.instance_update(context, instance_uuid, kwargs)
         return dict(rv.iteritems())
 
-    def _get_instance(self, context, instance_id, action_str):
+    def _get_instance(self, context, instance_uuid, action_str):
         try:
-            return self.get(context, instance_id)
+            return self.get(context, instance_uuid)
         except exception.NotFound:
-            LOG.warning(_("Instance %(instance_id)s was not found during "
-                          "%(action_str)s") %
-                        {'instance_id': instance_id, 'action_str': action_str})
+            LOG.warning(_("Instance %(instance_uuid)s was not found during "
+                          "%(action_str)s") % locals())
             raise
 
     @scheduler_api.reroute_compute("soft_delete")
-    def soft_delete(self, context, instance_id):
+    def soft_delete(self, context, instance_uuid):
         """Terminate an instance."""
-        LOG.debug(_("Going to try to soft delete %s"), instance_id)
-        instance = self._get_instance(context, instance_id, 'soft delete')
+        LOG.debug(_("Going to try to soft delete %s"), instance_uuid)
+        instance = self._get_instance(context, instance_uuid, 'soft delete')
 
-        if not _is_able_to_shutdown(instance, instance_id):
+        if not _is_able_to_shutdown(instance, instance_uuid):
             return
 
         # NOTE(jerdfelt): The compute daemon handles reclaiming instances
@@ -780,50 +789,50 @@
         host = instance['host']
         if host:
             self.update(context,
-                        instance_id,
+                        instance_uuid,
                         vm_state=vm_states.SOFT_DELETE,
                         task_state=task_states.POWERING_OFF,
                         deleted_at=utils.utcnow())
 
             self._cast_compute_message('power_off_instance', context,
-                                       instance_id, host)
+                                       instance_uuid, host)
         else:
             LOG.warning(_("No host for instance %s, deleting immediately"),
-                        instance_id)
-            terminate_volumes(self.db, context, instance_id)
-            self.db.instance_destroy(context, instance_id)
+                        instance_uuid)
+            terminate_volumes(self.db, context, instance_uuid)
+            self.db.instance_destroy(context, instance_uuid)
 
     @scheduler_api.reroute_compute("delete")
-    def delete(self, context, instance_id):
+    def delete(self, context, instance_uuid):
         """Terminate an instance."""
-        LOG.debug(_("Going to try to terminate %s"), instance_id)
-        instance = self._get_instance(context, instance_id, 'delete')
+        LOG.debug(_("Going to try to terminate %s"), instance_uuid)
+        instance = self._get_instance(context, instance_uuid, 'delete')
 
-        if not _is_able_to_shutdown(instance, instance_id):
+        if not _is_able_to_shutdown(instance, instance_uuid):
             return
 
         host = instance['host']
         if host:
             self.update(context,
-                        instance_id,
+                        instance_uuid,
                         task_state=task_states.DELETING)
 
             self._cast_compute_message('terminate_instance', context,
-                                       instance_id, host)
+                                       instance_uuid, host)
         else:
-            terminate_volumes(self.db, context, instance_id)
-            self.db.instance_destroy(context, instance_id)
+            terminate_volumes(self.db, context, instance_uuid)
+            self.db.instance_destroy(context, instance_uuid)
 
     @scheduler_api.reroute_compute("restore")
-    def restore(self, context, instance_id):
+    def restore(self, context, instance_uuid):
         """Restore a previously deleted (but not reclaimed) instance."""
-        instance = self._get_instance(context, instance_id, 'restore')
+        instance = self._get_instance(context, instance_uuid, 'restore')
 
-        if not _is_queued_delete(instance, instance_id):
+        if not _is_queued_delete(instance, instance_uuid):
             return
 
         self.update(context,
-                    instance_id,
+                    instance_uuid,
                     vm_state=vm_states.ACTIVE,
                     task_state=None,
                     deleted_at=None)
@@ -831,43 +840,43 @@
         host = instance['host']
         if host:
             self.update(context,
-                        instance_id,
+                        instance_uuid,
                         task_state=task_states.POWERING_ON)
             self._cast_compute_message('power_on_instance', context,
-                    instance_id, host)
+                    instance_uuid, host)
 
     @scheduler_api.reroute_compute("force_delete")
-    def force_delete(self, context, instance_id):
+    def force_delete(self, context, instance_uuid):
         """Force delete a previously deleted (but not reclaimed) instance."""
-        instance = self._get_instance(context, instance_id, 'force delete')
+        instance = self._get_instance(context, instance_uuid, 'force delete')
 
-        if not _is_queued_delete(instance, instance_id):
+        if not _is_queued_delete(instance, instance_uuid):
             return
 
         self.update(context,
-                    instance_id,
+                    instance_uuid,
                     task_state=task_states.DELETING,
                     progress=0)
 
         host = instance['host']
         if host:
             self._cast_compute_message('terminate_instance', context,
-                    instance_id, host)
+                    instance_uuid, host)
         else:
-            terminate_volumes(self.db, context, instance_id)
-            self.db.instance_destroy(context, instance_id)
+            terminate_volumes(self.db, context, instance_uuid)
+            self.db.instance_destroy(context, instance_uuid)
 
     @scheduler_api.reroute_compute("stop")
-    def stop(self, context, instance_id):
+    def stop(self, context, instance_uuid):
         """Stop an instance."""
-        LOG.debug(_("Going to try to stop %s"), instance_id)
+        LOG.debug(_("Going to try to stop %s"), instance_uuid)
 
-        instance = self._get_instance(context, instance_id, 'stopping')
-        if not _is_able_to_shutdown(instance, instance_id):
+        instance = self._get_instance(context, instance_uuid, 'stopping')
+        if not _is_able_to_shutdown(instance, instance_uuid):
             return
 
         self.update(context,
-                    instance_id,
+                    instance_uuid,
                     vm_state=vm_states.ACTIVE,
                     task_state=task_states.STOPPING,
                     terminated_at=utils.utcnow(),
@@ -876,21 +885,21 @@
         host = instance['host']
         if host:
             self._cast_compute_message('stop_instance', context,
-                    instance_id, host)
+                    instance_uuid, host)
 
-    def start(self, context, instance_id):
+    def start(self, context, instance_uuid):
         """Start an instance."""
-        LOG.debug(_("Going to try to start %s"), instance_id)
-        instance = self._get_instance(context, instance_id, 'starting')
+        LOG.debug(_("Going to try to start %s"), instance_uuid)
+        instance = self._get_instance(context, instance_uuid, 'starting')
         vm_state = instance["vm_state"]
 
         if vm_state != vm_states.STOPPED:
-            LOG.warning(_("Instance %(instance_id)s is not "
+            LOG.warning(_("Instance %(instance_uuid)s is not "
                           "stopped. (%(vm_state)s)") % locals())
             return
 
         self.update(context,
-                    instance_id,
+                    instance_uuid,
                     vm_state=vm_states.STOPPED,
                     task_state=task_states.STARTING)
 
@@ -901,7 +910,7 @@
                  FLAGS.scheduler_topic,
                  {"method": "start_instance",
                   "args": {"topic": FLAGS.compute_topic,
-                           "instance_id": instance_id}})
+                           "instance_uuid": instance_uuid}})
 
     def get_active_by_window(self, context, begin, end=None, project_id=None):
         """Get instances that were continuously active over a window."""
@@ -912,27 +921,20 @@
         """Get an instance type by instance type id."""
         return self.db.instance_type_get(context, instance_type_id)
 
-    def get(self, context, instance_id):
-        """Get a single instance with the given instance_id."""
-        # NOTE(sirp): id used to be exclusively integer IDs; now we're
-        # accepting both UUIDs and integer IDs. The handling of this
-        # is done in db/sqlalchemy/api/instance_get
-        if utils.is_uuid_like(instance_id):
-            uuid = instance_id
-            instance = self.db.instance_get_by_uuid(context, uuid)
-        else:
-            instance = self.db.instance_get(context, instance_id)
+    def get(self, context, instance_uuid):
+        """Get a single instance with the given instance_uuid."""
+        instance = self.db.instance_get(context, instance_uuid)
         return dict(instance.iteritems())
 
     @scheduler_api.reroute_compute("get")
-    def routing_get(self, context, instance_id):
+    def routing_get(self, context, instance_uuid):
         """A version of get with special routing characteristics.
 
         Use this method instead of get() if this is the only operation you
         intend to to. It will route to novaclient.get if the instance is not
         found.
         """
-        return self.get(context, instance_id)
+        return self.get(context, instance_uuid)
 
     def get_all(self, context, search_opts=None):
         """Get all instances filtered by one of the given parameters.
@@ -1025,7 +1027,7 @@
 
         return self.db.instance_get_all_by_filters(context, filters)
 
-    def _cast_compute_message(self, method, context, instance_id, host=None,
+    def _cast_compute_message(self, method, context, instance_uuid, host=None,
                               params=None):
         """Generic handler for RPC casts to compute.
 
@@ -1037,14 +1039,14 @@
         if not params:
             params = {}
         if not host:
-            instance = self.get(context, instance_id)
+            instance = self.get(context, instance_uuid)
             host = instance['host']
         queue = self.db.queue_get_for(context, FLAGS.compute_topic, host)
-        params['instance_id'] = instance_id
+        params['instance_uuid'] = instance_uuid
         kwargs = {'method': method, 'args': params}
         rpc.cast(context, queue, kwargs)
 
-    def _call_compute_message(self, method, context, instance_id, host=None,
+    def _call_compute_message(self, method, context, instance_uuid, host=None,
                               params=None):
         """Generic handler for RPC calls to compute.
 
@@ -1056,10 +1058,10 @@
         if not params:
             params = {}
         if not host:
-            instance = self.get(context, instance_id)
+            instance = self.get(context, instance_uuid)
             host = instance['host']
         queue = self.db.queue_get_for(context, FLAGS.compute_topic, host)
-        params['instance_id'] = instance_id
+        params['instance_uuid'] = instance_uuid
         kwargs = {'method': method, 'args': params}
         return rpc.call(context, queue, kwargs)
 
@@ -1067,53 +1069,53 @@
         """Generic handler for RPC calls to the scheduler."""
         rpc.cast(context, FLAGS.scheduler_topic, args)
 
-    def _find_host(self, context, instance_id):
+    def _find_host(self, context, instance_uuid):
         """Find the host associated with an instance."""
         for attempts in xrange(FLAGS.find_host_timeout):
-            instance = self.get(context, instance_id)
+            instance = self.get(context, instance_uuid)
             host = instance["host"]
             if host:
                 return host
             time.sleep(1)
         raise exception.Error(_("Unable to find host for Instance %s")
-                                % instance_id)
+                                % instance_uuid)
 
     @scheduler_api.reroute_compute("backup")
-    def backup(self, context, instance_id, name, backup_type, rotation,
+    def backup(self, context, instance_uuid, name, backup_type, rotation,
                extra_properties=None):
         """Backup the given instance
 
-        :param instance_id: nova.db.sqlalchemy.models.Instance.Id
+        :param instance_uuid: nova.db.sqlalchemy.models.Instance.Id
         :param name: name of the backup or snapshot
             name = backup_type  # daily backups are called 'daily'
         :param rotation: int representing how many backups to keep around;
             None if rotation shouldn't be used (as in the case of snapshots)
         :param extra_properties: dict of extra image properties to include
         """
-        recv_meta = self._create_image(context, instance_id, name, 'backup',
+        recv_meta = self._create_image(context, instance_uuid, name, 'backup',
                             backup_type=backup_type, rotation=rotation,
                             extra_properties=extra_properties)
         return recv_meta
 
     @scheduler_api.reroute_compute("snapshot")
-    def snapshot(self, context, instance_id, name, extra_properties=None):
+    def snapshot(self, context, instance_uuid, name, extra_properties=None):
         """Snapshot the given instance.
 
-        :param instance_id: nova.db.sqlalchemy.models.Instance.Id
+        :param instance_uuid: nova.db.sqlalchemy.models.Instance.Id
         :param name: name of the backup or snapshot
         :param extra_properties: dict of extra image properties to include
 
         :returns: A dict containing image metadata
         """
-        return self._create_image(context, instance_id, name, 'snapshot',
+        return self._create_image(context, instance_uuid, name, 'snapshot',
                                   extra_properties=extra_properties)
 
-    def _create_image(self, context, instance_id, name, image_type,
+    def _create_image(self, context, instance_uuid, name, image_type,
                       backup_type=None, rotation=None, extra_properties=None):
         """Create snapshot or backup for an instance on this host.
 
         :param context: security context
-        :param instance_id: nova.db.sqlalchemy.models.Instance.Id
+        :param instance_uuid: nova.db.sqlalchemy.models.Instance.Id
         :param name: string for name of the snapshot
         :param image_type: snapshot | backup
         :param backup_type: daily | weekly
@@ -1122,7 +1124,7 @@
         :param extra_properties: dict of extra image properties to include
 
         """
-        instance = self.db.instance_get(context, instance_id)
+        instance = self.db.instance_get(context, instance_uuid)
         properties = {'instance_uuid': instance['uuid'],
                       'user_id': str(context.user_id),
                       'image_state': 'creating',
@@ -1134,25 +1136,25 @@
         recv_meta = self.image_service.create(context, sent_meta)
         params = {'image_id': recv_meta['id'], 'image_type': image_type,
                   'backup_type': backup_type, 'rotation': rotation}
-        self._cast_compute_message('snapshot_instance', context, instance_id,
+        self._cast_compute_message('snapshot_instance', context, instance_uuid,
                                    params=params)
         return recv_meta
 
     @scheduler_api.reroute_compute("reboot")
-    def reboot(self, context, instance_id, reboot_type):
+    def reboot(self, context, instance_uuid, reboot_type):
         """Reboot the given instance."""
         self.update(context,
-                    instance_id,
+                    instance_uuid,
                     vm_state=vm_states.ACTIVE,
                     task_state=task_states.REBOOTING)
-        self._cast_compute_message('reboot_instance', context, instance_id,
+        self._cast_compute_message('reboot_instance', context, instance_uuid,
                 params={'reboot_type': reboot_type})
 
     @scheduler_api.reroute_compute("rebuild")
-    def rebuild(self, context, instance_id, image_href, admin_password,
+    def rebuild(self, context, instance_uuid, image_href, admin_password,
                 name=None, metadata=None, files_to_inject=None):
         """Rebuild the given instance with the provided metadata."""
-        instance = self.db.instance_get(context, instance_id)
+        instance = self.db.instance_get(context, instance_uuid)
         name = name or instance["display_name"]
 
         if instance["vm_state"] != vm_states.ACTIVE:
@@ -1166,7 +1168,7 @@
         self._check_metadata_properties_quota(context, metadata)
 
         self.update(context,
-                    instance_id,
+                    instance_uuid,
                     metadata=metadata,
                     display_name=name,
                     image_ref=image_href,
@@ -1181,23 +1183,24 @@
 
         self._cast_compute_message('rebuild_instance',
                                    context,
-                                   instance_id,
+                                   instance_uuid,
                                    params=rebuild_params)
 
     @scheduler_api.reroute_compute("revert_resize")
-    def revert_resize(self, context, instance_id):
+    def revert_resize(self, context, instance_uuid):
         """Reverts a resize, deleting the 'new' instance in the process."""
         context = context.elevated()
-        instance_ref = self._get_instance(context, instance_id,
+        instance_ref = self._get_instance(context, instance_uuid,
                 'revert_resize')
         migration_ref = self.db.migration_get_by_instance_and_status(context,
                 instance_ref['uuid'], 'finished')
         if not migration_ref:
-            raise exception.MigrationNotFoundByStatus(instance_id=instance_id,
-                                                      status='finished')
+            raise exception.MigrationNotFoundByStatus(
+                    instance_uuid=instance_uuid,
+                    status='finished')
 
         self.update(context,
-                    instance_id,
+                    instance_uuid,
                     vm_state=vm_states.ACTIVE,
                     task_state=None)
 
@@ -1211,19 +1214,20 @@
                 {'status': 'reverted'})
 
     @scheduler_api.reroute_compute("confirm_resize")
-    def confirm_resize(self, context, instance_id):
+    def confirm_resize(self, context, instance_uuid):
         """Confirms a migration/resize and deletes the 'old' instance."""
         context = context.elevated()
-        instance_ref = self._get_instance(context, instance_id,
+        instance_ref = self._get_instance(context, instance_uuid,
                 'confirm_resize')
         migration_ref = self.db.migration_get_by_instance_and_status(context,
                 instance_ref['uuid'], 'finished')
         if not migration_ref:
-            raise exception.MigrationNotFoundByStatus(instance_id=instance_id,
-                                                      status='finished')
+            raise exception.MigrationNotFoundByStatus(
+                    instance_uuid=instance_uuid,
+                    status='finished')
 
         self.update(context,
-                    instance_id,
+                    instance_uuid,
                     vm_state=vm_states.ACTIVE,
                     task_state=None)
 
@@ -1235,18 +1239,18 @@
 
         self.db.migration_update(context, migration_ref['id'],
                 {'status': 'confirmed'})
-        self.db.instance_update(context, instance_id,
+        self.db.instance_update(context, instance_uuid,
                 {'host': migration_ref['dest_compute'], })
 
     @scheduler_api.reroute_compute("resize")
-    def resize(self, context, instance_id, flavor_id=None):
+    def resize(self, context, instance_uuid, flavor_id=None):
         """Resize (ie, migrate) a running instance.
 
         If flavor_id is None, the process is considered a migration, keeping
         the original flavor_id. If flavor_id is not None, the instance should
         be migrated to a new host and resized to the new flavor_id.
         """
-        instance_ref = self._get_instance(context, instance_id, 'resize')
+        instance_ref = self._get_instance(context, instance_uuid, 'resize')
         current_instance_type = instance_ref['instance_type']
 
         # If flavor_id is not provided, only migrate the instance.
@@ -1273,29 +1277,29 @@
             raise exception.CannotResizeToSameSize()
 
         self.update(context,
-                    instance_id,
+                    instance_uuid,
                     vm_state=vm_states.RESIZING,
                     task_state=task_states.RESIZE_PREP)
 
-        instance_ref = self._get_instance(context, instance_id, 'resize')
+        instance_ref = self._get_instance(context, instance_uuid, 'resize')
         self._cast_scheduler_message(context,
                     {"method": "prep_resize",
                      "args": {"topic": FLAGS.compute_topic,
-                              "instance_id": instance_ref['uuid'],
+                              "instance_uuid": instance_ref['uuid'],
                               "instance_type_id": new_instance_type['id']}})
 
     @scheduler_api.reroute_compute("add_fixed_ip")
-    def add_fixed_ip(self, context, instance_id, network_id):
+    def add_fixed_ip(self, context, instance_uuid, network_id):
         """Add fixed_ip from specified network to given instance."""
         self._cast_compute_message('add_fixed_ip_to_instance', context,
-                                   instance_id,
+                                   instance_uuid,
                                    params=dict(network_id=network_id))
 
     @scheduler_api.reroute_compute("remove_fixed_ip")
-    def remove_fixed_ip(self, context, instance_id, address):
+    def remove_fixed_ip(self, context, instance_uuid, address):
         """Remove fixed_ip from specified network to given instance."""
         self._cast_compute_message('remove_fixed_ip_from_instance', context,
-                                   instance_id, params=dict(address=address))
+                                   instance_uuid, params=dict(address=address))
 
     #TODO(tr3buchet): how to run this in the correct zone?
     def add_network_to_project(self, context, project_id):
@@ -1308,22 +1312,22 @@
         self.network_api.add_network_to_project(context, project_id)
 
     @scheduler_api.reroute_compute("pause")
-    def pause(self, context, instance_id):
+    def pause(self, context, instance_uuid):
         """Pause the given instance."""
         self.update(context,
-                    instance_id,
+                    instance_uuid,
                     vm_state=vm_states.ACTIVE,
                     task_state=task_states.PAUSING)
-        self._cast_compute_message('pause_instance', context, instance_id)
+        self._cast_compute_message('pause_instance', context, instance_uuid)
 
     @scheduler_api.reroute_compute("unpause")
-    def unpause(self, context, instance_id):
+    def unpause(self, context, instance_uuid):
         """Unpause the given instance."""
         self.update(context,
-                    instance_id,
+                    instance_uuid,
                     vm_state=vm_states.PAUSED,
                     task_state=task_states.UNPAUSING)
-        self._cast_compute_message('unpause_instance', context, instance_id)
+        self._cast_compute_message('unpause_instance', context, instance_uuid)
 
     def _call_compute_message_for_host(self, action, context, host, params):
         """Call method deliberately designed to make host/service only calls"""
@@ -1342,76 +1346,79 @@
                 context, host=host, params={"action": action})
 
     @scheduler_api.reroute_compute("diagnostics")
-    def get_diagnostics(self, context, instance_id):
+    def get_diagnostics(self, context, instance_uuid):
         """Retrieve diagnostics for the given instance."""
         return self._call_compute_message("get_diagnostics",
                                           context,
-                                          instance_id)
+                                          instance_uuid)
 
-    def get_actions(self, context, instance_id):
+    def get_actions(self, context, instance_uuid):
         """Retrieve actions for the given instance."""
-        return self.db.instance_get_actions(context, instance_id)
+        return self.db.instance_get_actions(context, instance_uuid)
 
     @scheduler_api.reroute_compute("suspend")
-    def suspend(self, context, instance_id):
+    def suspend(self, context, instance_uuid):
         """Suspend the given instance."""
         self.update(context,
-                    instance_id,
+                    instance_uuid,
                     vm_state=vm_states.ACTIVE,
                     task_state=task_states.SUSPENDING)
-        self._cast_compute_message('suspend_instance', context, instance_id)
+        self._cast_compute_message('suspend_instance', context, instance_uuid)
 
     @scheduler_api.reroute_compute("resume")
-    def resume(self, context, instance_id):
+    def resume(self, context, instance_uuid):
         """Resume the given instance."""
         self.update(context,
-                    instance_id,
+                    instance_uuid,
                     vm_state=vm_states.SUSPENDED,
                     task_state=task_states.RESUMING)
-        self._cast_compute_message('resume_instance', context, instance_id)
+        self._cast_compute_message('resume_instance', context, instance_uuid)
 
     @scheduler_api.reroute_compute("rescue")
-    def rescue(self, context, instance_id, rescue_password=None):
+    def rescue(self, context, instance_uuid, rescue_password=None):
         """Rescue the given instance."""
         self.update(context,
-                    instance_id,
+                    instance_uuid,
                     vm_state=vm_states.ACTIVE,
                     task_state=task_states.RESCUING)
-
         rescue_params = {
             "rescue_password": rescue_password
         }
-        self._cast_compute_message('rescue_instance', context, instance_id,
+        self._cast_compute_message('rescue_instance', context, instance_uuid,
                                     params=rescue_params)
 
     @scheduler_api.reroute_compute("unrescue")
-    def unrescue(self, context, instance_id):
+    def unrescue(self, context, instance_uuid):
         """Unrescue the given instance."""
         self.update(context,
-                    instance_id,
+                    instance_uuid,
                     vm_state=vm_states.RESCUED,
                     task_state=task_states.UNRESCUING)
-        self._cast_compute_message('unrescue_instance', context, instance_id)
+        self._cast_compute_message('unrescue_instance', context, instance_uuid)
 
     @scheduler_api.reroute_compute("set_admin_password")
-    def set_admin_password(self, context, instance_id, password=None):
+    def set_admin_password(self, context, instance_uuid, password=None):
         """Set the root/admin password for the given instance."""
-        host = self._find_host(context, instance_id)
-
-        rpc.cast(context,
-                 self.db.queue_get_for(context, FLAGS.compute_topic, host),
-                 {"method": "set_admin_password",
-                  "args": {"instance_id": instance_id, "new_pass": password}})
-
-    def inject_file(self, context, instance_id):
+        host = self._find_host(context, instance_uuid)
+        queue = self.db.queue_get_for(context, FLAGS.compute_topic, host)
+        message = {
+            "method": "set_admin_password",
+            "args": {
+                "instance_uuid": instance_uuid,
+                "new_pass": password,
+            },
+        }
+        rpc.cast(context, queue, message)
+
+    def inject_file(self, context, instance_uuid):
         """Write a file to the given instance."""
-        self._cast_compute_message('inject_file', context, instance_id)
+        self._cast_compute_message('inject_file', context, instance_uuid)
 
-    def get_ajax_console(self, context, instance_id):
+    def get_ajax_console(self, context, instance_uuid):
         """Get a url to an AJAX Console."""
         output = self._call_compute_message('get_ajax_console',
                                             context,
-                                            instance_id)
+                                            instance_uuid)
         rpc.cast(context, '%s' % FLAGS.ajax_console_proxy_topic,
                  {'method': 'authorize_ajax_console',
                   'args': {'token': output['token'], 'host': output['host'],
@@ -1419,12 +1426,12 @@
         return {'url': '%s/?token=%s' % (FLAGS.ajax_console_proxy_url,
                                          output['token'])}
 
-    def get_vnc_console(self, context, instance_id):
+    def get_vnc_console(self, context, instance_uuid):
         """Get a url to a VNC Console."""
-        instance = self.get(context, instance_id)
+        instance = self.get(context, instance_uuid)
         output = self._call_compute_message('get_vnc_console',
                                             context,
-                                            instance_id)
+                                            instance_uuid)
         rpc.call(context, '%s' % FLAGS.vncproxy_topic,
                  {'method': 'authorize_vnc_console',
                   'args': {'token': output['token'],
@@ -1438,46 +1445,48 @@
                        'hostignore',
                        'portignore')}
 
-    def get_console_output(self, context, instance_id):
+    def get_console_output(self, context, instance_uuid):
         """Get console output for an an instance."""
         return self._call_compute_message('get_console_output',
                                           context,
-                                          instance_id)
+                                          instance_uuid)
 
-    def lock(self, context, instance_id):
+    def lock(self, context, instance_uuid):
         """Lock the given instance."""
-        self._cast_compute_message('lock_instance', context, instance_id)
+        self._cast_compute_message('lock_instance', context, instance_uuid)
 
-    def unlock(self, context, instance_id):
+    def unlock(self, context, instance_uuid):
         """Unlock the given instance."""
-        self._cast_compute_message('unlock_instance', context, instance_id)
+        self._cast_compute_message('unlock_instance', context, instance_uuid)
 
-    def get_lock(self, context, instance_id):
+    def get_lock(self, context, instance_uuid):
         """Return the boolean state of given instance's lock."""
-        instance = self.get(context, instance_id)
+        instance = self.get(context, instance_uuid)
         return instance['locked']
 
-    def reset_network(self, context, instance_id):
+    def reset_network(self, context, instance_uuid):
         """Reset networking on the instance."""
-        self._cast_compute_message('reset_network', context, instance_id)
+        self._cast_compute_message('reset_network', context, instance_uuid)
 
-    def inject_network_info(self, context, instance_id):
+    def inject_network_info(self, context, instance_uuid):
         """Inject network info for the instance."""
-        self._cast_compute_message('inject_network_info', context, instance_id)
+        self._cast_compute_message('inject_network_info',
+                                   context,
+                                   instance_uuid)
 
-    def attach_volume(self, context, instance_id, volume_id, device):
+    def attach_volume(self, context, instance_uuid, volume_id, device):
         """Attach an existing volume to an existing instance."""
         if not re.match("^/dev/[a-z]d[a-z]+$", device):
             raise exception.ApiError(_("Invalid device specified: %s. "
                                      "Example device: /dev/vdb") % device)
         self.volume_api.check_attach(context, volume_id=volume_id)
-        instance = self.get(context, instance_id)
+        instance = self.get(context, instance_uuid)
         host = instance['host']
         rpc.cast(context,
                  self.db.queue_get_for(context, FLAGS.compute_topic, host),
                  {"method": "attach_volume",
                   "args": {"volume_id": volume_id,
-                           "instance_id": instance_id,
+                           "instance_uuid": instance_uuid,
                            "mountpoint": device}})
 
     def detach_volume(self, context, volume_id):
@@ -1490,23 +1499,22 @@
         rpc.cast(context,
                  self.db.queue_get_for(context, FLAGS.compute_topic, host),
                  {"method": "detach_volume",
-                  "args": {"instance_id": instance['id'],
+                  "args": {"instance_uuid": instance['uuid'],
                            "volume_id": volume_id}})
         return instance
 
-    def associate_floating_ip(self, context, instance_id, address):
+    def associate_floating_ip(self, context, instance_uuid, address):
         """Makes calls to network_api to associate_floating_ip.
 
         :param address: is a string floating ip address
         """
-        instance = self.get(context, instance_id)
+        instance = self.get(context, instance_uuid)
 
         # TODO(tr3buchet): currently network_info doesn't contain floating IPs
         # in its info, if this changes, the next few lines will need to
         # accomodate the info containing floating as well as fixed ip addresses
         fixed_ip_addrs = []
-        for info in self.network_api.get_instance_nw_info(context,
-                                                          instance):
+        for info in self.network_api.get_instance_nw_info(context, instance):
             ips = info[1]['ips']
             fixed_ip_addrs.extend([ip_dict['ip'] for ip_dict in ips])
 
@@ -1515,7 +1523,7 @@
         # support specifying a particular fixed_ip if multiple exist.
         if not fixed_ip_addrs:
             msg = _("instance |%s| has no fixed_ips. "
-                    "unable to associate floating ip") % instance_id
+                    "unable to associate floating ip") % instance_uuid
             raise exception.ApiError(msg)
         if len(fixed_ip_addrs) > 1:
             LOG.warning(_("multiple fixed_ips exist, using the first: %s"),
@@ -1524,16 +1532,16 @@
                                                floating_ip=address,
                                                fixed_ip=fixed_ip_addrs[0])
 
-    def get_instance_metadata(self, context, instance_id):
+    def get_instance_metadata(self, context, instance_uuid):
         """Get all metadata associated with an instance."""
-        rv = self.db.instance_metadata_get(context, instance_id)
+        rv = self.db.instance_metadata_get(context, instance_uuid)
         return dict(rv.iteritems())
 
-    def delete_instance_metadata(self, context, instance_id, key):
+    def delete_instance_metadata(self, context, instance_uuid, key):
         """Delete the given metadata item from an instance."""
-        self.db.instance_metadata_delete(context, instance_id, key)
+        self.db.instance_metadata_delete(context, instance_uuid, key)
 
-    def update_instance_metadata(self, context, instance_id,
+    def update_instance_metadata(self, context, instance_uuid,
                                  metadata, delete=False):
         """Updates or creates instance metadata.
 
@@ -1544,9 +1552,20 @@
         if delete:
             _metadata = metadata
         else:
-            _metadata = self.get_instance_metadata(context, instance_id)
+            _metadata = self.get_instance_metadata(context, instance_uuid)
             _metadata.update(metadata)
 
         self._check_metadata_properties_quota(context, _metadata)
-        self.db.instance_metadata_update(context, instance_id, _metadata, True)
+        self.db.instance_metadata_update(context,
+                                         instance_uuid,
+                                         _metadata,
+                                         True)
         return _metadata
+
+    def get_instance_uuid(self, context, instance_id):
+        """Return instance uuid corresponding to the provided id"""
+        uuids = self.db.instance_get_id_to_uuid_mapping(context, [instance_id])
+        try:
+            return uuids[instance_id]
+        except KeyError:
+            raise exception.InstanceNotFound(instance_uuid=instance_id)

=== modified file 'nova/compute/manager.py'
--- nova/compute/manager.py	2011-09-21 20:59:40 +0000
+++ nova/compute/manager.py	2011-09-22 19:29:25 +0000
@@ -98,16 +98,12 @@
 def checks_instance_lock(function):
     """Decorator to prevent action against locked instances for non-admins."""
     @functools.wraps(function)
-    def decorated_function(self, context, instance_id, *args, **kwargs):
-        #TODO(anyone): this being called instance_id is forcing a slightly
-        # confusing convention of pushing instance_uuids
-        # through an "instance_id" key in the queue args dict when
-        # casting through the compute API
+    def decorated_function(self, context, instance_uuid, *args, **kwargs):
         LOG.info(_("check_instance_lock: decorating: |%s|"), function,
                  context=context)
         LOG.info(_("check_instance_lock: arguments: |%(self)s| |%(context)s|"
-                " |%(instance_id)s|") % locals(), context=context)
-        locked = self.get_lock(context, instance_id)
+                " |%(instance_uuid)s|") % locals(), context=context)
+        locked = self.get_lock(context, instance_uuid)
         admin = context.is_admin
         LOG.info(_("check_instance_lock: locked: |%s|"), locked,
                  context=context)
@@ -118,7 +114,7 @@
         if admin or not locked:
             LOG.info(_("check_instance_lock: executing: |%s|"), function,
                      context=context)
-            function(self, context, instance_id, *args, **kwargs)
+            function(self, context, instance_uuid, *args, **kwargs)
         else:
             LOG.error(_("check_instance_lock: not executing |%s|"),
                       function, context=context)
@@ -152,9 +148,9 @@
         super(ComputeManager, self).__init__(service_name="compute",
                                              *args, **kwargs)
 
-    def _instance_update(self, context, instance_id, **kwargs):
+    def _instance_update(self, context, instance_uuid, **kwargs):
         """Update an instance in the database using kwargs as value."""
-        return self.db.instance_update(context, instance_id, kwargs)
+        return self.db.instance_update(context, instance_uuid, kwargs)
 
     def init_host(self):
         """Initialization for a standalone compute service."""
@@ -176,7 +172,7 @@
                or FLAGS.start_guests_on_host_boot:
                 LOG.info(_('Rebooting instance %(inst_name)s after '
                             'nova-compute restart.'), locals())
-                self.reboot_instance(context, instance['id'])
+                self.reboot_instance(context, instance['uuid'])
             elif drv_state == power_state.RUNNING:
                 # Hyper-V and VMWareAPI drivers will raise an exception
                 try:
@@ -243,14 +239,14 @@
                                                                  instance)
         return network_info
 
-    def _setup_block_device_mapping(self, context, instance_id):
+    def _setup_block_device_mapping(self, context, instance_uuid):
         """setup volumes for block device mapping"""
         volume_api = volume.API()
         block_device_mapping = []
         swap = None
         ephemerals = []
         for bdm in self.db.block_device_mapping_get_all_by_instance(
-            context, instance_id):
+            context, instance_uuid):
             LOG.debug(_("setting up bdm %s"), bdm)
 
             if bdm['no_device']:
@@ -296,7 +292,7 @@
             if bdm['volume_id'] is not None:
                 volume_api.check_attach(context,
                                         volume_id=bdm['volume_id'])
-                dev_path = self._attach_volume_boot(context, instance_id,
+                dev_path = self._attach_volume_boot(context, instance_uuid,
                                                     bdm['volume_id'],
                                                     bdm['device_name'])
                 block_device_mapping.append({'device_path': dev_path,
@@ -305,7 +301,7 @@
 
         return (swap, ephemerals, block_device_mapping)
 
-    def _run_instance(self, context, instance_id, **kwargs):
+    def _run_instance(self, context, instance_uuid, **kwargs):
         """Launch a new instance with specified options."""
         def _check_image_size():
             """Ensure image is smaller than the maximum size allowed by the
@@ -365,7 +361,7 @@
                 raise exception.ImageTooLarge()
 
         context = context.elevated()
-        instance = self.db.instance_get(context, instance_id)
+        instance = self.db.instance_get(context, instance_uuid)
 
         requested_networks = kwargs.get('requested_networks', None)
 
@@ -374,14 +370,14 @@
 
         _check_image_size()
 
-        LOG.audit(_("instance %s: starting..."), instance_id,
+        LOG.audit(_("instance %s: starting..."), instance_uuid,
                   context=context)
         updates = {}
         updates['host'] = self.host
         updates['launched_on'] = self.host
         updates['vm_state'] = vm_states.BUILDING
         updates['task_state'] = task_states.NETWORKING
-        instance = self.db.instance_update(context, instance_id, updates)
+        instance = self.db.instance_update(context, instance_uuid, updates)
         instance['injected_files'] = kwargs.get('injected_files', [])
         instance['admin_pass'] = kwargs.get('admin_password', None)
 
@@ -404,13 +400,13 @@
                 network_info = []
 
             self._instance_update(context,
-                                  instance_id,
+                                  instance_uuid,
                                   vm_state=vm_states.BUILDING,
                                   task_state=task_states.BLOCK_DEVICE_MAPPING)
 
             (swap, ephemerals,
              block_device_mapping) = self._setup_block_device_mapping(
-                context, instance_id)
+                context, instance_uuid)
             block_device_info = {
                 'root_device_name': instance['root_device_name'],
                 'swap': swap,
@@ -418,7 +414,7 @@
                 'block_device_mapping': block_device_mapping}
 
             self._instance_update(context,
-                                  instance_id,
+                                  instance_uuid,
                                   vm_state=vm_states.BUILDING,
                                   task_state=task_states.SPAWNING)
 
@@ -427,7 +423,7 @@
                 self.driver.spawn(context, instance,
                                   network_info, block_device_info)
             except Exception as ex:  # pylint: disable=W0702
-                msg = _("Instance '%(instance_id)s' failed to spawn. Is "
+                msg = _("Instance '%(instance_uuid)s' failed to spawn. Is "
                         "virtualization enabled in the BIOS? Details: "
                         "%(ex)s") % locals()
                 LOG.exception(msg)
@@ -435,7 +431,7 @@
 
             current_power_state = self._get_power_state(context, instance)
             self._instance_update(context,
-                                  instance_id,
+                                  instance_uuid,
                                   power_state=current_power_state,
                                   vm_state=vm_states.ACTIVE,
                                   task_state=None,
@@ -454,23 +450,23 @@
             pass
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
-    def run_instance(self, context, instance_id, **kwargs):
-        self._run_instance(context, instance_id, **kwargs)
+    def run_instance(self, context, instance_uuid, **kwargs):
+        self._run_instance(context, instance_uuid, **kwargs)
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
     @checks_instance_lock
-    def start_instance(self, context, instance_id):
+    def start_instance(self, context, instance_uuid):
         """Starting an instance on this host."""
         # TODO(yamahata): injected_files isn't supported.
         #                 Anyway OSAPI doesn't support stop/start yet
-        self._run_instance(context, instance_id)
+        self._run_instance(context, instance_uuid)
 
-    def _shutdown_instance(self, context, instance_id, action_str):
+    def _shutdown_instance(self, context, instance_uuid, action_str):
         """Shutdown an instance on this host."""
         context = context.elevated()
-        instance = self.db.instance_get(context, instance_id)
-        LOG.audit(_("%(action_str)s instance %(instance_id)s") %
-                  {'action_str': action_str, 'instance_id': instance_id},
+        instance = self.db.instance_get(context, instance_uuid)
+        LOG.audit(_("%(action_str)s instance %(instance_uuid)s") %
+                  {'action_str': action_str, 'instance_uuid': instance_uuid},
                   context=context)
 
         network_info = self._get_instance_nw_info(context, instance)
@@ -479,28 +475,28 @@
 
         volumes = instance.get('volumes') or []
         for volume in volumes:
-            self._detach_volume(context, instance_id, volume['id'], False)
+            self._detach_volume(context, instance_uuid, volume['id'], False)
 
         if instance['power_state'] == power_state.SHUTOFF:
-            self.db.instance_destroy(context, instance_id)
+            self.db.instance_destroy(context, instance_uuid)
             raise exception.Error(_('trying to destroy already destroyed'
-                                    ' instance: %s') % instance_id)
+                                    ' instance: %s') % instance_uuid)
         self.driver.destroy(instance, network_info)
 
         if action_str == 'Terminating':
-            terminate_volumes(self.db, context, instance_id)
+            terminate_volumes(self.db, context, instance_uuid)
 
-    def _delete_instance(self, context, instance_id):
+    def _delete_instance(self, context, instance_uuid):
         """Delete an instance on this host."""
-        self._shutdown_instance(context, instance_id, 'Terminating')
-        instance = self.db.instance_get(context.elevated(), instance_id)
+        self._shutdown_instance(context, instance_uuid, 'Terminating')
+        instance = self.db.instance_get(context.elevated(), instance_uuid)
         self._instance_update(context,
-                              instance_id,
+                              instance_uuid,
                               vm_state=vm_states.DELETED,
                               task_state=None,
                               terminated_at=utils.utcnow())
 
-        self.db.instance_destroy(context, instance_id)
+        self.db.instance_destroy(context, instance_uuid)
 
         usage_info = utils.usage_from_instance(instance)
         notifier.notify('compute.%s' % self.host,
@@ -509,65 +505,65 @@
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
     @checks_instance_lock
-    def terminate_instance(self, context, instance_id):
+    def terminate_instance(self, context, instance_uuid):
         """Terminate an instance on this host."""
-        self._delete_instance(context, instance_id)
+        self._delete_instance(context, instance_uuid)
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
     @checks_instance_lock
-    def stop_instance(self, context, instance_id):
+    def stop_instance(self, context, instance_uuid):
         """Stopping an instance on this host."""
-        self._shutdown_instance(context, instance_id, 'Stopping')
+        self._shutdown_instance(context, instance_uuid, 'Stopping')
         self._instance_update(context,
-                              instance_id,
+                              instance_uuid,
                               vm_state=vm_states.STOPPED,
                               task_state=None)
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
     @checks_instance_lock
-    def power_off_instance(self, context, instance_id):
+    def power_off_instance(self, context, instance_uuid):
         """Power off an instance on this host."""
-        instance = self.db.instance_get(context, instance_id)
+        instance = self.db.instance_get(context, instance_uuid)
         self.driver.power_off(instance)
         current_power_state = self._get_power_state(context, instance)
         self._instance_update(context,
-                              instance_id,
+                              instance_uuid,
                               power_state=current_power_state,
                               task_state=None)
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
     @checks_instance_lock
-    def power_on_instance(self, context, instance_id):
+    def power_on_instance(self, context, instance_uuid):
         """Power on an instance on this host."""
-        instance = self.db.instance_get(context, instance_id)
+        instance = self.db.instance_get(context, instance_uuid)
         self.driver.power_on(instance)
         current_power_state = self._get_power_state(context, instance)
         self._instance_update(context,
-                              instance_id,
+                              instance_uuid,
                               power_state=current_power_state,
                               task_state=None)
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
     @checks_instance_lock
-    def rebuild_instance(self, context, instance_id, **kwargs):
+    def rebuild_instance(self, context, instance_uuid, **kwargs):
         """Destroy and re-make this instance.
 
         A 'rebuild' effectively purges all existing data from the system and
         remakes the VM with given 'metadata' and 'personalities'.
 
         :param context: `nova.RequestContext` object
-        :param instance_id: Instance identifier (integer)
+        :param instance_uuid: Instance identifier (integer)
         :param injected_files: Files to inject
         :param new_pass: password to set on rebuilt instance
         """
         context = context.elevated()
 
-        instance_ref = self.db.instance_get(context, instance_id)
-        LOG.audit(_("Rebuilding instance %s"), instance_id, context=context)
+        instance_ref = self.db.instance_get(context, instance_uuid)
+        LOG.audit(_("Rebuilding instance %s"), instance_uuid, context=context)
 
         current_power_state = self._get_power_state(context, instance_ref)
         self._instance_update(context,
-                              instance_id,
+                              instance_uuid,
                               power_state=current_power_state,
                               vm_state=vm_states.REBUILDING,
                               task_state=None)
@@ -576,17 +572,17 @@
         self.driver.destroy(instance_ref, network_info)
 
         self._instance_update(context,
-                              instance_id,
+                              instance_uuid,
                               vm_state=vm_states.REBUILDING,
                               task_state=task_states.BLOCK_DEVICE_MAPPING)
 
         instance_ref.injected_files = kwargs.get('injected_files', [])
         network_info = self.network_api.get_instance_nw_info(context,
                                                               instance_ref)
-        bd_mapping = self._setup_block_device_mapping(context, instance_id)
+        bd_mapping = self._setup_block_device_mapping(context, instance_uuid)
 
         self._instance_update(context,
-                              instance_id,
+                              instance_uuid,
                               vm_state=vm_states.REBUILDING,
                               task_state=task_states.SPAWNING)
 
@@ -598,7 +594,7 @@
 
         current_power_state = self._get_power_state(context, instance_ref)
         self._instance_update(context,
-                              instance_id,
+                              instance_uuid,
                               power_state=current_power_state,
                               vm_state=vm_states.ACTIVE,
                               task_state=None,
@@ -612,15 +608,15 @@
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
     @checks_instance_lock
-    def reboot_instance(self, context, instance_id, reboot_type="SOFT"):
+    def reboot_instance(self, context, instance_uuid, reboot_type="SOFT"):
         """Reboot an instance on this host."""
-        LOG.audit(_("Rebooting instance %s"), instance_id, context=context)
+        LOG.audit(_("Rebooting instance %s"), instance_uuid, context=context)
         context = context.elevated()
-        instance_ref = self.db.instance_get(context, instance_id)
+        instance_ref = self.db.instance_get(context, instance_uuid)
 
         current_power_state = self._get_power_state(context, instance_ref)
         self._instance_update(context,
-                              instance_id,
+                              instance_uuid,
                               power_state=current_power_state,
                               vm_state=vm_states.ACTIVE,
                               task_state=task_states.REBOOTING)
@@ -629,7 +625,7 @@
             state = instance_ref['power_state']
             running = power_state.RUNNING
             LOG.warn(_('trying to reboot a non-running '
-                     'instance: %(instance_id)s (state: %(state)s '
+                     'instance: %(instance_uuid)s (state: %(state)s '
                      'expected: %(running)s)') % locals(),
                      context=context)
 
@@ -638,19 +634,19 @@
 
         current_power_state = self._get_power_state(context, instance_ref)
         self._instance_update(context,
-                              instance_id,
+                              instance_uuid,
                               power_state=current_power_state,
                               vm_state=vm_states.ACTIVE,
                               task_state=None)
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
-    def snapshot_instance(self, context, instance_id, image_id,
+    def snapshot_instance(self, context, instance_uuid, image_id,
                           image_type='snapshot', backup_type=None,
                           rotation=None):
         """Snapshot an instance on this host.
 
         :param context: security context
-        :param instance_id: nova.db.sqlalchemy.models.Instance.Id
+        :param instance_uuid: nova.db.sqlalchemy.models.Instance.Id
         :param image_id: glance.db.sqlalchemy.models.Image.Id
         :param image_type: snapshot | backup
         :param backup_type: daily | weekly
@@ -665,27 +661,27 @@
             raise Exception(_('Image type not recognized %s') % image_type)
 
         context = context.elevated()
-        instance_ref = self.db.instance_get(context, instance_id)
+        instance_ref = self.db.instance_get(context, instance_uuid)
 
         current_power_state = self._get_power_state(context, instance_ref)
         self._instance_update(context,
-                              instance_id,
+                              instance_uuid,
                               power_state=current_power_state,
                               vm_state=vm_states.ACTIVE,
                               task_state=task_state)
 
-        LOG.audit(_('instance %s: snapshotting'), instance_id,
+        LOG.audit(_('instance %s: snapshotting'), instance_uuid,
                   context=context)
 
         if instance_ref['power_state'] != power_state.RUNNING:
             state = instance_ref['power_state']
             running = power_state.RUNNING
             LOG.warn(_('trying to snapshot a non-running '
-                       'instance: %(instance_id)s (state: %(state)s '
+                       'instance: %(instance_uuid)s (state: %(state)s '
                        'expected: %(running)s)') % locals())
 
         self.driver.snapshot(context, instance_ref, image_id)
-        self._instance_update(context, instance_id, task_state=None)
+        self._instance_update(context, instance_uuid, task_state=None)
 
         if image_type == 'snapshot' and rotation:
             raise exception.ImageRotationNotAllowed()
@@ -745,7 +741,7 @@
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
     @checks_instance_lock
-    def set_admin_password(self, context, instance_id, new_pass=None):
+    def set_admin_password(self, context, instance_uuid, new_pass=None):
         """Set the root/admin password for an instance on this host.
 
         This is generally only called by API password resets after an
@@ -761,8 +757,8 @@
         max_tries = 10
 
         for i in xrange(max_tries):
-            instance_ref = self.db.instance_get(context, instance_id)
-            instance_id = instance_ref["id"]
+            instance_ref = self.db.instance_get(context, instance_uuid)
+            instance_uuid = instance_ref["uuid"]
             instance_state = instance_ref["power_state"]
             expected_state = power_state.RUNNING
 
@@ -793,16 +789,16 @@
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
     @checks_instance_lock
-    def inject_file(self, context, instance_id, path, file_contents):
+    def inject_file(self, context, instance_uuid, path, file_contents):
         """Write a file to the specified path in an instance on this host."""
         context = context.elevated()
-        instance_ref = self.db.instance_get(context, instance_id)
-        instance_id = instance_ref['id']
+        instance_ref = self.db.instance_get(context, instance_uuid)
+        instance_uuid = instance_ref['uuid']
         instance_state = instance_ref['power_state']
         expected_state = power_state.RUNNING
         if instance_state != expected_state:
             LOG.warn(_('trying to inject a file into a non-running '
-                    'instance: %(instance_id)s (state: %(instance_state)s '
+                    'instance: %(instance_uuid)s (state: %(instance_state)s '
                     'expected: %(expected_state)s)') % locals())
         nm = instance_ref['name']
         msg = _('instance %(nm)s: injecting file to %(path)s') % locals()
@@ -811,16 +807,16 @@
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
     @checks_instance_lock
-    def agent_update(self, context, instance_id, url, md5hash):
+    def agent_update(self, context, instance_uuid, url, md5hash):
         """Update agent running on an instance on this host."""
         context = context.elevated()
-        instance_ref = self.db.instance_get(context, instance_id)
-        instance_id = instance_ref['id']
+        instance_ref = self.db.instance_get(context, instance_uuid)
+        instance_uuid = instance_ref['uuid']
         instance_state = instance_ref['power_state']
         expected_state = power_state.RUNNING
         if instance_state != expected_state:
             LOG.warn(_('trying to update agent on a non-running '
-                    'instance: %(instance_id)s (state: %(instance_state)s '
+                    'instance: %(instance_uuid)s (state: %(instance_state)s '
                     'expected: %(expected_state)s)') % locals())
         nm = instance_ref['name']
         msg = _('instance %(nm)s: updating agent to %(url)s') % locals()
@@ -829,16 +825,16 @@
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
     @checks_instance_lock
-    def rescue_instance(self, context, instance_id, **kwargs):
+    def rescue_instance(self, context, instance_uuid, **kwargs):
         """
         Rescue an instance on this host.
         :param rescue_password: password to set on rescue instance
         """
 
-        LOG.audit(_('instance %s: rescuing'), instance_id, context=context)
+        LOG.audit(_('instance %s: rescuing'), instance_uuid, context=context)
         context = context.elevated()
 
-        instance_ref = self.db.instance_get(context, instance_id)
+        instance_ref = self.db.instance_get(context, instance_uuid)
         instance_ref.admin_pass = kwargs.get('rescue_password',
                 utils.generate_password(FLAGS.password_length))
         network_info = self._get_instance_nw_info(context, instance_ref)
@@ -848,19 +844,19 @@
 
         current_power_state = self._get_power_state(context, instance_ref)
         self._instance_update(context,
-                              instance_id,
+                              instance_uuid,
                               vm_state=vm_states.RESCUED,
                               task_state=None,
                               power_state=current_power_state)
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
     @checks_instance_lock
-    def unrescue_instance(self, context, instance_id):
+    def unrescue_instance(self, context, instance_uuid):
         """Rescue an instance on this host."""
-        LOG.audit(_('instance %s: unrescuing'), instance_id, context=context)
+        LOG.audit(_('instance %s: unrescuing'), instance_uuid, context=context)
         context = context.elevated()
 
-        instance_ref = self.db.instance_get(context, instance_id)
+        instance_ref = self.db.instance_get(context, instance_uuid)
         network_info = self._get_instance_nw_info(context, instance_ref)
 
         # NOTE(blamar): None of the virt drivers use the 'callback' param
@@ -868,18 +864,17 @@
 
         current_power_state = self._get_power_state(context, instance_ref)
         self._instance_update(context,
-                              instance_id,
+                              instance_uuid,
                               vm_state=vm_states.ACTIVE,
                               task_state=None,
                               power_state=current_power_state)
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
     @checks_instance_lock
-    def confirm_resize(self, context, instance_id, migration_id):
+    def confirm_resize(self, context, instance_uuid, migration_id):
         """Destroys the source instance."""
         migration_ref = self.db.migration_get(context, migration_id)
-        instance_ref = self.db.instance_get_by_uuid(context,
-                migration_ref.instance_uuid)
+        instance_ref = self.db.instance_get(context, instance_uuid)
 
         network_info = self._get_instance_nw_info(context, instance_ref)
         self.driver.confirm_migration(
@@ -893,7 +888,7 @@
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
     @checks_instance_lock
-    def revert_resize(self, context, instance_id, migration_id):
+    def revert_resize(self, context, instance_uuid, migration_id):
         """Destroys the new instance on the destination machine.
 
         Reverts the model changes, and powers on the old instance on the
@@ -901,8 +896,7 @@
 
         """
         migration_ref = self.db.migration_get(context, migration_id)
-        instance_ref = self.db.instance_get_by_uuid(context,
-                migration_ref.instance_uuid)
+        instance_ref = self.db.instance_get(context, instance_uuid)
 
         network_info = self._get_instance_nw_info(context, instance_ref)
         self.driver.destroy(instance_ref, network_info)
@@ -910,13 +904,13 @@
                 instance_ref['host'])
         rpc.cast(context, topic,
                 {'method': 'finish_revert_resize',
-                 'args': {'instance_id': instance_ref['uuid'],
+                 'args': {'instance_uuid': instance_ref['uuid'],
                           'migration_id': migration_ref['id']},
                 })
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
     @checks_instance_lock
-    def finish_revert_resize(self, context, instance_id, migration_id):
+    def finish_revert_resize(self, context, instance_uuid, migration_id):
         """Finishes the second half of reverting a resize.
 
         Power back on the source instance and revert the resized attributes
@@ -924,8 +918,7 @@
 
         """
         migration_ref = self.db.migration_get(context, migration_id)
-        instance_ref = self.db.instance_get_by_uuid(context,
-                migration_ref.instance_uuid)
+        instance_ref = self.db.instance_get(context, instance_uuid)
 
         instance_type = self.db.instance_type_get(context,
                 migration_ref['old_instance_type_id'])
@@ -950,23 +943,19 @@
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
     @checks_instance_lock
-    def prep_resize(self, context, instance_id, instance_type_id):
+    def prep_resize(self, context, instance_uuid, instance_type_id):
         """Initiates the process of moving a running instance to another host.
 
         Possibly changes the RAM and disk size in the process.
 
         """
         context = context.elevated()
-
-        # Because of checks_instance_lock, this must currently be called
-        # instance_id. However, the compute API is always passing the UUID
-        # of the instance down
-        instance_ref = self.db.instance_get_by_uuid(context, instance_id)
+        instance_ref = self.db.instance_get(context, instance_uuid)
 
         same_host = instance_ref['host'] == FLAGS.host
         if same_host and not FLAGS.allow_resize_to_same_host:
             self._instance_update(context,
-                                  instance_id,
+                                  instance_uuid,
                                   vm_state=vm_states.ERROR)
             msg = _('Migration error: destination same as source!')
             raise exception.Error(msg)
@@ -991,7 +980,7 @@
                 instance_ref['host'])
         rpc.cast(context, topic,
                 {'method': 'resize_instance',
-                 'args': {'instance_id': instance_ref['uuid'],
+                 'args': {'instance_uuid': instance_ref['uuid'],
                           'migration_id': migration_ref['id']}})
 
         usage_info = utils.usage_from_instance(instance_ref,
@@ -1004,11 +993,10 @@
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
     @checks_instance_lock
-    def resize_instance(self, context, instance_id, migration_id):
+    def resize_instance(self, context, instance_uuid, migration_id):
         """Starts the migration of a running instance to another host."""
         migration_ref = self.db.migration_get(context, migration_id)
-        instance_ref = self.db.instance_get_by_uuid(context,
-                migration_ref.instance_uuid)
+        instance_ref = self.db.instance_get(context, instance_uuid)
 
         self.db.migration_update(context,
                                  migration_id,
@@ -1027,13 +1015,13 @@
                                       migration_ref['dest_compute'])
         params = {'migration_id': migration_id,
                   'disk_info': disk_info,
-                  'instance_id': instance_ref['uuid']}
+                  'instance_uuid': instance_ref['uuid']}
         rpc.cast(context, topic, {'method': 'finish_resize',
                                   'args': params})
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
     @checks_instance_lock
-    def finish_resize(self, context, instance_id, migration_id, disk_info):
+    def finish_resize(self, context, instance_uuid, migration_id, disk_info):
         """Completes the migration process.
 
         Sets up the newly transferred disk and turns on the instance at its
@@ -1043,8 +1031,7 @@
         migration_ref = self.db.migration_get(context, migration_id)
 
         resize_instance = False
-        instance_ref = self.db.instance_get_by_uuid(context,
-                migration_ref.instance_uuid)
+        instance_ref = self.db.instance_get(context, instance_uuid)
         if migration_ref['old_instance_type_id'] != \
            migration_ref['new_instance_type_id']:
             instance_type = self.db.instance_type_get(context,
@@ -1056,15 +1043,13 @@
                         local_gb=instance_type['local_gb']))
             resize_instance = True
 
-        instance_ref = self.db.instance_get_by_uuid(context,
-                                            instance_ref.uuid)
-
+        instance_ref = self.db.instance_get(context, instance_uuid)
         network_info = self._get_instance_nw_info(context, instance_ref)
         self.driver.finish_migration(context, migration_ref, instance_ref,
                                      disk_info, network_info, resize_instance)
 
         self._instance_update(context,
-                              instance_id,
+                              instance_uuid,
                               vm_state=vm_states.ACTIVE,
                               task_state=task_states.RESIZE_VERIFY)
 
@@ -1073,58 +1058,58 @@
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
     @checks_instance_lock
-    def add_fixed_ip_to_instance(self, context, instance_id, network_id):
+    def add_fixed_ip_to_instance(self, context, instance_uuid, network_id):
         """Calls network_api to add new fixed_ip to instance
         then injects the new network info and resets instance networking.
 
         """
-        self.network_api.add_fixed_ip_to_instance(context, instance_id,
+        self.network_api.add_fixed_ip_to_instance(context, instance_uuid,
                                                   self.host, network_id)
-        self.inject_network_info(context, instance_id)
-        self.reset_network(context, instance_id)
+        self.inject_network_info(context, instance_uuid)
+        self.reset_network(context, instance_uuid)
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
     @checks_instance_lock
-    def remove_fixed_ip_from_instance(self, context, instance_id, address):
+    def remove_fixed_ip_from_instance(self, context, instance_uuid, address):
         """Calls network_api to remove existing fixed_ip from instance
         by injecting the altered network info and resetting
         instance networking.
         """
-        self.network_api.remove_fixed_ip_from_instance(context, instance_id,
+        self.network_api.remove_fixed_ip_from_instance(context, instance_uuid,
                                                        address)
-        self.inject_network_info(context, instance_id)
-        self.reset_network(context, instance_id)
+        self.inject_network_info(context, instance_uuid)
+        self.reset_network(context, instance_uuid)
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
     @checks_instance_lock
-    def pause_instance(self, context, instance_id):
+    def pause_instance(self, context, instance_uuid):
         """Pause an instance on this host."""
-        LOG.audit(_('instance %s: pausing'), instance_id, context=context)
+        LOG.audit(_('instance %s: pausing'), instance_uuid, context=context)
         context = context.elevated()
 
-        instance_ref = self.db.instance_get(context, instance_id)
+        instance_ref = self.db.instance_get(context, instance_uuid)
         self.driver.pause(instance_ref, lambda result: None)
 
         current_power_state = self._get_power_state(context, instance_ref)
         self._instance_update(context,
-                              instance_id,
+                              instance_uuid,
                               power_state=current_power_state,
                               vm_state=vm_states.PAUSED,
                               task_state=None)
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
     @checks_instance_lock
-    def unpause_instance(self, context, instance_id):
+    def unpause_instance(self, context, instance_uuid):
         """Unpause a paused instance on this host."""
-        LOG.audit(_('instance %s: unpausing'), instance_id, context=context)
+        LOG.audit(_('instance %s: unpausing'), instance_uuid, context=context)
         context = context.elevated()
 
-        instance_ref = self.db.instance_get(context, instance_id)
+        instance_ref = self.db.instance_get(context, instance_uuid)
         self.driver.unpause(instance_ref, lambda result: None)
 
         current_power_state = self._get_power_state(context, instance_ref)
         self._instance_update(context,
-                              instance_id,
+                              instance_uuid,
                               power_state=current_power_state,
                               vm_state=vm_states.ACTIVE,
                               task_state=None)
@@ -1140,123 +1125,120 @@
         return self.driver.set_host_enabled(host, enabled)
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
-    def get_diagnostics(self, context, instance_id):
+    def get_diagnostics(self, context, instance_uuid):
         """Retrieve diagnostics for an instance on this host."""
-        instance_ref = self.db.instance_get(context, instance_id)
+        instance_ref = self.db.instance_get(context, instance_uuid)
         if instance_ref["power_state"] == power_state.RUNNING:
-            LOG.audit(_("instance %s: retrieving diagnostics"), instance_id,
+            LOG.audit(_("instance %s: retrieving diagnostics"), instance_uuid,
                       context=context)
             return self.driver.get_diagnostics(instance_ref)
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
     @checks_instance_lock
-    def suspend_instance(self, context, instance_id):
+    def suspend_instance(self, context, instance_uuid):
         """Suspend the given instance."""
-        LOG.audit(_('instance %s: suspending'), instance_id, context=context)
+        LOG.audit(_('instance %s: suspending'), instance_uuid, context=context)
         context = context.elevated()
 
-        instance_ref = self.db.instance_get(context, instance_id)
+        instance_ref = self.db.instance_get(context, instance_uuid)
         self.driver.suspend(instance_ref, lambda result: None)
 
         current_power_state = self._get_power_state(context, instance_ref)
         self._instance_update(context,
-                              instance_id,
+                              instance_uuid,
                               power_state=current_power_state,
                               vm_state=vm_states.SUSPENDED,
                               task_state=None)
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
     @checks_instance_lock
-    def resume_instance(self, context, instance_id):
+    def resume_instance(self, context, instance_uuid):
         """Resume the given suspended instance."""
-        LOG.audit(_('instance %s: resuming'), instance_id, context=context)
+        LOG.audit(_('instance %s: resuming'), instance_uuid, context=context)
         context = context.elevated()
 
-        instance_ref = self.db.instance_get(context, instance_id)
+        instance_ref = self.db.instance_get(context, instance_uuid)
         self.driver.resume(instance_ref, lambda result: None)
 
         current_power_state = self._get_power_state(context, instance_ref)
         self._instance_update(context,
-                              instance_id,
+                              instance_uuid,
                               power_state=current_power_state,
                               vm_state=vm_states.ACTIVE,
                               task_state=None)
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
-    def lock_instance(self, context, instance_id):
+    def lock_instance(self, context, instance_uuid):
         """Lock the given instance."""
         context = context.elevated()
 
-        LOG.debug(_('instance %s: locking'), instance_id, context=context)
-        self.db.instance_update(context, instance_id, {'locked': True})
+        LOG.debug(_('instance %s: locking'), instance_uuid, context=context)
+        self.db.instance_update(context, instance_uuid, {'locked': True})
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
-    def unlock_instance(self, context, instance_id):
+    def unlock_instance(self, context, instance_uuid):
         """Unlock the given instance."""
         context = context.elevated()
 
-        LOG.debug(_('instance %s: unlocking'), instance_id, context=context)
-        self.db.instance_update(context, instance_id, {'locked': False})
+        LOG.debug(_('instance %s: unlocking'), instance_uuid, context=context)
+        self.db.instance_update(context, instance_uuid, {'locked': False})
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
-    def get_lock(self, context, instance_id):
+    def get_lock(self, context, instance_uuid):
         """Return the boolean state of the given instance's lock."""
         context = context.elevated()
-        LOG.debug(_('instance %s: getting locked state'), instance_id,
+        LOG.debug(_('instance %s: getting locked state'), instance_uuid,
                   context=context)
-        if utils.is_uuid_like(instance_id):
-            uuid = instance_id
-            instance_ref = self.db.instance_get_by_uuid(context, uuid)
-        else:
-            instance_ref = self.db.instance_get(context, instance_id)
-        return instance_ref['locked']
+        instance = self.db.instance_get(context, instance_uuid)
+        return instance['locked']
 
     @checks_instance_lock
-    def reset_network(self, context, instance_id):
+    def reset_network(self, context, instance_uuid):
         """Reset networking on the given instance."""
-        instance = self.db.instance_get(context, instance_id)
-        LOG.debug(_('instance %s: reset network'), instance_id,
+        instance = self.db.instance_get(context, instance_uuid)
+        LOG.debug(_('instance %s: reset network'), instance_uuid,
                                                    context=context)
         self.driver.reset_network(instance)
 
     @checks_instance_lock
-    def inject_network_info(self, context, instance_id):
+    def inject_network_info(self, context, instance_uuid):
         """Inject network info for the given instance."""
-        LOG.debug(_('instance %s: inject network info'), instance_id,
+        LOG.debug(_('instance %s: inject network info'), instance_uuid,
                                                          context=context)
-        instance = self.db.instance_get(context, instance_id)
+        instance = self.db.instance_get(context, instance_uuid)
         network_info = self._get_instance_nw_info(context, instance)
         LOG.debug(_("network_info to inject: |%s|"), network_info)
 
         self.driver.inject_network_info(instance, network_info)
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
-    def get_console_output(self, context, instance_id):
+    def get_console_output(self, context, instance_uuid):
         """Send the console output for the given instance."""
         context = context.elevated()
-        instance_ref = self.db.instance_get(context, instance_id)
-        LOG.audit(_("Get console output for instance %s"), instance_id,
+        instance_ref = self.db.instance_get(context, instance_uuid)
+        LOG.audit(_("Get console output for instance %s"), instance_uuid,
                   context=context)
         output = self.driver.get_console_output(instance_ref)
         return output.decode('utf-8', 'replace').encode('ascii', 'replace')
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
-    def get_ajax_console(self, context, instance_id):
+    def get_ajax_console(self, context, instance_uuid):
         """Return connection information for an ajax console."""
         context = context.elevated()
-        LOG.debug(_("instance %s: getting ajax console"), instance_id)
-        instance_ref = self.db.instance_get(context, instance_id)
+        LOG.debug(_("instance %s: getting ajax console"), instance_uuid)
+        instance_ref = self.db.instance_get(context, instance_uuid)
         return self.driver.get_ajax_console(instance_ref)
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
-    def get_vnc_console(self, context, instance_id):
+    def get_vnc_console(self, context, instance_uuid):
         """Return connection information for a vnc console."""
         context = context.elevated()
-        LOG.debug(_("instance %s: getting vnc console"), instance_id)
-        instance_ref = self.db.instance_get(context, instance_id)
+        LOG.debug(_("instance %s: getting vnc console"), instance_uuid)
+        instance_ref = self.db.instance_get(context, instance_uuid)
         return self.driver.get_vnc_console(instance_ref)
 
-    def _attach_volume_boot(self, context, instance_id, volume_id, mountpoint):
+    def _attach_volume_boot(self, context, instance_uuid, volume_id,
+                            mountpoint):
         """Attach a volume to an instance at boot time. So actual attach
         is done by instance creation"""
 
@@ -1265,20 +1247,21 @@
         volume.API().check_attach(context, volume_id)
 
         context = context.elevated()
-        LOG.audit(_("instance %(instance_id)s: booting with "
+        LOG.audit(_("instance %(instance_uuid)s: booting with "
                     "volume %(volume_id)s at %(mountpoint)s") %
                   locals(), context=context)
         dev_path = self.volume_manager.setup_compute_volume(context, volume_id)
-        self.db.volume_attached(context, volume_id, instance_id, mountpoint)
+        self.db.volume_attached(context, volume_id, instance_uuid, mountpoint)
         return dev_path
 
     @checks_instance_lock
-    def attach_volume(self, context, instance_id, volume_id, mountpoint):
+    def attach_volume(self, context, instance_uuid, volume_id, mountpoint):
         """Attach a volume to an instance."""
         context = context.elevated()
-        instance_ref = self.db.instance_get(context, instance_id)
-        LOG.audit(_("instance %(instance_id)s: attaching volume %(volume_id)s"
-                " to %(mountpoint)s") % locals(), context=context)
+        instance_ref = self.db.instance_get(context, instance_uuid)
+        LOG.audit(_("instance %(instance_uuid)s: attaching volume "
+                    "%(volume_id)s to %(mountpoint)s") % locals(),
+                    context=context)
         dev_path = self.volume_manager.setup_compute_volume(context,
                                                             volume_id)
         try:
@@ -1287,10 +1270,10 @@
                                       mountpoint)
             self.db.volume_attached(context,
                                     volume_id,
-                                    instance_id,
+                                    instance_uuid,
                                     mountpoint)
             values = {
-                'instance_id': instance_id,
+                'instance_uuid': instance_uuid,
                 'device_name': mountpoint,
                 'delete_on_termination': False,
                 'virtual_name': None,
@@ -1303,7 +1286,7 @@
             # NOTE(vish): The inline callback eats the exception info so we
             #             log the traceback here and reraise the same
             #             ecxception below.
-            LOG.exception(_("instance %(instance_id)s: attach failed"
+            LOG.exception(_("instance %(instance_uuid)s: attach failed"
                     " %(mountpoint)s, removing") % locals(), context=context)
             self.volume_manager.remove_compute_volume(context,
                                                       volume_id)
@@ -1313,17 +1296,17 @@
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
     @checks_instance_lock
-    def _detach_volume(self, context, instance_id, volume_id, destroy_bdm):
+    def _detach_volume(self, context, instance_uuid, volume_id, destroy_bdm):
         """Detach a volume from an instance."""
         context = context.elevated()
-        instance_ref = self.db.instance_get(context, instance_id)
+        instance_ref = self.db.instance_get(context, instance_uuid)
         volume_ref = self.db.volume_get(context, volume_id)
         mp = volume_ref['mountpoint']
         LOG.audit(_("Detach volume %(volume_id)s from mountpoint %(mp)s"
-                " on instance %(instance_id)s") % locals(), context=context)
+                " on instance %(instance_uuid)s") % locals(), context=context)
         if instance_ref['name'] not in self.driver.list_instances():
             LOG.warn(_("Detaching volume from unknown instance %s"),
-                     instance_id, context=context)
+                     instance_uuid, context=context)
         else:
             self.driver.detach_volume(instance_ref['name'],
                                       volume_ref['mountpoint'])
@@ -1331,12 +1314,12 @@
         self.db.volume_detached(context, volume_id)
         if destroy_bdm:
             self.db.block_device_mapping_destroy_by_instance_and_volume(
-                context, instance_id, volume_id)
+                context, instance_uuid, volume_id)
         return True
 
-    def detach_volume(self, context, instance_id, volume_id):
+    def detach_volume(self, context, instance_uuid, volume_id):
         """Detach a volume from an instance."""
-        return self._detach_volume(context, instance_id, volume_id, True)
+        return self._detach_volume(context, instance_uuid, volume_id, True)
 
     def remove_volume(self, context, volume_id):
         """Remove volume on compute host.
@@ -1413,12 +1396,12 @@
         """
         return self.driver.update_available_resource(context, self.host)
 
-    def pre_live_migration(self, context, instance_id, time=None,
+    def pre_live_migration(self, context, instance_uuid, time=None,
                            block_migration=False, disk=None):
         """Preparations for live migration at dest host.
 
         :param context: security context
-        :param instance_id: nova.db.sqlalchemy.models.Instance.Id
+        :param instance_uuid: nova.db.sqlalchemy.models.Instance.Id
         :param block_migration: if true, prepare for block migration
 
         """
@@ -1426,7 +1409,7 @@
             time = greenthread
 
         # Getting instance info
-        instance_ref = self.db.instance_get(context, instance_id)
+        instance_ref = self.db.instance_get(context, instance_uuid)
         hostname = instance_ref['hostname']
 
         # If any volume is mounted, prepare here.
@@ -1447,7 +1430,7 @@
 
         fixed_ips = [nw_info[1]['ips'] for nw_info in network_info]
         if not fixed_ips:
-            raise exception.FixedIpNotFoundForInstance(instance_id=instance_id)
+            raise exception.FixedIpNotFoundForInstance(instance_id=instance_uuid)
 
         max_retry = FLAGS.live_migration_retry_count
         for cnt in range(max_retry):
@@ -1478,18 +1461,18 @@
                                             instance_ref,
                                             disk)
 
-    def live_migration(self, context, instance_id,
+    def live_migration(self, context, instance_uuid,
                        dest, block_migration=False):
         """Executing live migration.
 
         :param context: security context
-        :param instance_id: nova.db.sqlalchemy.models.Instance.Id
+        :param instance_uuid: nova.db.sqlalchemy.models.Instance.Id
         :param dest: destination host
         :param block_migration: if true, do block migration
 
         """
         # Get instance for error handling.
-        instance_ref = self.db.instance_get(context, instance_id)
+        instance_ref = self.db.instance_get(context, instance_uuid)
 
         try:
             # Checking volume node is working correctly when any volumes
@@ -1498,7 +1481,7 @@
                 rpc.call(context,
                           FLAGS.volume_topic,
                           {"method": "check_for_export",
-                           "args": {'instance_id': instance_id}})
+                           "args": {'instance_uuid': instance_uuid}})
 
             if block_migration:
                 disk = self.driver.get_instance_disk_info(context,
@@ -1509,7 +1492,7 @@
             rpc.call(context,
                      self.db.queue_get_for(context, FLAGS.compute_topic, dest),
                      {"method": "pre_live_migration",
-                      "args": {'instance_id': instance_id,
+                      "args": {'instance_uuid': instance_uuid,
                                'block_migration': block_migration,
                                'disk': disk}})
 
@@ -1537,18 +1520,18 @@
         and mainly updating database record.
 
         :param ctxt: security context
-        :param instance_id: nova.db.sqlalchemy.models.Instance.Id
+        :param instance_uuid: nova.db.sqlalchemy.models.Instance.Id
         :param dest: destination host
         :param block_migration: if true, do block migration
 
         """
 
         LOG.info(_('post_live_migration() is started..'))
-        instance_id = instance_ref['id']
+        instance_uuid = instance_ref['uuid']
 
         # Detaching volumes.
         try:
-            for vol in self.db.volume_get_all_by_instance(ctxt, instance_id):
+            for vol in self.db.volume_get_all_by_instance(ctxt, instance_uuid):
                 self.volume_manager.remove_compute_volume(ctxt, vol['id'])
         except exception.NotFound:
             pass
@@ -1566,7 +1549,7 @@
             # Not return if floating_ip is not found, otherwise,
             # instance never be accessible..
             floating_ip = self.db.instance_get_floating_address(ctxt,
-                                                         instance_id)
+                                                         instance_uuid)
             if not floating_ip:
                 LOG.info(_('No floating_ip is found for %s.'), i_name)
             else:
@@ -1587,13 +1570,13 @@
         rpc.call(ctxt,
                  self.db.queue_get_for(ctxt, FLAGS.compute_topic, dest),
                      {"method": "post_live_migration_at_destination",
-                      "args": {'instance_id': instance_ref.id,
+                      "args": {'instance_uuid': instance_ref.uuid,
                                'block_migration': block_migration}})
 
         # Restore instance state
         current_power_state = self._get_power_state(ctxt, instance_ref)
         self._instance_update(ctxt,
-                              instance_ref["id"],
+                              instance_ref["uuid"],
                               host=dest,
                               power_state=current_power_state,
                               vm_state=vm_states.ACTIVE,
@@ -1616,15 +1599,15 @@
                    "This error can be safely ignored."))
 
     def post_live_migration_at_destination(self, context,
-                                instance_id, block_migration=False):
+                                instance_uuid, block_migration=False):
         """Post operations for live migration .
 
         :param context: security context
-        :param instance_id: nova.db.sqlalchemy.models.Instance.Id
+        :param instance_uuid: nova.db.sqlalchemy.models.Instance.Id
         :param block_migration: block_migration
 
         """
-        instance_ref = self.db.instance_get(context, instance_id)
+        instance_ref = self.db.instance_get(context, instance_uuid)
         LOG.info(_('Post operation of migraton started for %s .')
                  % instance_ref.name)
         network_info = self._get_instance_nw_info(context, instance_ref)
@@ -1638,14 +1621,14 @@
         """Recovers Instance/volume state from migrating -> running.
 
         :param context: security context
-        :param instance_id: nova.db.sqlalchemy.models.Instance.Id
+        :param instance_uuid: nova.db.sqlalchemy.models.Instance.Id
         :param dest:
             This method is called from live migration src host.
             This param specifies destination host.
         """
         host = instance_ref['host']
         self._instance_update(context,
-                              instance_ref['id'],
+                              instance_ref['uuid'],
                               host=host,
                               vm_state=vm_states.ACTIVE,
                               task_state=None)
@@ -1662,15 +1645,15 @@
             rpc.cast(context,
                      self.db.queue_get_for(context, FLAGS.compute_topic, dest),
                      {"method": "rollback_live_migration_at_destination",
-                      "args": {'instance_id': instance_ref['id']}})
+                      "args": {'instance_uuid': instance_ref['uuid']}})
 
-    def rollback_live_migration_at_destination(self, context, instance_id):
+    def rollback_live_migration_at_destination(self, context, instance_uuid):
         """ Cleaning up image directory that is created pre_live_migration.
 
         :param context: security context
-        :param instance_id: nova.db.sqlalchemy.models.Instance.Id
+        :param instance_uuid: nova.db.sqlalchemy.models.Instance.Id
         """
-        instances_ref = self.db.instance_get(context, instance_id)
+        instances_ref = self.db.instance_get(context, instance_uuid)
         network_info = self._get_instance_nw_info(context, instances_ref)
         self.driver.destroy(instances_ref, network_info)
 
@@ -1764,7 +1747,7 @@
                 continue
 
             self._instance_update(context,
-                                  db_instance["id"],
+                                  db_instance["uuid"],
                                   power_state=vm_power_state)
 
     def _reclaim_queued_deletes(self, context):
@@ -1779,4 +1762,4 @@
             if instance['vm_state'] == vm_states.SOFT_DELETE and \
                (curtime - instance['deleted_at']) >= queue_time:
                 LOG.info('Deleting %s' % instance['name'])
-                self._delete_instance(context, instance['id'])
+                self._delete_instance(context, instance['uuid'])

=== modified file 'nova/console/manager.py'
--- nova/console/manager.py	2011-06-30 01:30:15 +0000
+++ nova/console/manager.py	2011-09-22 19:29:25 +0000
@@ -57,16 +57,16 @@
         self.driver.init_host()
 
     @exception.wrap_exception()
-    def add_console(self, context, instance_id, password=None,
+    def add_console(self, context, instance_uuid, password=None,
                     port=None, **kwargs):
-        instance = self.db.instance_get(context, instance_id)
+        instance = self.db.instance_get(context, instance_uuid)
         host = instance['host']
         name = instance['name']
         pool = self.get_pool_for_instance_host(context, host)
         try:
             console = self.db.console_get_by_pool_instance(context,
                                                       pool['id'],
-                                                      instance_id)
+                                                      instance_uuid)
         except exception.NotFound:
             logging.debug(_('Adding console'))
             if not password:
@@ -74,7 +74,7 @@
             if not port:
                 port = self.driver.get_port(context)
             console_data = {'instance_name': name,
-                            'instance_id': instance_id,
+                            'instance_uuid': instance_uuid,
                             'password': password,
                             'pool_id': pool['id']}
             if port:

=== modified file 'nova/console/vmrc.py'
--- nova/console/vmrc.py	2011-06-07 17:32:53 +0000
+++ nova/console/vmrc.py	2011-09-22 19:29:25 +0000
@@ -90,7 +90,7 @@
                 vm_ds_path_name = ds_path_name
                 break
         if vm_ref is None:
-            raise exception.InstanceNotFound(instance_id=instance_name)
+            raise exception.InstanceNotFound(instance_uuid=instance_name)
         json_data = json.dumps({'vm_id': vm_ds_path_name,
                     'username': username,
                     'password': password})
@@ -124,7 +124,7 @@
             if vm.propSet[0].val == instance_name:
                 vm_ref = vm.obj
         if vm_ref is None:
-            raise exception.InstanceNotFound(instance_id=instance_name)
+            raise exception.InstanceNotFound(instance_uuid=instance_name)
         virtual_machine_ticket = \
                         vim_session._call_method(
             vim_session._get_vim(),

=== modified file 'nova/db/api.py'
--- nova/db/api.py	2011-09-21 16:29:36 +0000
+++ nova/db/api.py	2011-09-22 19:29:25 +0000
@@ -43,7 +43,7 @@
                     'The backend to use for db')
 flags.DEFINE_boolean('enable_new_services', True,
                      'Services to be added to the available pool on create')
-flags.DEFINE_string('instance_name_template', 'instance-%08x',
+flags.DEFINE_string('instance_name_template', 'instance-%s',
                     'Template string to be used to generate instance names')
 flags.DEFINE_string('volume_name_template', 'volume-%08x',
                     'Template string to be used to generate instance names')
@@ -74,9 +74,9 @@
 ###################
 
 
-def service_destroy(context, instance_id):
+def service_destroy(context, instance_uuid):
     """Destroy the service or raise if it does not exist."""
-    return IMPL.service_destroy(context, instance_id)
+    return IMPL.service_destroy(context, instance_uuid)
 
 
 def service_get(context, service_id):
@@ -331,25 +331,25 @@
 ####################
 
 
-def fixed_ip_associate(context, address, instance_id, network_id=None,
+def fixed_ip_associate(context, address, instance_uuid, network_id=None,
                        reserved=False):
     """Associate fixed ip to instance.
 
     Raises if fixed ip is not available.
 
     """
-    return IMPL.fixed_ip_associate(context, address, instance_id, network_id,
+    return IMPL.fixed_ip_associate(context, address, instance_uuid, network_id,
                                    reserved)
 
 
-def fixed_ip_associate_pool(context, network_id, instance_id=None, host=None):
+def fixed_ip_associate_pool(context, network_id, instance_uuid=None, host=None):
     """Find free ip in network and associate it to instance or host.
 
     Raises if one is not available.
 
     """
     return IMPL.fixed_ip_associate_pool(context, network_id,
-                                        instance_id, host)
+                                        instance_uuid, host)
 
 
 def fixed_ip_create(context, values):
@@ -382,9 +382,9 @@
     return IMPL.fixed_ip_get_by_address(context, address)
 
 
-def fixed_ip_get_by_instance(context, instance_id):
+def fixed_ip_get_by_instance(context, instance_uuid):
     """Get fixed ips by instance or raise if none exist."""
-    return IMPL.fixed_ip_get_by_instance(context, instance_id)
+    return IMPL.fixed_ip_get_by_instance(context, instance_uuid)
 
 
 def fixed_ip_get_by_network_host(context, network_id, host):
@@ -439,16 +439,16 @@
     return IMPL.virtual_interface_get_by_fixed_ip(context, fixed_ip_id)
 
 
-def virtual_interface_get_by_instance(context, instance_id):
+def virtual_interface_get_by_instance(context, instance_uuid):
     """Gets all virtual_interfaces for instance."""
-    return IMPL.virtual_interface_get_by_instance(context, instance_id)
-
-
-def virtual_interface_get_by_instance_and_network(context, instance_id,
+    return IMPL.virtual_interface_get_by_instance(context, instance_uuid)
+
+
+def virtual_interface_get_by_instance_and_network(context, instance_uuid,
                                                            network_id):
     """Gets all virtual interfaces for instance."""
     return IMPL.virtual_interface_get_by_instance_and_network(context,
-                                                              instance_id,
+                                                              instance_uuid,
                                                               network_id)
 
 
@@ -462,9 +462,9 @@
     return IMPL.virtual_interface_delete(context, vif_id)
 
 
-def virtual_interface_delete_by_instance(context, instance_id):
+def virtual_interface_delete_by_instance(context, instance_uuid):
     """Delete virtual interface records associated with instance."""
-    return IMPL.virtual_interface_delete_by_instance(context, instance_id)
+    return IMPL.virtual_interface_delete_by_instance(context, instance_uuid)
 
 
 def virtual_interface_get_all(context):
@@ -485,24 +485,19 @@
     return IMPL.instance_data_get_for_project(context, project_id)
 
 
-def instance_destroy(context, instance_id):
+def instance_destroy(context, instance_uuid):
     """Destroy the instance or raise if it does not exist."""
-    return IMPL.instance_destroy(context, instance_id)
-
-
-def instance_stop(context, instance_id):
+    return IMPL.instance_destroy(context, instance_uuid)
+
+
+def instance_stop(context, instance_uuid):
     """Stop the instance or raise if it does not exist."""
-    return IMPL.instance_stop(context, instance_id)
-
-
-def instance_get_by_uuid(context, uuid):
-    """Get an instance or raise if it does not exist."""
-    return IMPL.instance_get_by_uuid(context, uuid)
-
-
-def instance_get(context, instance_id):
-    """Get an instance or raise if it does not exist."""
-    return IMPL.instance_get(context, instance_id)
+    return IMPL.instance_stop(context, instance_uuid)
+
+
+def instance_get(context, instance_uuid):
+    """Get an instance or raise if it does not exist."""
+    return IMPL.instance_get(context, instance_uuid)
 
 
 def instance_get_all(context):
@@ -561,48 +556,51 @@
     return IMPL.instance_get_by_fixed_ipv6(context, address)
 
 
-def instance_get_fixed_addresses(context, instance_id):
+def instance_get_fixed_addresses(context, instance_uuid):
     """Get the fixed ip address of an instance."""
-    return IMPL.instance_get_fixed_addresses(context, instance_id)
-
-
-def instance_get_fixed_addresses_v6(context, instance_id):
-    return IMPL.instance_get_fixed_addresses_v6(context, instance_id)
-
-
-def instance_get_floating_address(context, instance_id):
+    return IMPL.instance_get_fixed_addresses(context, instance_uuid)
+
+
+def instance_get_fixed_addresses_v6(context, instance_uuid):
+    return IMPL.instance_get_fixed_addresses_v6(context, instance_uuid)
+
+
+def instance_get_floating_address(context, instance_uuid):
     """Get the first floating ip address of an instance."""
-    return IMPL.instance_get_floating_address(context, instance_id)
+    return IMPL.instance_get_floating_address(context, instance_uuid)
 
 
 def instance_get_project_vpn(context, project_id):
     """Get a vpn instance by project or return None."""
     return IMPL.instance_get_project_vpn(context, project_id)
 
+def instance_get_id_by_uuid(context, instance_uuid):
+    """Get corresponding instance id or raise if it does not exist."""
+    return IMPL.instance_get_id_by_uuid(context, instance_uuid)
 
-def instance_set_state(context, instance_id, state, description=None):
+def instance_set_state(context, instance_uuid, state, description=None):
     """Set the state of an instance."""
-    return IMPL.instance_set_state(context, instance_id, state, description)
-
-
-def instance_update(context, instance_id, values):
+    return IMPL.instance_set_state(context, instance_uuid, state, description)
+
+
+def instance_update(context, instance_uuid, values):
     """Set the given properties on an instance and update it.
 
     Raises NotFound if instance does not exist.
 
     """
-    return IMPL.instance_update(context, instance_id, values)
-
-
-def instance_add_security_group(context, instance_id, security_group_id):
+    return IMPL.instance_update(context, instance_uuid, values)
+
+
+def instance_add_security_group(context, instance_uuid, security_group_id):
     """Associate the given security group with the given instance."""
-    return IMPL.instance_add_security_group(context, instance_id,
+    return IMPL.instance_add_security_group(context, instance_uuid,
                                             security_group_id)
 
 
-def instance_remove_security_group(context, instance_id, security_group_id):
+def instance_remove_security_group(context, instance_uuid, security_group_id):
     """Disassociate the given security group from the given instance."""
-    return IMPL.instance_remove_security_group(context, instance_id,
+    return IMPL.instance_remove_security_group(context, instance_uuid,
                                             security_group_id)
 
 
@@ -611,9 +609,9 @@
     return IMPL.instance_action_create(context, values)
 
 
-def instance_get_actions(context, instance_id):
+def instance_get_actions(context, instance_uuid):
     """Get instance actions by instance id."""
-    return IMPL.instance_get_actions(context, instance_id)
+    return IMPL.instance_get_actions(context, instance_uuid)
 
 
 def instance_get_id_to_uuid_mapping(context, ids):
@@ -749,14 +747,14 @@
     return IMPL.network_get_by_cidr(context, cidr)
 
 
-def network_get_by_instance(context, instance_id):
+def network_get_by_instance(context, instance_uuid):
     """Get a network by instance id or raise if it does not exist."""
-    return IMPL.network_get_by_instance(context, instance_id)
-
-
-def network_get_all_by_instance(context, instance_id):
+    return IMPL.network_get_by_instance(context, instance_uuid)
+
+
+def network_get_all_by_instance(context, instance_uuid):
     """Get all networks by instance id or raise if none exist."""
-    return IMPL.network_get_all_by_instance(context, instance_id)
+    return IMPL.network_get_all_by_instance(context, instance_uuid)
 
 
 def network_get_all_by_host(context, host):
@@ -908,9 +906,9 @@
     return IMPL.volume_allocate_iscsi_target(context, volume_id, host)
 
 
-def volume_attached(context, volume_id, instance_id, mountpoint):
+def volume_attached(context, volume_id, instance_uuid, mountpoint):
     """Ensure that a volume is set as attached."""
-    return IMPL.volume_attached(context, volume_id, instance_id, mountpoint)
+    return IMPL.volume_attached(context, volume_id, instance_uuid, mountpoint)
 
 
 def volume_create(context, values):
@@ -948,9 +946,9 @@
     return IMPL.volume_get_all_by_host(context, host)
 
 
-def volume_get_all_by_instance(context, instance_id):
+def volume_get_all_by_instance(context, instance_uuid):
     """Get all volumes belonging to a instance."""
-    return IMPL.volume_get_all_by_instance(context, instance_id)
+    return IMPL.volume_get_all_by_instance(context, instance_uuid)
 
 
 def volume_get_all_by_project(context, project_id):
@@ -1043,9 +1041,9 @@
     return IMPL.block_device_mapping_update_or_create(context, values)
 
 
-def block_device_mapping_get_all_by_instance(context, instance_id):
+def block_device_mapping_get_all_by_instance(context, instance_uuid):
     """Get all block device mapping belonging to a instance"""
-    return IMPL.block_device_mapping_get_all_by_instance(context, instance_id)
+    return IMPL.block_device_mapping_get_all_by_instance(context, instance_uuid)
 
 
 def block_device_mapping_destroy(context, bdm_id):
@@ -1053,11 +1051,11 @@
     return IMPL.block_device_mapping_destroy(context, bdm_id)
 
 
-def block_device_mapping_destroy_by_instance_and_volume(context, instance_id,
+def block_device_mapping_destroy_by_instance_and_volume(context, instance_uuid,
                                                         volume_id):
     """Destroy the block device mapping or raise if it does not exist."""
     return IMPL.block_device_mapping_destroy_by_instance_and_volume(
-        context, instance_id, volume_id)
+        context, instance_uuid, volume_id)
 
 
 ####################
@@ -1083,9 +1081,9 @@
     return IMPL.security_group_get_by_project(context, project_id)
 
 
-def security_group_get_by_instance(context, instance_id):
+def security_group_get_by_instance(context, instance_uuid):
     """Get security groups to which the instance is assigned."""
-    return IMPL.security_group_get_by_instance(context, instance_id)
+    return IMPL.security_group_get_by_instance(context, instance_uuid)
 
 
 def security_group_exists(context, project_id, group_name):
@@ -1326,19 +1324,19 @@
     return IMPL.console_delete(context, console_id)
 
 
-def console_get_by_pool_instance(context, pool_id, instance_id):
+def console_get_by_pool_instance(context, pool_id, instance_uuid):
     """Get console entry for a given instance and pool."""
-    return IMPL.console_get_by_pool_instance(context, pool_id, instance_id)
-
-
-def console_get_all_by_instance(context, instance_id):
+    return IMPL.console_get_by_pool_instance(context, pool_id, instance_uuid)
+
+
+def console_get_all_by_instance(context, instance_uuid):
     """Get consoles for a given instance."""
-    return IMPL.console_get_all_by_instance(context, instance_id)
-
-
-def console_get(context, console_id, instance_id=None):
+    return IMPL.console_get_all_by_instance(context, instance_uuid)
+
+
+def console_get(context, console_id, instance_uuid=None):
     """Get a specific console (possibly on a given instance)."""
-    return IMPL.console_get(context, console_id, instance_id)
+    return IMPL.console_get(context, console_id, instance_uuid)
 
 
     ##################
@@ -1415,19 +1413,19 @@
 ####################
 
 
-def instance_metadata_get(context, instance_id):
+def instance_metadata_get(context, instance_uuid):
     """Get all metadata for an instance."""
-    return IMPL.instance_metadata_get(context, instance_id)
-
-
-def instance_metadata_delete(context, instance_id, key):
+    return IMPL.instance_metadata_get(context, instance_uuid)
+
+
+def instance_metadata_delete(context, instance_uuid, key):
     """Delete the given metadata item."""
-    IMPL.instance_metadata_delete(context, instance_id, key)
-
-
-def instance_metadata_update(context, instance_id, metadata, delete):
+    IMPL.instance_metadata_delete(context, instance_uuid, key)
+
+
+def instance_metadata_update(context, instance_uuid, metadata, delete):
     """Update metadata if it exists, otherwise create it."""
-    IMPL.instance_metadata_update(context, instance_id, metadata, delete)
+    IMPL.instance_metadata_update(context, instance_uuid, metadata, delete)
 
 
 ####################

=== modified file 'nova/db/sqlalchemy/api.py'
--- nova/db/sqlalchemy/api.py	2011-09-21 22:49:35 +0000
+++ nova/db/sqlalchemy/api.py	2011-09-22 19:29:25 +0000
@@ -124,13 +124,13 @@
 def require_instance_exists(f):
     """Decorator to require the specified instance to exist.
 
-    Requres the wrapped function to use context and instance_id as
+    Requres the wrapped function to use context and instance_uuid as
     their first two arguments.
     """
 
-    def wrapper(context, instance_id, *args, **kwargs):
-        db.api.instance_get(context, instance_id)
-        return f(context, instance_id, *args, **kwargs)
+    def wrapper(context, instance_uuid, *args, **kwargs):
+        db.api.instance_get(context, instance_uuid)
+        return f(context, instance_uuid, *args, **kwargs)
     wrapper.__name__ = f.__name__
     return wrapper
 
@@ -674,7 +674,7 @@
 
 
 @require_admin_context
-def fixed_ip_associate(context, address, instance_id, network_id=None,
+def fixed_ip_associate(context, address, instance_uuid, network_id=None,
                        reserved=False):
     """Keyword arguments:
     reserved -- should be a boolean value(True or False), exact value will be
@@ -704,14 +704,14 @@
                                            network_id,
                                            session=session)
         fixed_ip_ref.instance = instance_get(context,
-                                             instance_id,
+                                             instance_uuid,
                                              session=session)
         session.add(fixed_ip_ref)
     return fixed_ip_ref['address']
 
 
 @require_admin_context
-def fixed_ip_associate_pool(context, network_id, instance_id=None, host=None):
+def fixed_ip_associate_pool(context, network_id, instance_uuid=None, host=None):
     session = get_session()
     with session.begin():
         network_or_none = or_(models.FixedIp.network_id == network_id,
@@ -732,9 +732,9 @@
             fixed_ip_ref.network = network_get(context,
                                            network_id,
                                            session=session)
-        if instance_id:
+        if instance_uuid:
             fixed_ip_ref.instance = instance_get(context,
-                                                 instance_id,
+                                                 instance_uuid,
                                                  session=session)
         if host:
             fixed_ip_ref.host = host
@@ -770,9 +770,9 @@
     result = session.query(models.FixedIp).\
                      filter(models.FixedIp.network_id.in_(inner_q)).\
                      filter(models.FixedIp.updated_at < time).\
-                     filter(models.FixedIp.instance_id != None).\
+                     filter(models.FixedIp.instance_uuid != None).\
                      filter_by(allocated=False).\
-                     update({'instance_id': None,
+                     update({'instance_uuid': None,
                              'leased': False,
                              'updated_at': utils.utcnow()},
                              synchronize_session='fetch')
@@ -830,15 +830,15 @@
 
 
 @require_context
-def fixed_ip_get_by_instance(context, instance_id):
+def fixed_ip_get_by_instance(context, instance_uuid):
     session = get_session()
     rv = session.query(models.FixedIp).\
                  options(joinedload('floating_ips')).\
-                 filter_by(instance_id=instance_id).\
+                 filter_by(instance_uuid=instance_uuid).\
                  filter_by(deleted=False).\
                  all()
     if not rv:
-        raise exception.FixedIpNotFoundForInstance(instance_id=instance_id)
+        raise exception.FixedIpNotFoundForInstance(instance_uuid=instance_uuid)
     return rv
 
 
@@ -984,14 +984,14 @@
 
 @require_context
 @require_instance_exists
-def virtual_interface_get_by_instance(context, instance_id):
+def virtual_interface_get_by_instance(context, instance_uuid):
     """Gets all virtual interfaces for instance.
 
-    :param instance_id: = id of the instance to retreive vifs for
+    :param instance_uuid: = uuid of the instance to retreive vifs for
     """
     session = get_session()
     vif_refs = session.query(models.VirtualInterface).\
-                       filter_by(instance_id=instance_id).\
+                       filter_by(instance_uuid=instance_uuid).\
                        options(joinedload('network')).\
                        options(joinedload('fixed_ips')).\
                        all()
@@ -999,12 +999,13 @@
 
 
 @require_context
-def virtual_interface_get_by_instance_and_network(context, instance_id,
-                                                           network_id):
+def virtual_interface_get_by_instance_and_network(context,
+                                                  instance_uuid,
+                                                  network_id):
     """Gets virtual interface for instance that's associated with network."""
     session = get_session()
     vif_ref = session.query(models.VirtualInterface).\
-                      filter_by(instance_id=instance_id).\
+                      filter_by(instance_uuid=instance_uuid).\
                       filter_by(network_id=network_id).\
                       options(joinedload('network')).\
                       options(joinedload('fixed_ips')).\
@@ -1040,13 +1041,13 @@
 
 
 @require_context
-def virtual_interface_delete_by_instance(context, instance_id):
+def virtual_interface_delete_by_instance(context, instance_uuid):
     """Delete virtual interface records that are associated
-    with the instance given by instance_id.
+    with the instance given by instance_uuid.
 
-    :param instance_id: = id of instance
+    :param instance_uuid: = id of instance
     """
-    vif_refs = virtual_interface_get_by_instance(context, instance_id)
+    vif_refs = virtual_interface_get_by_instance(context, instance_uuid)
     for vif_ref in vif_refs:
         virtual_interface_delete(context, vif_ref['id'])
 
@@ -1110,85 +1111,70 @@
 
 
 @require_context
-def instance_destroy(context, instance_id):
+def instance_destroy(context, instance_uuid):
     session = get_session()
     with session.begin():
         session.query(models.Instance).\
-                filter_by(id=instance_id).\
+                filter_by(uuid=instance_uuid).\
                 update({'deleted': True,
                         'deleted_at': utils.utcnow(),
                         'updated_at': literal_column('updated_at')})
         session.query(models.SecurityGroupInstanceAssociation).\
-                filter_by(instance_id=instance_id).\
+                filter_by(instance_uuid=instance_uuid).\
                 update({'deleted': True,
                         'deleted_at': utils.utcnow(),
                         'updated_at': literal_column('updated_at')})
         session.query(models.InstanceMetadata).\
-                filter_by(instance_id=instance_id).\
+                filter_by(instance_uuid=instance_uuid).\
                 update({'deleted': True,
                         'deleted_at': utils.utcnow(),
                         'updated_at': literal_column('updated_at')})
 
 
 @require_context
-def instance_stop(context, instance_id):
+def instance_stop(context, instance_uuid):
     session = get_session()
     with session.begin():
         session.query(models.Instance).\
-                filter_by(id=instance_id).\
+                filter_by(uuid=instance_uuid).\
                 update({'host': None,
                         'vm_state': vm_states.STOPPED,
                         'task_state': None,
                         'updated_at': literal_column('updated_at')})
         session.query(models.SecurityGroupInstanceAssociation).\
-                filter_by(instance_id=instance_id).\
+                filter_by(instance_uuid=instance_uuid).\
                 update({'updated_at': literal_column('updated_at')})
         session.query(models.InstanceMetadata).\
-                filter_by(instance_id=instance_id).\
+                filter_by(instance_uuid=instance_uuid).\
                 update({'updated_at': literal_column('updated_at')})
 
 
 @require_context
-def instance_get_by_uuid(context, uuid, session=None):
-    partial = _build_instance_get(context, session=session)
-    result = partial.filter_by(uuid=uuid)
-    result = result.first()
-    if not result:
-        # FIXME(sirp): it would be nice if InstanceNotFound would accept a
-        # uuid parameter as well
-        raise exception.InstanceNotFound(instance_id=uuid)
-    return result
-
-
-@require_context
-def instance_get(context, instance_id, session=None):
-    partial = _build_instance_get(context, session=session)
-    result = partial.filter_by(id=instance_id)
-    result = result.first()
-    if not result:
-        raise exception.InstanceNotFound(instance_id=instance_id)
-    return result
-
-
-@require_context
-def _build_instance_get(context, session=None):
+def instance_get(context, instance_uuid, session=None):
     if not session:
         session = get_session()
 
     partial = session.query(models.Instance).\
-                     options(joinedload_all('fixed_ips.floating_ips')).\
-                     options(joinedload_all('fixed_ips.network')).\
-                     options(joinedload_all('security_groups.rules')).\
-                     options(joinedload('volumes')).\
-                     options(joinedload('metadata')).\
-                     options(joinedload('instance_type'))
+                    options(joinedload_all('fixed_ips.floating_ips')).\
+                    options(joinedload_all('fixed_ips.network')).\
+                    options(joinedload_all('security_groups.rules')).\
+                    options(joinedload('volumes')).\
+                    options(joinedload('metadata')).\
+                    options(joinedload('instance_type')).\
+                    filter_by(uuid=instance_uuid)
 
     if is_admin_context(context):
         partial = partial.filter_by(deleted=can_read_deleted(context))
     elif is_user_context(context):
         partial = partial.filter_by(project_id=context.project_id).\
-                        filter_by(deleted=False)
-    return partial
+                          filter_by(deleted=False)
+
+    result = partial.first()
+
+    if not result:
+        raise exception.InstanceNotFound(instance_uuid=instance_uuid)
+
+    return result
 
 
 @require_admin_context
@@ -1427,26 +1413,26 @@
 
 
 @require_context
-def instance_get_fixed_addresses(context, instance_id):
+def instance_get_fixed_addresses(context, instance_uuid):
     session = get_session()
     with session.begin():
-        instance_ref = instance_get(context, instance_id, session=session)
+        instance_ref = instance_get(context, instance_uuid, session=session)
         try:
-            fixed_ips = fixed_ip_get_by_instance(context, instance_id)
+            fixed_ips = fixed_ip_get_by_instance(context, instance_uuid)
         except exception.NotFound:
             return []
         return [fixed_ip.address for fixed_ip in fixed_ips]
 
 
 @require_context
-def instance_get_fixed_addresses_v6(context, instance_id):
+def instance_get_fixed_addresses_v6(context, instance_uuid):
     session = get_session()
     with session.begin():
         # get instance
-        instance_ref = instance_get(context, instance_id, session=session)
+        instance_ref = instance_get(context, instance_uuid, session=session)
         # assume instance has 1 mac for each network associated with it
         # get networks associated with instance
-        network_refs = network_get_all_by_instance(context, instance_id)
+        network_refs = network_get_all_by_instance(context, instance_uuid)
         # compile a list of cidr_v6 prefixes sorted by network id
         prefixes = [ref.cidr_v6 for ref in
                 sorted(network_refs, key=lambda ref: ref.id)]
@@ -1464,8 +1450,8 @@
 
 
 @require_context
-def instance_get_floating_address(context, instance_id):
-    fixed_ip_refs = fixed_ip_get_by_instance(context, instance_id)
+def instance_get_floating_address(context, instance_uuid):
+    fixed_ip_refs = fixed_ip_get_by_instance(context, instance_uuid)
     if not fixed_ip_refs:
         return None
     # NOTE(tr3buchet): this only gets the first fixed_ip
@@ -1477,30 +1463,26 @@
 
 
 @require_context
-def instance_update(context, instance_id, values):
+def instance_update(context, instance_uuid, values):
     session = get_session()
     metadata = values.get('metadata')
     if metadata is not None:
         instance_metadata_update(context,
-                                 instance_id,
+                                 instance_uuid,
                                  values.pop('metadata'),
                                  delete=True)
     with session.begin():
-        if utils.is_uuid_like(instance_id):
-            instance_ref = instance_get_by_uuid(context, instance_id,
-                                                session=session)
-        else:
-            instance_ref = instance_get(context, instance_id, session=session)
+        instance_ref = instance_get(context, instance_uuid, session=session)
         instance_ref.update(values)
         instance_ref.save(session=session)
         return instance_ref
 
 
-def instance_add_security_group(context, instance_id, security_group_id):
+def instance_add_security_group(context, instance_uuid, security_group_id):
     """Associate the given security group with the given instance"""
     session = get_session()
     with session.begin():
-        instance_ref = instance_get(context, instance_id, session=session)
+        instance_ref = instance_get(context, instance_uuid, session=session)
         security_group_ref = security_group_get(context,
                                                 security_group_id,
                                                 session=session)
@@ -1509,12 +1491,12 @@
 
 
 @require_context
-def instance_remove_security_group(context, instance_id, security_group_id):
+def instance_remove_security_group(context, instance_uuid, security_group_id):
     """Disassociate the given security group from the given instance"""
     session = get_session()
 
     session.query(models.SecurityGroupInstanceAssociation).\
-                filter_by(instance_id=instance_id).\
+                filter_by(instance_uuid=instance_uuid).\
                 filter_by(security_group_id=security_group_id).\
                 update({'deleted': True,
                         'deleted_at': utils.utcnow(),
@@ -1534,17 +1516,13 @@
 
 
 @require_admin_context
-def instance_get_actions(context, instance_id):
-    """Return the actions associated to the given instance id"""
+def instance_get_actions(context, instance_uuid):
+    """Return the actions associated to the given instance uuid"""
     session = get_session()
 
-    if utils.is_uuid_like(instance_id):
-        instance = instance_get_by_uuid(context, instance_id, session)
-        instance_id = instance.id
-
     return session.query(models.InstanceActions).\
-        filter_by(instance_id=instance_id).\
-       all()
+                   filter_by(instance_uuid=instance_uuid).\
+                   all()
 
 
 @require_context
@@ -1819,7 +1797,7 @@
     return session.query(models.FixedIp).\
                    options(joinedload_all('instance')).\
                    filter_by(network_id=network_id).\
-                   filter(models.FixedIp.instance_id != None).\
+                   filter(models.FixedIp.instance_uuid != None).\
                    filter(models.FixedIp.virtual_interface_id != None).\
                    filter_by(deleted=False).\
                    all()
@@ -1866,32 +1844,32 @@
 
 
 @require_admin_context
-def network_get_by_instance(_context, instance_id):
+def network_get_by_instance(_context, instance_uuid):
     # note this uses fixed IP to get to instance
     # only works for networks the instance has an IP from
     session = get_session()
     rv = session.query(models.Network).\
                  filter_by(deleted=False).\
                  join(models.Network.fixed_ips).\
-                 filter_by(instance_id=instance_id).\
+                 filter_by(instance_uuid=instance_uuid).\
                  filter_by(deleted=False).\
                  first()
     if not rv:
-        raise exception.NetworkNotFoundForInstance(instance_id=instance_id)
+        raise exception.NetworkNotFoundForInstance(instance_uuid=instance_uuid)
     return rv
 
 
 @require_admin_context
-def network_get_all_by_instance(_context, instance_id):
+def network_get_all_by_instance(_context, instance_uuid):
     session = get_session()
     rv = session.query(models.Network).\
                  filter_by(deleted=False).\
                  join(models.Network.fixed_ips).\
-                 filter_by(instance_id=instance_id).\
+                 filter_by(instance_uuid=instance_uuid).\
                  filter_by(deleted=False).\
                  all()
     if not rv:
-        raise exception.NetworkNotFoundForInstance(instance_id=instance_id)
+        raise exception.NetworkNotFoundForInstance(instance_uuid=instance_uuid)
     return rv
 
 
@@ -2149,15 +2127,14 @@
 
 
 @require_admin_context
-def volume_attached(context, volume_id, instance_id, mountpoint):
+def volume_attached(context, volume_id, instance_uuid, mountpoint):
     session = get_session()
     with session.begin():
         volume_ref = volume_get(context, volume_id, session=session)
         volume_ref['status'] = 'in-use'
         volume_ref['mountpoint'] = mountpoint
         volume_ref['attach_status'] = 'attached'
-        volume_ref.instance = instance_get(context, instance_id,
-                                           session=session)
+        volume_ref.instance = instance_get(context, instance_uuid, session)
         volume_ref.save(session=session)
 
 
@@ -2273,16 +2250,16 @@
 
 
 @require_admin_context
-def volume_get_all_by_instance(context, instance_id):
+def volume_get_all_by_instance(context, instance_uuid):
     session = get_session()
     result = session.query(models.Volume).\
                      options(joinedload('volume_metadata')).\
                      options(joinedload('volume_type')).\
-                     filter_by(instance_id=instance_id).\
+                     filter_by(instance_uuid=instance_uuid).\
                      filter_by(deleted=False).\
                      all()
     if not result:
-        raise exception.VolumeNotFoundForInstance(instance_id=instance_id)
+        raise exception.VolumeNotFoundForInstance(instance_uuid=instance_uuid)
     return result
 
 
@@ -2557,7 +2534,7 @@
     session = get_session()
     with session.begin():
         result = session.query(models.BlockDeviceMapping).\
-                 filter_by(instance_id=values['instance_id']).\
+                 filter_by(instance_uuid=values['instance_uuid']).\
                  filter_by(device_name=values['device_name']).\
                  filter_by(deleted=False).\
                  first()
@@ -2574,7 +2551,7 @@
         if (virtual_name is not None and
             block_device.is_swap_or_ephemeral(virtual_name)):
             session.query(models.BlockDeviceMapping).\
-            filter_by(instance_id=values['instance_id']).\
+            filter_by(instance_uuid=values['instance_uuid']).\
             filter_by(virtual_name=virtual_name).\
             filter(models.BlockDeviceMapping.device_name !=
                    values['device_name']).\
@@ -2584,10 +2561,10 @@
 
 
 @require_context
-def block_device_mapping_get_all_by_instance(context, instance_id):
+def block_device_mapping_get_all_by_instance(context, instance_uuid):
     session = get_session()
     result = session.query(models.BlockDeviceMapping).\
-             filter_by(instance_id=instance_id).\
+             filter_by(instance_uuid=instance_uuid).\
              filter_by(deleted=False).\
              all()
     if not result:
@@ -2607,12 +2584,12 @@
 
 
 @require_context
-def block_device_mapping_destroy_by_instance_and_volume(context, instance_id,
+def block_device_mapping_destroy_by_instance_and_volume(context, instance_uuid,
                                                         volume_id):
     session = get_session()
     with session.begin():
         session.query(models.BlockDeviceMapping).\
-        filter_by(instance_id=instance_id).\
+        filter_by(instance_uuid=instance_uuid).\
         filter_by(volume_id=volume_id).\
         filter_by(deleted=False).\
         update({'deleted': True,
@@ -2684,13 +2661,13 @@
 
 
 @require_context
-def security_group_get_by_instance(context, instance_id):
+def security_group_get_by_instance(context, instance_uuid):
     session = get_session()
     return session.query(models.SecurityGroup).\
                    filter_by(deleted=False).\
                    options(joinedload_all('rules')).\
                    join(models.SecurityGroup.instances).\
-                   filter_by(id=instance_id).\
+                   filter_by(uuid=instance_uuid).\
                    filter_by(deleted=False).\
                    all()
 
@@ -3151,7 +3128,7 @@
                      filter_by(instance_uuid=instance_uuid).\
                      filter_by(status=status).first()
     if not result:
-        raise exception.MigrationNotFoundByStatus(instance_id=instance_uuid,
+        raise exception.MigrationNotFoundByStatus(instance_uuid=instance_uuid,
                                                   status=status)
     return result
 
@@ -3236,41 +3213,43 @@
                 delete()
 
 
-def console_get_by_pool_instance(context, pool_id, instance_id):
+def console_get_by_pool_instance(context, pool_id, instance_uuid):
     session = get_session()
     result = session.query(models.Console).\
                    filter_by(pool_id=pool_id).\
-                   filter_by(instance_id=instance_id).\
+                   filter_by(instance_uuid=instance_uuid).\
                    options(joinedload('pool')).\
                    first()
     if not result:
-        raise exception.ConsoleNotFoundInPoolForInstance(pool_id=pool_id,
-                                                 instance_id=instance_id)
+        params = {'pool_id': pool_id, 'instance_uuid': instance_uuid}
+        raise exception.ConsoleNotFoundInPoolForInstance(**params)
     return result
 
 
-def console_get_all_by_instance(context, instance_id):
+def console_get_all_by_instance(context, instance_uuid):
     session = get_session()
     results = session.query(models.Console).\
-                   filter_by(instance_id=instance_id).\
-                   options(joinedload('pool')).\
-                   all()
+                            filter_by(instance_uuid=instance_uuid).\
+                            options(joinedload('pool')).\
+                            all()
     return results
 
 
-def console_get(context, console_id, instance_id=None):
+def console_get(context, console_id, instance_uuid=None):
     session = get_session()
     query = session.query(models.Console).\
                     filter_by(id=console_id)
-    if instance_id:
-        query = query.filter_by(instance_id=instance_id)
+    if instance_uuid:
+        query = query.filter_by(instance_uuid=instance_uuid)
     result = query.options(joinedload('pool')).first()
     if not result:
-        if instance_id:
-            raise exception.ConsoleNotFoundForInstance(console_id=console_id,
-                                                       instance_id=instance_id)
-        else:
-            raise exception.ConsoleNotFound(console_id=console_id)
+        params = {'console_id': console_id}
+        if not instance_uuid:
+            raise exception.ConsoleNotFound(**params)
+
+        params['instance_uuid'] = instance_uuid
+        raise exception.ConsoleNotFoundForInstance(**params)
+
     return result
 
 
@@ -3473,11 +3452,11 @@
 
 @require_context
 @require_instance_exists
-def instance_metadata_get(context, instance_id):
+def instance_metadata_get(context, instance_uuid):
     session = get_session()
 
     meta_results = session.query(models.InstanceMetadata).\
-                    filter_by(instance_id=instance_id).\
+                    filter_by(instance_uuid=instance_uuid).\
                     filter_by(deleted=False).\
                     all()
 
@@ -3489,10 +3468,10 @@
 
 @require_context
 @require_instance_exists
-def instance_metadata_delete(context, instance_id, key):
+def instance_metadata_delete(context, instance_uuid, key):
     session = get_session()
     session.query(models.InstanceMetadata).\
-        filter_by(instance_id=instance_id).\
+        filter_by(instance_uuid=instance_uuid).\
         filter_by(key=key).\
         filter_by(deleted=False).\
         update({'deleted': True,
@@ -3502,10 +3481,10 @@
 
 @require_context
 @require_instance_exists
-def instance_metadata_delete_all(context, instance_id):
+def instance_metadata_delete_all(context, instance_uuid):
     session = get_session()
     session.query(models.InstanceMetadata).\
-        filter_by(instance_id=instance_id).\
+        filter_by(instance_uuid=instance_uuid).\
         filter_by(deleted=False).\
         update({'deleted': True,
                 'deleted_at': utils.utcnow(),
@@ -3514,33 +3493,33 @@
 
 @require_context
 @require_instance_exists
-def instance_metadata_get_item(context, instance_id, key, session=None):
+def instance_metadata_get_item(context, instance_uuid, key, session=None):
     if not session:
         session = get_session()
 
     meta_result = session.query(models.InstanceMetadata).\
-                    filter_by(instance_id=instance_id).\
+                    filter_by(instance_uuid=instance_uuid).\
                     filter_by(key=key).\
                     filter_by(deleted=False).\
                     first()
 
     if not meta_result:
         raise exception.InstanceMetadataNotFound(metadata_key=key,
-                                                 instance_id=instance_id)
+                                                 instance_uuid=instance_uuid)
     return meta_result
 
 
 @require_context
 @require_instance_exists
-def instance_metadata_update(context, instance_id, metadata, delete):
+def instance_metadata_update(context, instance_uuid, metadata, delete):
     session = get_session()
 
     # Set existing metadata to deleted if delete argument is True
     if delete:
-        original_metadata = instance_metadata_get(context, instance_id)
+        original_metadata = instance_metadata_get(context, instance_uuid)
         for meta_key, meta_value in original_metadata.iteritems():
             if meta_key not in metadata:
-                meta_ref = instance_metadata_get_item(context, instance_id,
+                meta_ref = instance_metadata_get_item(context, instance_uuid,
                                                       meta_key, session)
                 meta_ref.update({'deleted': True})
                 meta_ref.save(session=session)
@@ -3554,11 +3533,11 @@
         item = {"value": meta_value}
 
         try:
-            meta_ref = instance_metadata_get_item(context, instance_id,
+            meta_ref = instance_metadata_get_item(context, instance_uuid,
                                                   meta_key, session)
         except exception.InstanceMetadataNotFound, e:
             meta_ref = models.InstanceMetadata()
-            item.update({"key": meta_key, "instance_id": instance_id})
+            item.update({"key": meta_key, "instance_uuid": instance_uuid})
 
         meta_ref.update(item)
         meta_ref.save(session=session)

=== modified file 'nova/db/sqlalchemy/migrate_repo/versions/031_fk_fixed_ips_virtual_interface_id.py'
--- nova/db/sqlalchemy/migrate_repo/versions/031_fk_fixed_ips_virtual_interface_id.py	2011-06-30 19:20:59 +0000
+++ nova/db/sqlalchemy/migrate_repo/versions/031_fk_fixed_ips_virtual_interface_id.py	2011-09-22 19:29:25 +0000
@@ -23,7 +23,6 @@
 
 meta = MetaData()
 
-
 def upgrade(migrate_engine):
     meta.bind = migrate_engine
     dialect = migrate_engine.url.get_dialect().name

=== added file 'nova/db/sqlalchemy/migrate_repo/versions/050_renames_for_instance_uuids.py'
--- nova/db/sqlalchemy/migrate_repo/versions/050_renames_for_instance_uuids.py	1970-01-01 00:00:00 +0000
+++ nova/db/sqlalchemy/migrate_repo/versions/050_renames_for_instance_uuids.py	2011-09-22 19:29:25 +0000
@@ -0,0 +1,117 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import migrate
+import sqlalchemy
+
+from nova import utils
+
+
+meta = sqlalchemy.MetaData()
+
+
+table_names = [
+    'consoles',
+    'instance_actions',
+    'block_device_mapping',
+    'fixed_ips',
+    'security_group_instance_association',
+    'volumes',
+    'instance_metadata',
+    'virtual_interfaces',
+]
+
+
+skip_fk_tables = [
+    'virtual_interfaces',
+    'consoles',
+]
+
+
+def upgrade(migrate_engine):
+    """Upgrade database schema."""
+    meta.bind = migrate_engine
+
+    instances = sqlalchemy.Table('instances', meta, autoload=True)
+
+    sqlalchemy.Index('uuid_idx', instances.c.uuid).create(bind=migrate_engine)
+
+    mapping = {}
+    for instance in migrate_engine.execute(instances.select()):
+        mapping[instance.id] = instance.uuid or utils.gen_uuid()
+
+    for table_name in table_names:
+        # Load table definition
+        table = sqlalchemy.Table(table_name, meta, autoload=True)
+        instance_uuid_column = sqlalchemy.Column('instance_uuid',
+                                                 sqlalchemy.String(36))
+
+        # Add a new instance_uuid column
+        table.create_column(instance_uuid_column)
+
+        if table_name not in skip_fk_tables:
+            migrate.ForeignKeyConstraint([table.c.instance_uuid],
+                                         [instances.c.uuid]).create()
+
+        # Insert correct uuid data
+        for instance_id, instance_uuid in mapping.iteritems():
+            query = table.update().\
+                          where(table.c.instance_id == instance_id).\
+                          values(instance_uuid = instance_uuid)
+            migrate_engine.execute(query)
+
+        # Drop the old instance_id column
+        table.c.instance_id.drop()
+
+
+def downgrade(migrate_engine):
+    """Downgrade database schema."""
+    meta.bind = migrate_engine
+
+    instances = sqlalchemy.Table('instances', meta, autoload=True)
+
+    mapping = {}
+    for instance in migrate_engine.execute(instances.select()):
+        mapping[instance.uuid] = instance.id
+
+    for table_name in table_names:
+        # Load table definition
+        table = sqlalchemy.Table(table_name, meta, autoload=True)
+        instance_id_column = sqlalchemy.Column('instance_id',
+                                               sqlalchemy.Integer())
+
+        # Add a new instance_id column
+        table.create_column(instance_id_column)
+
+        # Insert correct uuid data
+        for instance_uuid, instance_id in mapping.iteritems():
+            query = table.update().\
+                          where(table.c.instance_uuid == instance_uuid).\
+                          values(instance_id = instance_id)
+            migrate_engine.execute(query)
+
+        if table_name not in skip_fk_tables:
+            migrate.ForeignKeyConstraint([table.c.instance_uuid],
+                                         [instances.c.uuid]).drop()
+
+        # Drop the old instance_id column
+        table.c.instance_uuid.drop()
+
+        if table_name not in skip_fk_tables:
+            migrate.ForeignKeyConstraint([table.c.instance_id],
+                                         [instances.c.id]).create()
+
+    sqlalchemy.Index('uuid_idx', instances.c.uuid).drop(bind=migrate_engine)

=== added file 'nova/db/sqlalchemy/migrate_repo/versions/050_sqlite_downgrade.sql'
--- nova/db/sqlalchemy/migrate_repo/versions/050_sqlite_downgrade.sql	1970-01-01 00:00:00 +0000
+++ nova/db/sqlalchemy/migrate_repo/versions/050_sqlite_downgrade.sql	2011-09-22 19:29:25 +0000
@@ -0,0 +1,266 @@
+BEGIN TRANSACTION;
+
+-- START consoles
+ALTER TABLE consoles RENAME TO consoles_backup;
+
+CREATE TABLE consoles (
+    created_at DATETIME,
+    updated_at DATETIME,
+    deleted_at DATETIME,
+    deleted BOOLEAN,
+    id INTEGER NOT NULL,
+    instance_name VARCHAR(255),
+    instance_id INTEGER,
+    password VARCHAR(255),
+    port INTEGER,
+    pool_id INTEGER,
+    PRIMARY KEY (id),
+    FOREIGN KEY(pool_id) REFERENCES console_pools (id),
+    CHECK (deleted IN (0, 1))
+);
+
+INSERT INTO consoles
+    SELECT * FROM consoles_backup;
+
+UPDATE consoles
+    SET instance_uuid = (
+        SELECT id FROM instances WHERE uuid = consoles.instance_id
+    );
+
+DROP TABLE consoles_backup;
+-- END consoles
+
+
+-- START instance_actions
+ALTER TABLE instance_actions RENAME TO instance_actions_backup;
+
+CREATE TABLE instance_actions (
+    created_at DATETIME, 
+    updated_at DATETIME, 
+    deleted_at DATETIME, 
+    deleted BOOLEAN, 
+    id INTEGER NOT NULL, 
+    instance_id INTEGER,
+    action VARCHAR(255), 
+    error TEXT, 
+    PRIMARY KEY (id), 
+    FOREIGN KEY(instance_id) REFERENCES instances (id), 
+    CHECK (deleted IN (0, 1))
+);
+
+INSERT INTO instance_actions
+    SELECT * FROM instance_actions_backup;
+
+UPDATE instance_actions 
+    SET instance_id = (
+        SELECT id FROM instances WHERE uuid = instance_actions.instance_id
+    );
+
+DROP TABLE instance_actions_backup;
+-- END instance_actions
+
+
+-- START fixed_ips
+ALTER TABLE fixed_ips RENAME TO fixed_ips_backup;
+
+CREATE TABLE fixed_ips (
+    id INTEGER NOT NULL,
+    address VARCHAR(255),
+    virtual_interface_id INTEGER,
+    network_id INTEGER,
+    instance_id INTEGER,
+    allocated BOOLEAN default FALSE,
+    leased BOOLEAN default FALSE,
+    reserved BOOLEAN default FALSE,
+    created_at DATETIME NOT NULL,
+    updated_at DATETIME,
+    deleted_at DATETIME,
+    deleted BOOLEAN NOT NULL, host VARCHAR(255),
+    PRIMARY KEY (id),
+    FOREIGN KEY(instance_id) REFERENCES instances (id),
+    FOREIGN KEY(virtual_interface_id) REFERENCES virtual_interfaces (id),
+    CHECK (deleted IN (0, 1))
+);
+
+INSERT INTO fixed_ips
+    SELECT * FROM fixed_ips_backup;
+
+UPDATE fixed_ips 
+    SET instance_id = (
+        SELECT id FROM instances WHERE uuid = fixed_ips.instance_id
+    );
+
+DROP TABLE fixed_ips_backup;
+-- END fixed_ips
+
+
+-- START security_group_instance_association
+ALTER TABLE security_group_instance_association 
+    RENAME TO security_group_instance_association_backup;
+
+CREATE TABLE security_group_instance_association (
+    id INTEGER NOT NULL, 
+    security_group_id INTEGER, 
+    instance_id INTEGER, 
+    created_at DATETIME, 
+    updated_at DATETIME, 
+    deleted_at DATETIME, 
+    deleted BOOLEAN, 
+    PRIMARY KEY (id), 
+    FOREIGN KEY(instance_id) REFERENCES instances (id), 
+    FOREIGN KEY(security_group_id) REFERENCES security_groups (id), 
+    CHECK (deleted IN (0, 1))
+);
+
+INSERT INTO security_group_instance_association
+    SELECT * FROM security_group_instance_association_backup;
+
+UPDATE security_group_instance_association
+    SET instance_id = (
+        SELECT id FROM instances WHERE uuid = security_group_instance_association.instance_id
+    );
+
+DROP TABLE security_group_instance_association_backup;
+-- END security_group_instance_association
+
+
+-- START volumes
+ALTER TABLE volumes RENAME TO volumes_backup;
+
+CREATE TABLE volumes (
+    created_at DATETIME, 
+    updated_at DATETIME, 
+    deleted_at DATETIME, 
+    deleted BOOLEAN, 
+    id INTEGER NOT NULL, 
+    ec2_id VARCHAR(255), 
+    user_id VARCHAR(255), 
+    project_id VARCHAR(255), 
+    host VARCHAR(255), 
+    size INTEGER, 
+    availability_zone VARCHAR(255), 
+    instance_id INTEGER,
+    mountpoint VARCHAR(255), 
+    attach_time VARCHAR(255), 
+    status VARCHAR(255), 
+    attach_status VARCHAR(255), 
+    scheduled_at DATETIME, 
+    launched_at DATETIME, 
+    terminated_at DATETIME, 
+    display_name VARCHAR(255), 
+    display_description VARCHAR(255), 
+    provider_location VARCHAR(256), 
+    provider_auth VARCHAR(256), 
+    snapshot_id INTEGER, 
+    volume_type_id INTEGER, 
+    PRIMARY KEY (id), 
+    FOREIGN KEY(instance_id) REFERENCES instances (id), 
+    CHECK (deleted IN (0, 1))
+);
+
+INSERT INTO volumes SELECT * FROM volumes_backup;
+
+UPDATE volumes
+    SET instance_id = (
+        SELECT id FROM instances WHERE uuid = volumes.instance_id
+    );
+
+DROP TABLE volumes_backup;
+-- END volumes
+
+
+-- START block_device_mapping
+ALTER TABLE block_device_mapping RENAME TO block_device_mapping_backup;
+
+CREATE TABLE block_device_mapping (
+    created_at DATETIME, 
+    updated_at DATETIME, 
+    deleted_at DATETIME, 
+    deleted BOOLEAN, 
+    id INTEGER NOT NULL, 
+    instance_id INTEGER NOT NULL, 
+    device_name VARCHAR(255) NOT NULL, 
+    delete_on_termination BOOLEAN, 
+    virtual_name VARCHAR(255), 
+    snapshot_id INTEGER, 
+    volume_id INTEGER, 
+    volume_size INTEGER, 
+    no_device BOOLEAN, 
+    PRIMARY KEY (id), 
+    FOREIGN KEY(snapshot_id) REFERENCES snapshots (id), 
+    FOREIGN KEY(volume_id) REFERENCES volumes (id), 
+    FOREIGN KEY(instance_id) REFERENCES instances (id), 
+    CHECK (delete_on_termination IN (0, 1)), 
+    CHECK (deleted IN (0, 1)), 
+    CHECK (no_device IN (0, 1))
+);
+
+INSERT INTO block_device_mapping SELECT * FROM block_device_mapping_backup;
+
+UPDATE block_device_mapping
+    SET instance_id = (
+        SELECT id FROM instances WHERE uuid = block_device_mapping.instance_id
+    );
+
+DROP TABLE block_device_mapping_backup;
+-- END block_device_mapping
+
+
+-- START virtual_interfaces
+ALTER TABLE virtual_interfaces RENAME TO virtual_interfaces_backup;
+
+CREATE TABLE virtual_interfaces (
+    created_at DATETIME, 
+    updated_at DATETIME, 
+    deleted_at DATETIME, 
+    deleted BOOLEAN, 
+    id INTEGER NOT NULL, 
+    address VARCHAR(255), 
+    network_id INTEGER, 
+    instance_id INTEGER,
+    uuid VARCHAR(36), 
+    PRIMARY KEY (id), 
+    FOREIGN KEY(network_id) REFERENCES networks (id), 
+    UNIQUE (address), 
+    CHECK (deleted IN (0, 1))
+);
+
+INSERT INTO virtual_interfaces SELECT * FROM virtual_interfaces_backup;
+
+UPDATE virtual_interfaces
+    SET instance_id = (
+        SELECT id FROM instances WHERE uuid = virtual_interfaces.instance_id
+    );
+
+DROP TABLE virtual_interfaces_backup;
+-- END virtual_interfaces
+
+
+-- START instance_metadata
+ALTER TABLE instance_metadata RENAME TO instance_metadata_backup;
+
+CREATE TABLE instance_metadata (
+    created_at DATETIME, 
+    updated_at DATETIME, 
+    deleted_at DATETIME, 
+    deleted BOOLEAN, 
+    id INTEGER NOT NULL, 
+    instance_id INTEGER,
+    key VARCHAR(255), 
+    value VARCHAR(255), 
+    PRIMARY KEY (id), 
+    FOREIGN KEY(instance_id) REFERENCES instances (id), 
+    CHECK (deleted IN (0, 1))
+);
+
+INSERT INTO instance_metadata SELECT * FROM instance_metadata_backup;
+
+UPDATE instance_metadata
+    SET instance_id = (
+        SELECT id FROM instances WHERE uuid = instance_metadata.instance_id
+    );
+
+DROP TABLE instance_metadata_backup;
+-- END instance_metadata
+
+COMMIT;

=== added file 'nova/db/sqlalchemy/migrate_repo/versions/050_sqlite_upgrade.sql'
--- nova/db/sqlalchemy/migrate_repo/versions/050_sqlite_upgrade.sql	1970-01-01 00:00:00 +0000
+++ nova/db/sqlalchemy/migrate_repo/versions/050_sqlite_upgrade.sql	2011-09-22 19:29:25 +0000
@@ -0,0 +1,265 @@
+BEGIN TRANSACTION;
+
+-- START consoles
+ALTER TABLE consoles RENAME TO consoles_backup;
+
+CREATE TABLE consoles (
+    created_at DATETIME, 
+    updated_at DATETIME, 
+    deleted_at DATETIME, 
+    deleted BOOLEAN, 
+    id INTEGER NOT NULL, 
+    instance_name VARCHAR(255), 
+    instance_uuid VARCHAR(36), 
+    password VARCHAR(255), 
+    port INTEGER, 
+    pool_id INTEGER, 
+    PRIMARY KEY (id), 
+    FOREIGN KEY(pool_id) REFERENCES console_pools (id), 
+    CHECK (deleted IN (0, 1))
+);
+
+INSERT INTO consoles
+    SELECT * FROM consoles_backup;
+
+UPDATE consoles
+    SET instance_uuid = (
+        SELECT uuid FROM instances WHERE id = consoles.instance_uuid
+    );
+
+DROP TABLE consoles_backup;
+-- END consoles
+
+-- START instance_actions
+ALTER TABLE instance_actions RENAME TO instance_actions_backup;
+
+CREATE TABLE instance_actions (
+    created_at DATETIME, 
+    updated_at DATETIME, 
+    deleted_at DATETIME, 
+    deleted BOOLEAN, 
+    id INTEGER NOT NULL, 
+    instance_uuid VARCHAR(36), 
+    action VARCHAR(255), 
+    error TEXT, 
+    PRIMARY KEY (id), 
+    FOREIGN KEY(instance_uuid) REFERENCES instances (uuid), 
+    CHECK (deleted IN (0, 1))
+);
+
+INSERT INTO instance_actions
+    SELECT * FROM instance_actions_backup;
+
+UPDATE instance_actions 
+    SET instance_uuid = (
+        SELECT uuid FROM instances WHERE id = instance_actions.instance_uuid
+    );
+
+DROP TABLE instance_actions_backup;
+-- END instance_actions
+
+
+-- START fixed_ips
+ALTER TABLE fixed_ips RENAME TO fixed_ips_backup;
+
+CREATE TABLE fixed_ips (
+    id INTEGER NOT NULL,
+    address VARCHAR(255),
+    virtual_interface_id INTEGER,
+    network_id INTEGER,
+    instance_uuid VARCHAR(255),
+    allocated BOOLEAN default FALSE,
+    leased BOOLEAN default FALSE,
+    reserved BOOLEAN default FALSE,
+    created_at DATETIME NOT NULL,
+    updated_at DATETIME,
+    deleted_at DATETIME,
+    deleted BOOLEAN NOT NULL, host VARCHAR(255),
+    PRIMARY KEY (id),
+    FOREIGN KEY(instance_uuid) REFERENCES instances (uuid),
+    FOREIGN KEY(virtual_interface_id) REFERENCES virtual_interfaces (id),
+    CHECK (deleted IN (0, 1))
+);
+
+INSERT INTO fixed_ips
+    SELECT * FROM fixed_ips_backup;
+
+UPDATE fixed_ips 
+    SET instance_uuid = (
+        SELECT uuid FROM instances WHERE id = fixed_ips.instance_uuid
+    );
+
+DROP TABLE fixed_ips_backup;
+-- END fixed_ips
+
+
+-- START security_group_instance_association
+ALTER TABLE security_group_instance_association 
+    RENAME TO security_group_instance_association_backup;
+
+CREATE TABLE security_group_instance_association (
+    id INTEGER NOT NULL, 
+    security_group_id INTEGER, 
+    instance_uuid VARCHAR(36), 
+    created_at DATETIME, 
+    updated_at DATETIME, 
+    deleted_at DATETIME, 
+    deleted BOOLEAN, 
+    PRIMARY KEY (id), 
+    FOREIGN KEY(instance_uuid) REFERENCES instances (uuid), 
+    FOREIGN KEY(security_group_id) REFERENCES security_groups (id), 
+    CHECK (deleted IN (0, 1))
+);
+
+INSERT INTO security_group_instance_association
+    SELECT * FROM security_group_instance_association_backup;
+
+UPDATE security_group_instance_association
+    SET instance_uuid = (
+        SELECT uuid FROM instances WHERE id = security_group_instance_association.instance_uuid
+    );
+
+DROP TABLE security_group_instance_association_backup;
+-- END security_group_instance_association
+
+
+-- START volumes
+ALTER TABLE volumes RENAME TO volumes_backup;
+
+CREATE TABLE volumes (
+    created_at DATETIME, 
+    updated_at DATETIME, 
+    deleted_at DATETIME, 
+    deleted BOOLEAN, 
+    id INTEGER NOT NULL, 
+    ec2_id VARCHAR(255), 
+    user_id VARCHAR(255), 
+    project_id VARCHAR(255), 
+    host VARCHAR(255), 
+    size INTEGER, 
+    availability_zone VARCHAR(255), 
+    instance_uuid VARCHAR(36),
+    mountpoint VARCHAR(255), 
+    attach_time VARCHAR(255), 
+    status VARCHAR(255), 
+    attach_status VARCHAR(255), 
+    scheduled_at DATETIME, 
+    launched_at DATETIME, 
+    terminated_at DATETIME, 
+    display_name VARCHAR(255), 
+    display_description VARCHAR(255), 
+    provider_location VARCHAR(256), 
+    provider_auth VARCHAR(256), 
+    snapshot_id INTEGER, 
+    volume_type_id INTEGER, 
+    PRIMARY KEY (id), 
+    FOREIGN KEY(instance_uuid) REFERENCES instances (uuid), 
+    CHECK (deleted IN (0, 1))
+);
+
+INSERT INTO volumes SELECT * FROM volumes_backup;
+
+UPDATE volumes
+    SET instance_uuid = (
+        SELECT uuid FROM instances WHERE id = volumes.instance_uuid
+    );
+
+DROP TABLE volumes_backup;
+-- END volumes
+
+
+-- START block_device_mapping
+ALTER TABLE block_device_mapping RENAME TO block_device_mapping_backup;
+
+CREATE TABLE block_device_mapping (
+    created_at DATETIME, 
+    updated_at DATETIME, 
+    deleted_at DATETIME, 
+    deleted BOOLEAN, 
+    id INTEGER NOT NULL, 
+    instance_uuid VARCHAR(36) NOT NULL, 
+    device_name VARCHAR(255) NOT NULL, 
+    delete_on_termination BOOLEAN, 
+    virtual_name VARCHAR(255), 
+    snapshot_id INTEGER, 
+    volume_id INTEGER, 
+    volume_size INTEGER, 
+    no_device BOOLEAN, 
+    PRIMARY KEY (id), 
+    FOREIGN KEY(snapshot_id) REFERENCES snapshots (id), 
+    FOREIGN KEY(volume_id) REFERENCES volumes (id), 
+    FOREIGN KEY(instance_uuid) REFERENCES instances (uuid), 
+    CHECK (delete_on_termination IN (0, 1)), 
+    CHECK (deleted IN (0, 1)), 
+    CHECK (no_device IN (0, 1))
+);
+
+INSERT INTO block_device_mapping SELECT * FROM block_device_mapping_backup;
+
+UPDATE block_device_mapping
+    SET instance_uuid = (
+        SELECT uuid FROM instances WHERE id = block_device_mapping.instance_uuid
+    );
+
+DROP TABLE block_device_mapping_backup;
+-- END block_device_mapping
+
+
+-- START virtual_interfaces
+ALTER TABLE virtual_interfaces RENAME TO virtual_interfaces_backup;
+
+CREATE TABLE virtual_interfaces (
+    created_at DATETIME, 
+    updated_at DATETIME, 
+    deleted_at DATETIME, 
+    deleted BOOLEAN, 
+    id INTEGER NOT NULL, 
+    address VARCHAR(255), 
+    network_id INTEGER, 
+    instance_uuid VARCHAR(36),
+    uuid VARCHAR(36), 
+    PRIMARY KEY (id), 
+    FOREIGN KEY(network_id) REFERENCES networks (id), 
+    UNIQUE (address), 
+    CHECK (deleted IN (0, 1))
+);
+
+INSERT INTO virtual_interfaces SELECT * FROM virtual_interfaces_backup;
+
+UPDATE virtual_interfaces
+    SET instance_uuid = (
+        SELECT uuid FROM instances WHERE id = virtual_interfaces.instance_uuid
+    );
+
+DROP TABLE virtual_interfaces_backup;
+-- END virtual_interfaces
+
+
+-- START instance_metadata
+ALTER TABLE instance_metadata RENAME TO instance_metadata_backup;
+
+CREATE TABLE instance_metadata (
+    created_at DATETIME, 
+    updated_at DATETIME, 
+    deleted_at DATETIME, 
+    deleted BOOLEAN, 
+    id INTEGER NOT NULL, 
+    instance_uuid VARCHAR(36),
+    key VARCHAR(255), 
+    value VARCHAR(255), 
+    PRIMARY KEY (id), 
+    FOREIGN KEY(instance_uuid) REFERENCES instances (uuid), 
+    CHECK (deleted IN (0, 1))
+);
+
+INSERT INTO instance_metadata SELECT * FROM instance_metadata_backup;
+
+UPDATE instance_metadata
+    SET instance_uuid = (
+        SELECT uuid FROM instances WHERE id = instance_metadata.instance_uuid
+    );
+
+DROP TABLE instance_metadata_backup;
+-- END instance_metadata
+
+COMMIT;

=== modified file 'nova/db/sqlalchemy/migration.py'