Merge "Use instance uuids for consoles and diagnostics."

4 files changed, 42 insertions, 40 deletions

diff --git a/nova/compute/api.py b/nova/compute/api.py
index b276ecf7a..3b8944c6f 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -1053,8 +1053,7 @@ class API(base.Base):
         kwargs = {'method': method, 'args': params}
         rpc.cast(context, queue, kwargs)
 
-    def _call_compute_message(self, method, context, instance_id, host=None,
-                              params=None):
+    def _call_compute_message(self, method, context, instance, params=None):
         """Generic handler for RPC calls to compute.
 
         :param params: Optional dictionary of arguments to be passed to the
@@ -1064,14 +1063,9 @@ class API(base.Base):
         """
         if not params:
             params = {}
-        if not host:
-            instance = self.get(context, instance_id)
-            host = instance['host']
+        host = instance['host']
         queue = self.db.queue_get_for(context, FLAGS.compute_topic, host)
-        if utils.is_uuid_like(instance_id):
-            params['instance_uuid'] = instance_id
-        else:
-            params['instance_id'] = instance_id
+        params['instance_uuid'] = instance['uuid']
         kwargs = {'method': method, 'args': params}
         return rpc.call(context, queue, kwargs)
 
@@ -1385,7 +1379,7 @@ class API(base.Base):
         """Retrieve diagnostics for the given instance."""
         return self._call_compute_message("get_diagnostics",
                                           context,
-                                          instance['id'])
+                                          instance)
 
     def get_actions(self, context, instance):
         """Retrieve actions for the given instance."""
@@ -1467,7 +1461,7 @@ class API(base.Base):
         """Get a url to an AJAX Console."""
         output = self._call_compute_message('get_ajax_console',
                                             context,
-                                            instance['id'])
+                                            instance)
         rpc.cast(context, '%s' % FLAGS.ajax_console_proxy_topic,
                  {'method': 'authorize_ajax_console',
                   'args': {'token': output['token'], 'host': output['host'],
@@ -1479,7 +1473,7 @@ class API(base.Base):
         """Get a url to a VNC Console."""
         output = self._call_compute_message('get_vnc_console',
                                             context,
-                                            instance['id'])
+                                            instance)
         rpc.call(context, '%s' % FLAGS.vncproxy_topic,
                  {'method': 'authorize_vnc_console',
                   'args': {'token': output['token'],
@@ -1495,10 +1489,9 @@ class API(base.Base):
 
     def get_console_output(self, context, instance):
         """Get console output for an an instance."""
-        instance_id = instance['id']
         return self._call_compute_message('get_console_output',
                                           context,
-                                          instance_id)
+                                          instance)
 
     def lock(self, context, instance):
         """Lock the given instance."""
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 7cd76f35d..e924c9f9b 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -1262,11 +1262,11 @@ class ComputeManager(manager.SchedulerDependentManager):
         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_by_uuid(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)
 
@@ -1353,29 +1353,29 @@ class ComputeManager(manager.SchedulerDependentManager):
         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_by_uuid(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_by_uuid(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_by_uuid(context, instance_uuid)
         return self.driver.get_vnc_console(instance_ref)
 
     def _attach_volume_boot(self, context, instance_id, volume_id, mountpoint):
diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index 6e1302520..a67d16e40 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -374,33 +374,42 @@ class ComputeTestCase(BaseTestCase):
 
     def test_console_output(self):
         """Make sure we can get console output from instance"""
-        instance_id = self._create_instance()
-        self.compute.run_instance(self.context, instance_id)
+        instance = self._create_fake_instance()
+        self.compute.run_instance(self.context, instance['id'])
 
         console = self.compute.get_console_output(self.context,
-                                                        instance_id)
+                                                  instance['uuid'])
         self.assert_(console)
-        self.compute.terminate_instance(self.context, instance_id)
+        self.compute.terminate_instance(self.context, instance['id'])
 
     def test_ajax_console(self):
         """Make sure we can get console output from instance"""
-        instance_id = self._create_instance()
-        self.compute.run_instance(self.context, instance_id)
+        instance = self._create_fake_instance()
+        self.compute.run_instance(self.context, instance['id'])
 
         console = self.compute.get_ajax_console(self.context,
-                                                instance_id)
+                                                instance['uuid'])
         self.assert_(set(['token', 'host', 'port']).issubset(console.keys()))
-        self.compute.terminate_instance(self.context, instance_id)
+        self.compute.terminate_instance(self.context, instance['id'])
 
     def test_vnc_console(self):
         """Make sure we can a vnc console for an instance."""
-        instance_id = self._create_instance()
-        self.compute.run_instance(self.context, instance_id)
+        instance = self._create_fake_instance()
+        self.compute.run_instance(self.context, instance['id'])
 
-        console = self.compute.get_vnc_console(self.context,
-                                               instance_id)
+        console = self.compute.get_vnc_console(self.context, instance['uuid'])
         self.assert_(console)
-        self.compute.terminate_instance(self.context, instance_id)
+        self.compute.terminate_instance(self.context, instance['id'])
+
+    def test_diagnostics(self):
+        """Make sure we can get diagnostics for an instance."""
+        instance = self._create_fake_instance()
+        self.compute.run_instance(self.context, instance['id'])
+
+        diagnostics = self.compute.get_diagnostics(self.context,
+                                                   instance['uuid'])
+        self.assertEqual(diagnostics, 'FAKE_DIAGNOSTICS')
+        self.compute.terminate_instance(self.context, instance['id'])
 
     def test_add_fixed_ip_usage_notification(self):
         def dummy(*args, **kwargs):
diff --git a/nova/virt/fake.py b/nova/virt/fake.py
index d4a554c81..e860f72d5 100644
--- a/nova/virt/fake.py
+++ b/nova/virt/fake.py
@@ -191,7 +191,7 @@ class FakeConnection(driver.ComputeDriver):
                 'cpu_time': 0}
 
     def get_diagnostics(self, instance_name):
-        return {}
+        return 'FAKE_DIAGNOSTICS'
 
     def get_all_bw_usage(self, start_time, stop_time=None):
         """Return bandwidth usage info for each interface on each