Merged trunk

3 files changed, 72 insertions, 48 deletions

diff --git a/nova/compute/api.py b/nova/compute/api.py
index acafc7760..9994e5724 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -467,10 +467,10 @@ class API(base.Base):
 
         return [dict(x.iteritems()) for x in instances]
 
-    def has_finished_migration(self, context, instance_id):
+    def has_finished_migration(self, context, instance_uuid):
         """Returns true if an instance has a finished migration."""
         try:
-            db.migration_get_by_instance_and_status(context, instance_id,
+            db.migration_get_by_instance_and_status(context, instance_uuid,
                     'finished')
             return True
         except exception.NotFound:
@@ -868,39 +868,50 @@ class API(base.Base):
                                    instance_id,
                                    params=rebuild_params)
 
+    @scheduler_api.reroute_compute("revert_resize")
     def revert_resize(self, context, instance_id):
         """Reverts a resize, deleting the 'new' instance in the process."""
         context = context.elevated()
+        instance_ref = self._get_instance(context, instance_id,
+                'revert_resize')
         migration_ref = self.db.migration_get_by_instance_and_status(context,
-                instance_id, 'finished')
+                instance_ref['uuid'], 'finished')
         if not migration_ref:
             raise exception.MigrationNotFoundByStatus(instance_id=instance_id,
                                                       status='finished')
 
         params = {'migration_id': migration_ref['id']}
-        self._cast_compute_message('revert_resize', context, instance_id,
-                migration_ref['dest_compute'], params=params)
+        self._cast_compute_message('revert_resize', context,
+                                   instance_ref['uuid'],
+                                   migration_ref['source_compute'],
+                                   params=params)
+
         self.db.migration_update(context, migration_ref['id'],
                 {'status': 'reverted'})
 
+    @scheduler_api.reroute_compute("confirm_resize")
     def confirm_resize(self, context, instance_id):
         """Confirms a migration/resize and deletes the 'old' instance."""
         context = context.elevated()
+        instance_ref = self._get_instance(context, instance_id,
+                'confirm_resize')
         migration_ref = self.db.migration_get_by_instance_and_status(context,
-                instance_id, 'finished')
+                instance_ref['uuid'], 'finished')
         if not migration_ref:
             raise exception.MigrationNotFoundByStatus(instance_id=instance_id,
                                                       status='finished')
-        instance_ref = self.db.instance_get(context, instance_id)
         params = {'migration_id': migration_ref['id']}
-        self._cast_compute_message('confirm_resize', context, instance_id,
-                migration_ref['source_compute'], params=params)
+        self._cast_compute_message('confirm_resize', context,
+                                   instance_ref['uuid'],
+                                   migration_ref['dest_compute'],
+                                   params=params)
 
         self.db.migration_update(context, migration_ref['id'],
                 {'status': 'confirmed'})
         self.db.instance_update(context, instance_id,
                 {'host': migration_ref['dest_compute'], })
 
+    @scheduler_api.reroute_compute("resize")
     def resize(self, context, instance_id, flavor_id=None):
         """Resize (ie, migrate) a running instance.
 
@@ -908,8 +919,8 @@ class API(base.Base):
         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 = self.db.instance_get(context, instance_id)
-        current_instance_type = instance['instance_type']
+        instance_ref = self._get_instance(context, instance_id, 'resize')
+        current_instance_type = instance_ref['instance_type']
 
         # If flavor_id is not provided, only migrate the instance.
         if not flavor_id:
@@ -937,10 +948,11 @@ class API(base.Base):
             raise exception.ApiError(_("Invalid flavor: cannot use"
                     "the same flavor. "))
 
+        instance_ref = self._get_instance(context, instance_id, 'resize')
         self._cast_scheduler_message(context,
                     {"method": "prep_resize",
                      "args": {"topic": FLAGS.compute_topic,
-                              "instance_id": instance_id,
+                              "instance_id": instance_ref['uuid'],
                               "flavor_id": new_instance_type['id']}})
 
     @scheduler_api.reroute_compute("add_fixed_ip")
diff --git a/nova/compute/instance_types.py b/nova/compute/instance_types.py
index 1d246e445..c13a629a9 100644
--- a/nova/compute/instance_types.py
+++ b/nova/compute/instance_types.py
@@ -112,7 +112,7 @@ def get_instance_type(id):
         return get_default_instance_type()
     try:
         ctxt = context.get_admin_context()
-        return db.instance_type_get_by_id(ctxt, id)
+        return db.instance_type_get(ctxt, id)
     except exception.DBError:
         raise exception.ApiError(_("Unknown instance type: %s") % id)
 
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index e60781c6d..aeecdecfa 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -91,6 +91,10 @@ 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
         LOG.info(_("check_instance_lock: decorating: |%s|"), function,
                  context=context)
         LOG.info(_("check_instance_lock: arguments: |%(self)s| |%(context)s|"
@@ -682,8 +686,9 @@ class ComputeManager(manager.SchedulerDependentManager):
     @checks_instance_lock
     def confirm_resize(self, context, instance_id, migration_id):
         """Destroys the source instance."""
-        context = context.elevated()
-        instance_ref = self.db.instance_get(context, instance_id)
+        migration_ref = self.db.migration_get(context, migration_id)
+        instance_ref = self.db.instance_get_by_uuid(context,
+                migration_ref.instance_uuid)
 
         network_info = self._get_instance_nw_info(context, instance_ref)
         self.driver.destroy(instance_ref, network_info)
@@ -702,8 +707,9 @@ class ComputeManager(manager.SchedulerDependentManager):
         source machine.
 
         """
-        instance_ref = self.db.instance_get(context, instance_id)
         migration_ref = self.db.migration_get(context, migration_id)
+        instance_ref = self.db.instance_get_by_uuid(context,
+                migration_ref.instance_uuid)
 
         network_info = self._get_instance_nw_info(context, instance_ref)
         self.driver.destroy(instance_ref, network_info)
@@ -711,9 +717,7 @@ class ComputeManager(manager.SchedulerDependentManager):
                 instance_ref['host'])
         rpc.cast(context, topic,
                 {'method': 'finish_revert_resize',
-                 'args': {
-                       'migration_id': migration_ref['id'],
-                       'instance_id': instance_id, },
+                 'args': {'migration_id': migration_ref['id']},
                 })
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
@@ -725,14 +729,16 @@ class ComputeManager(manager.SchedulerDependentManager):
         in the database.
 
         """
-        instance_ref = self.db.instance_get(context, instance_id)
         migration_ref = self.db.migration_get(context, migration_id)
+        instance_ref = self.db.instance_get_by_uuid(context,
+                migration_ref.instance_uuid)
+
         instance_type = self.db.instance_type_get_by_flavor_id(context,
                 migration_ref['old_flavor_id'])
 
         # Just roll back the record. There's no need to resize down since
         # the 'old' VM already has the preferred attributes
-        self.db.instance_update(context, instance_id,
+        self.db.instance_update(context, instance_ref['uuid'],
            dict(memory_mb=instance_type['memory_mb'],
                 vcpus=instance_type['vcpus'],
                 local_gb=instance_type['local_gb'],
@@ -756,17 +762,23 @@ class ComputeManager(manager.SchedulerDependentManager):
 
         """
         context = context.elevated()
-        instance_ref = self.db.instance_get(context, instance_id)
+
+        # 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)
 
         if instance_ref['host'] == FLAGS.host:
             raise exception.Error(_(
                     'Migration error: destination same as source!'))
 
-        old_instance_type = self.db.instance_type_get_by_id(context,
+        old_instance_type = self.db.instance_type_get(context,
                 instance_ref['instance_type_id'])
+        new_instance_type = self.db.instance_type_get_by_flavor_id(context,
+                flavor_id)
 
         migration_ref = self.db.migration_create(context,
-                {'instance_id': instance_id,
+                {'instance_uuid': instance_ref['uuid'],
                  'source_compute': instance_ref['host'],
                  'dest_compute': FLAGS.host,
                  'dest_host':   self.driver.get_host_ip_addr(),
@@ -774,22 +786,18 @@ class ComputeManager(manager.SchedulerDependentManager):
                  'new_flavor_id': flavor_id,
                  'status':      'pre-migrating'})
 
-        LOG.audit(_('instance %s: migrating to '), instance_id,
+        LOG.audit(_('instance %s: migrating'), instance_ref['uuid'],
                 context=context)
         topic = self.db.queue_get_for(context, FLAGS.compute_topic,
                 instance_ref['host'])
         rpc.cast(context, topic,
                 {'method': 'resize_instance',
-                 'args': {
-                       'migration_id': migration_ref['id'],
-                       'instance_id': instance_id, },
-                })
+                 'args': {'instance_id': instance_ref['uuid'],
+                          'migration_id': migration_ref['id']}})
 
-        instance_type = self.db.instance_type_get_by_flavor_id(context,
-                flavor_id)
         usage_info = utils.usage_from_instance(instance_ref,
-                              new_instance_type=instance_type['name'],
-                              new_instance_type_id=instance_type['id'])
+                              new_instance_type=new_instance_type['name'],
+                              new_instance_type_id=new_instance_type['id'])
         notifier.notify('compute.%s' % self.host,
                             'compute.instance.resize.prep',
                             notifier.INFO,
@@ -800,7 +808,9 @@ class ComputeManager(manager.SchedulerDependentManager):
     def resize_instance(self, context, instance_id, 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(context, instance_id)
+        instance_ref = self.db.instance_get_by_uuid(context,
+                migration_ref.instance_uuid)
+
         self.db.migration_update(context,
                                  migration_id,
                                  {'status': 'migrating'})
@@ -816,10 +826,11 @@ class ComputeManager(manager.SchedulerDependentManager):
         topic = self.db.queue_get_for(context,
                                       FLAGS.compute_topic,
                                       migration_ref['dest_compute'])
+        params = {'migration_id': migration_id,
+                  'disk_info': disk_info,
+                  'instance_id': instance_ref['uuid']}
         rpc.cast(context, topic, {'method': 'finish_resize',
-                                  'args': {'migration_id': migration_id,
-                                           'instance_id': instance_id,
-                                           'disk_info': disk_info}})
+                                  'args': params})
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
     @checks_instance_lock
@@ -831,23 +842,20 @@ class ComputeManager(manager.SchedulerDependentManager):
 
         """
         migration_ref = self.db.migration_get(context, migration_id)
-        instance_ref = self.db.instance_get(context,
-                migration_ref['instance_id'])
-        # TODO(mdietz): apply the rest of the instance_type attributes going
-        # after they're supported
+        instance_ref = self.db.instance_get_by_uuid(context,
+                migration_ref.instance_uuid)
         instance_type = self.db.instance_type_get_by_flavor_id(context,
                 migration_ref['new_flavor_id'])
-        self.db.instance_update(context, instance_id,
+        self.db.instance_update(context, instance_ref.uuid,
                dict(instance_type_id=instance_type['id'],
                     memory_mb=instance_type['memory_mb'],
                     vcpus=instance_type['vcpus'],
                     local_gb=instance_type['local_gb']))
 
-        # reload the updated instance ref
-        # FIXME(mdietz): is there reload functionality?
-        instance = self.db.instance_get(context, instance_id)
-        network_info = self._get_instance_nw_info(context, instance)
-        self.driver.finish_resize(instance, disk_info, network_info)
+        instance_ref = self.db.instance_get_by_uuid(context,
+                                            instance_ref.uuid)
+        network_info = self._get_instance_nw_info(context, instance_ref)
+        self.driver.finish_resize(instance_ref, disk_info, network_info)
 
         self.db.migration_update(context, migration_id,
                 {'status': 'finished', })
@@ -979,7 +987,11 @@ class ComputeManager(manager.SchedulerDependentManager):
         context = context.elevated()
         LOG.debug(_('instance %s: getting locked state'), instance_id,
                   context=context)
-        instance_ref = self.db.instance_get(context, instance_id)
+        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']
 
     @checks_instance_lock