snapshot/backup in compute manager to use uuids

Related to blueprint internal-uuids. Changes shapshot in the computer manager to
expect uuids instead of ids. Also updates some compute api fakes.

Change-Id: I525754ea065c7df9dfe1d093e4c94c02bebf4c02

2 files changed, 20 insertions, 15 deletions

diff --git a/nova/compute/api.py b/nova/compute/api.py
index 5c7ed9ba3..9384ed26f 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -1053,7 +1053,10 @@ class API(base.Base):
             instance = self.get(context, instance_id)
             host = instance['host']
         queue = self.db.queue_get_for(context, FLAGS.compute_topic, host)
-        params['instance_id'] = instance_id
+        if utils.is_uuid_like(instance_id):
+            params['instance_uuid'] = instance_id
+        else:
+            params['instance_id'] = instance_id
         kwargs = {'method': method, 'args': params}
         rpc.cast(context, queue, kwargs)
 
@@ -1072,7 +1075,10 @@ class API(base.Base):
             instance = self.get(context, instance_id)
             host = instance['host']
         queue = self.db.queue_get_for(context, FLAGS.compute_topic, host)
-        params['instance_id'] = instance_id
+        if utils.is_uuid_like(instance_id):
+            params['instance_uuid'] = instance_id
+        else:
+            params['instance_id'] = instance_id
         kwargs = {'method': method, 'args': params}
         return rpc.call(context, queue, kwargs)
 
@@ -1136,15 +1142,15 @@ class API(base.Base):
 
         """
         task_state = instance["task_state"]
-        instance_id = instance['id']
+        instance_uuid = instance['uuid']
 
         if task_state == task_states.IMAGE_BACKUP:
-            raise exception.InstanceBackingUp(instance_id=instance_id)
+            raise exception.InstanceBackingUp(instance_uuid=instance_uuid)
 
         if task_state == task_states.IMAGE_SNAPSHOT:
-            raise exception.InstanceSnapshotting(instance_id=instance_id)
+            raise exception.InstanceSnapshotting(instance_uuid=instance_uuid)
 
-        properties = {'instance_uuid': instance['uuid'],
+        properties = {'instance_uuid': instance_uuid,
                       'user_id': str(context.user_id),
                       'image_state': 'creating',
                       'image_type': image_type,
@@ -1155,7 +1161,7 @@ class API(base.Base):
         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
 
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index dd3ab74af..0e9893854 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -715,13 +715,13 @@ class ComputeManager(manager.SchedulerDependentManager):
                               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.Uuid
         :param image_id: glance.db.sqlalchemy.models.Image.Id
         :param image_type: snapshot | backup
         :param backup_type: daily | weekly
@@ -736,33 +736,32 @@ class ComputeManager(manager.SchedulerDependentManager):
             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_by_uuid(context, instance_uuid)
 
         current_power_state = self._get_power_state(context, instance_ref)
         self._instance_update(context,
-                              instance_id,
+                              instance_ref['id'],
                               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_ref['id'], task_state=None)
 
         if image_type == 'snapshot' and rotation:
             raise exception.ImageRotationNotAllowed()
 
         elif image_type == 'backup' and rotation:
-            instance_uuid = instance_ref['uuid']
             self.rotate_backups(context, instance_uuid, backup_type, rotation)
 
         elif image_type == 'backup':