Naming instance directory by uuid in VMware Hyper.

Like Libvirt Hyper, Using EC2 template for naming instance
directory may cause conflict. we follow what Libvirt does to use
instance uuid instead of EC2 template naming. To keep backwards
compability, when fails to find a instance by uuid, fall back to use
EC2 name.

Fix bug #1186944

Change-Id: Iaba099225a9b3b0390cae4c5fbd82d7e6c11f0e0

4 files changed, 86 insertions, 94 deletions

diff --git a/nova/tests/virt/vmwareapi/db_fakes.py b/nova/tests/virt/vmwareapi/db_fakes.py
index 8f2df43e3..93fcf6e13 100644
--- a/nova/tests/virt/vmwareapi/db_fakes.py
+++ b/nova/tests/virt/vmwareapi/db_fakes.py
@@ -19,8 +19,6 @@
 Stubouts, mocks and fixtures for the test suite
 """
 
-import uuid
-
 from nova.compute import task_states
 from nova.compute import vm_states
 from nova import db
@@ -62,7 +60,7 @@ def stub_out_db_instance_api(stubs):
         base_options = {
             'name': values['name'],
             'id': values['id'],
-            'uuid': uuid.uuid4(),
+            'uuid': values['uuid'],
             'reservation_id': utils.generate_uid('r'),
             'image_ref': values['image_ref'],
             'kernel_id': values['kernel_id'],
diff --git a/nova/tests/virt/vmwareapi/test_vmwareapi.py b/nova/tests/virt/vmwareapi/test_vmwareapi.py
index dd1a0e923..e5c2520ca 100644
--- a/nova/tests/virt/vmwareapi/test_vmwareapi.py
+++ b/nova/tests/virt/vmwareapi/test_vmwareapi.py
@@ -135,6 +135,7 @@ class VMwareAPIVMTestCase(test.TestCase):
     def _create_instance_in_the_db(self):
         values = {'name': 1,
                   'id': 1,
+                  'uuid': "fake-uuid",
                   'project_id': self.project_id,
                   'user_id': self.user_id,
                   'image_ref': "1",
@@ -164,7 +165,8 @@ class VMwareAPIVMTestCase(test.TestCase):
         self.assertEquals(len(instances), 1)
 
         # Get Nova record for VM
-        vm_info = self.conn.get_info({'name': 1})
+        vm_info = self.conn.get_info({'uuid': 'fake-uuid',
+                                      'name': 1})
 
         # Get record for VM
         vms = vmwareapi_fake._get_objects("VirtualMachine")
@@ -218,7 +220,7 @@ class VMwareAPIVMTestCase(test.TestCase):
 
     def test_spawn(self):
         self._create_vm()
-        info = self.conn.get_info({'name': 1})
+        info = self.conn.get_info({'uuid': 'fake-uuid'})
         self._check_vm_info(info, power_state.RUNNING)
 
     def test_snapshot(self):
@@ -232,11 +234,11 @@ class VMwareAPIVMTestCase(test.TestCase):
                   'expected_state': task_states.IMAGE_PENDING_UPLOAD}}]
         func_call_matcher = matchers.FunctionCallMatcher(expected_calls)
         self._create_vm()
-        info = self.conn.get_info({'name': 1})
+        info = self.conn.get_info({'uuid': 'fake-uuid'})
         self._check_vm_info(info, power_state.RUNNING)
         self.conn.snapshot(self.context, self.instance, "Test-Snapshot",
                            func_call_matcher.call)
-        info = self.conn.get_info({'name': 1})
+        info = self.conn.get_info({'uuid': 'fake-uuid'})
         self._check_vm_info(info, power_state.RUNNING)
         self.assertIsNone(func_call_matcher.match())
 
@@ -248,12 +250,23 @@ class VMwareAPIVMTestCase(test.TestCase):
 
     def test_reboot(self):
         self._create_vm()
-        info = self.conn.get_info({'name': 1})
+        info = self.conn.get_info({'name': 1, 'uuid': 'fake-uuid'})
         self._check_vm_info(info, power_state.RUNNING)
         reboot_type = "SOFT"
         self.conn.reboot(self.context, self.instance, self.network_info,
                          reboot_type)
-        info = self.conn.get_info({'name': 1})
+        info = self.conn.get_info({'name': 1, 'uuid': 'fake-uuid'})
+        self._check_vm_info(info, power_state.RUNNING)
+
+    def test_reboot_with_uuid(self):
+        """Test fall back to use name when can't find by uuid."""
+        self._create_vm()
+        info = self.conn.get_info({'name': 'fake-uuid', 'uuid': 'wrong-uuid'})
+        self._check_vm_info(info, power_state.RUNNING)
+        reboot_type = "SOFT"
+        self.conn.reboot(self.context, self.instance, self.network_info,
+                         reboot_type)
+        info = self.conn.get_info({'name': 'fake-uuid', 'uuid': 'wrong-uuid'})
         self._check_vm_info(info, power_state.RUNNING)
 
     def test_reboot_non_existent(self):
@@ -264,10 +277,10 @@ class VMwareAPIVMTestCase(test.TestCase):
 
     def test_reboot_not_poweredon(self):
         self._create_vm()
-        info = self.conn.get_info({'name': 1})
+        info = self.conn.get_info({'uuid': 'fake-uuid'})
         self._check_vm_info(info, power_state.RUNNING)
         self.conn.suspend(self.instance)
-        info = self.conn.get_info({'name': 1})
+        info = self.conn.get_info({'uuid': 'fake-uuid'})
         self._check_vm_info(info, power_state.SUSPENDED)
         self.assertRaises(exception.InstanceRebootFailure, self.conn.reboot,
                           self.context, self.instance, self.network_info,
@@ -275,10 +288,10 @@ class VMwareAPIVMTestCase(test.TestCase):
 
     def test_suspend(self):
         self._create_vm()
-        info = self.conn.get_info({'name': 1})
+        info = self.conn.get_info({'uuid': "fake-uuid"})
         self._check_vm_info(info, power_state.RUNNING)
         self.conn.suspend(self.instance)
-        info = self.conn.get_info({'name': 1})
+        info = self.conn.get_info({'uuid': 'fake-uuid'})
         self._check_vm_info(info, power_state.SUSPENDED)
 
     def test_suspend_non_existent(self):
@@ -288,13 +301,13 @@ class VMwareAPIVMTestCase(test.TestCase):
 
     def test_resume(self):
         self._create_vm()
-        info = self.conn.get_info({'name': 1})
+        info = self.conn.get_info({'uuid': 'fake-uuid'})
         self._check_vm_info(info, power_state.RUNNING)
         self.conn.suspend(self.instance)
-        info = self.conn.get_info({'name': 1})
+        info = self.conn.get_info({'uuid': 'fake-uuid'})
         self._check_vm_info(info, power_state.SUSPENDED)
         self.conn.resume(self.instance, self.network_info)
-        info = self.conn.get_info({'name': 1})
+        info = self.conn.get_info({'uuid': 'fake-uuid'})
         self._check_vm_info(info, power_state.RUNNING)
 
     def test_resume_non_existent(self):
@@ -304,20 +317,20 @@ class VMwareAPIVMTestCase(test.TestCase):
 
     def test_resume_not_suspended(self):
         self._create_vm()
-        info = self.conn.get_info({'name': 1})
+        info = self.conn.get_info({'uuid': 'fake-uuid'})
         self._check_vm_info(info, power_state.RUNNING)
         self.assertRaises(exception.InstanceResumeFailure, self.conn.resume,
                           self.instance, self.network_info)
 
     def test_power_on(self):
         self._create_vm()
-        info = self.conn.get_info({'name': 1})
+        info = self.conn.get_info({'uuid': 'fake-uuid'})
         self._check_vm_info(info, power_state.RUNNING)
         self.conn.power_off(self.instance)
-        info = self.conn.get_info({'name': 1})
+        info = self.conn.get_info({'uuid': 'fake-uuid'})
         self._check_vm_info(info, power_state.SHUTDOWN)
         self.conn.power_on(self.instance)
-        info = self.conn.get_info({'name': 1})
+        info = self.conn.get_info({'uuid': 'fake-uuid'})
         self._check_vm_info(info, power_state.RUNNING)
 
     def test_power_on_non_existent(self):
@@ -327,10 +340,10 @@ class VMwareAPIVMTestCase(test.TestCase):
 
     def test_power_off(self):
         self._create_vm()
-        info = self.conn.get_info({'name': 1})
+        info = self.conn.get_info({'uuid': 'fake-uuid'})
         self._check_vm_info(info, power_state.RUNNING)
         self.conn.power_off(self.instance)
-        info = self.conn.get_info({'name': 1})
+        info = self.conn.get_info({'uuid': 'fake-uuid'})
         self._check_vm_info(info, power_state.SHUTDOWN)
 
     def test_power_off_non_existent(self):
@@ -341,19 +354,19 @@ class VMwareAPIVMTestCase(test.TestCase):
     def test_power_off_suspended(self):
         self._create_vm()
         self.conn.suspend(self.instance)
-        info = self.conn.get_info({'name': 1})
+        info = self.conn.get_info({'uuid': 'fake-uuid'})
         self._check_vm_info(info, power_state.SUSPENDED)
         self.assertRaises(exception.InstancePowerOffFailure,
                           self.conn.power_off, self.instance)
 
     def test_get_info(self):
         self._create_vm()
-        info = self.conn.get_info({'name': 1})
+        info = self.conn.get_info({'uuid': 'fake-uuid'})
         self._check_vm_info(info, power_state.RUNNING)
 
     def test_destroy(self):
         self._create_vm()
-        info = self.conn.get_info({'name': 1})
+        info = self.conn.get_info({'uuid': 'fake-uuid'})
         self._check_vm_info(info, power_state.RUNNING)
         instances = self.conn.list_instances()
         self.assertEquals(len(instances), 1)
diff --git a/nova/virt/vmwareapi/vm_util.py b/nova/virt/vmwareapi/vm_util.py
index 4287b4eaa..6b3b83133 100644
--- a/nova/virt/vmwareapi/vm_util.py
+++ b/nova/virt/vmwareapi/vm_util.py
@@ -47,7 +47,7 @@ def get_vm_create_spec(client_factory, instance, data_store_name,
                        vif_infos, os_type="otherGuest"):
     """Builds the VM Create spec."""
     config_spec = client_factory.create('ns0:VirtualMachineConfigSpec')
-    config_spec.name = instance['name']
+    config_spec.name = instance['uuid']
     config_spec.guestId = os_type
 
     vm_file_info = client_factory.create('ns0:VirtualMachineFileInfo')
@@ -499,6 +499,25 @@ def get_vm_ref_from_name(session, vm_name):
     return None
 
 
+def get_vm_ref_from_uuid(session, instance_uuid):
+    """Get reference to the VM with the uuid specified."""
+    vms = session._call_method(vim_util, "get_objects",
+                "VirtualMachine", ["name"])
+    for vm in vms:
+        if vm.propSet[0].val == instance_uuid:
+            return vm.obj
+
+
+def get_vm_ref(session, instance):
+    """Get reference to the VM through uuid or vm name."""
+    vm_ref = get_vm_ref_from_uuid(session, instance['uuid'])
+    if not vm_ref:
+        vm_ref = get_vm_ref_from_name(session, instance['name'])
+    if vm_ref is None:
+        raise exception.InstanceNotFound(instance_id=instance['uuid'])
+    return vm_ref
+
+
 def get_cluster_ref_from_name(session, cluster_name):
     """Get reference to the cluster with the name specified."""
     cls = session._call_method(vim_util, "get_objects",
diff --git a/nova/virt/vmwareapi/vmops.py b/nova/virt/vmwareapi/vmops.py
index 23c85025b..b84ea62c9 100644
--- a/nova/virt/vmwareapi/vmops.py
+++ b/nova/virt/vmwareapi/vmops.py
@@ -130,9 +130,6 @@ class VMwareVMOps(object):
         4. Attach the disk to the VM by reconfiguring the same.
         5. Power on the VM.
         """
-        vm_ref = vm_util.get_vm_ref_from_name(self._session, instance['name'])
-        if vm_ref:
-            raise exception.InstanceExists(name=instance['name'])
 
         client_factory = self._session._get_vim().client.factory
         service_content = self._session._get_vim().get_service_content()
@@ -206,7 +203,7 @@ class VMwareVMOps(object):
             LOG.debug(_("Created VM on the ESX host"), instance=instance)
 
         _execute_create_vm()
-        vm_ref = vm_util.get_vm_ref_from_name(self._session, instance['name'])
+        vm_ref = vm_util.get_vm_ref(self._session, instance)
 
         # Set the machine.id parameter of the instance to inject
         # the NIC configuration inside the VM
@@ -349,7 +346,7 @@ class VMwareVMOps(object):
                 upload_folder = self._instance_path_base
                 upload_name = instance['image_ref']
             else:
-                upload_folder = instance['name']
+                upload_folder = instance['uuid']
                 upload_name = instance['name']
 
             # The vmdk meta-data file
@@ -406,7 +403,7 @@ class VMwareVMOps(object):
             root_disk = driver.block_device_info_get_mapping(
                            block_device_info)[0]
             connection_info = root_disk['connection_info']
-            self._volumeops.attach_volume(connection_info, instance['name'],
+            self._volumeops.attach_volume(connection_info, instance['uuid'],
                                           self._default_root_device)
 
         def _power_on_vm():
@@ -435,10 +432,7 @@ class VMwareVMOps(object):
         4. Now upload the -flat.vmdk file to the image store.
         5. Delete the coalesced .vmdk and -flat.vmdk created.
         """
-        vm_ref = vm_util.get_vm_ref_from_name(self._session, instance['name'])
-        if vm_ref is None:
-            raise exception.InstanceNotFound(instance_id=instance['uuid'])
-
+        vm_ref = vm_util.get_vm_ref(self._session, instance)
         client_factory = self._session._get_vim().client.factory
         service_content = self._session._get_vim().get_service_content()
 
@@ -468,7 +462,7 @@ class VMwareVMOps(object):
             snapshot_task = self._session._call_method(
                         self._session._get_vim(),
                         "CreateSnapshot_Task", vm_ref,
-                        name="%s-snapshot" % instance['name'],
+                        name="%s-snapshot" % instance['uuid'],
                         description="Taking Snapshot of the VM",
                         memory=False,
                         quiesce=True)
@@ -583,10 +577,7 @@ class VMwareVMOps(object):
 
     def reboot(self, instance, network_info):
         """Reboot a VM instance."""
-        vm_ref = vm_util.get_vm_ref_from_name(self._session, instance['name'])
-        if vm_ref is None:
-            raise exception.InstanceNotFound(instance_id=instance['uuid'])
-
+        vm_ref = vm_util.get_vm_ref(self._session, instance)
         self.plug_vifs(instance, network_info)
 
         lst_properties = ["summary.guest.toolsStatus", "runtime.powerState",
@@ -633,14 +624,8 @@ class VMwareVMOps(object):
         2. Destroy the VM.
         """
         try:
-            vm_ref = vm_util.get_vm_ref_from_name(self._session,
-                                                  instance['name'])
-            if vm_ref is None:
-                LOG.debug(_("instance not present"), instance=instance)
-                return
-
+            vm_ref = vm_util.get_vm_ref(self._session, instance)
             self.power_off(instance)
-
             try:
                 LOG.debug(_("Destroying the VM"), instance=instance)
                 destroy_task = self._session._call_method(
@@ -665,11 +650,7 @@ class VMwareVMOps(object):
         3. Delete the contents of the folder holding the VM related data.
         """
         try:
-            vm_ref = vm_util.get_vm_ref_from_name(self._session,
-                                                  instance['name'])
-            if vm_ref is None:
-                LOG.debug(_("instance not present"), instance=instance)
-                return
+            vm_ref = vm_util.get_vm_ref(self._session, instance)
             lst_properties = ["config.files.vmPathName", "runtime.powerState"]
             props = self._session._call_method(vim_util,
                         "get_object_properties",
@@ -748,10 +729,7 @@ class VMwareVMOps(object):
 
     def suspend(self, instance):
         """Suspend the specified instance."""
-        vm_ref = vm_util.get_vm_ref_from_name(self._session, instance['name'])
-        if vm_ref is None:
-            raise exception.InstanceNotFound(instance_id=instance['uuid'])
-
+        vm_ref = vm_util.get_vm_ref(self._session, instance)
         pwr_state = self._session._call_method(vim_util,
                     "get_dynamic_property", vm_ref,
                     "VirtualMachine", "runtime.powerState")
@@ -772,10 +750,7 @@ class VMwareVMOps(object):
 
     def resume(self, instance):
         """Resume the specified instance."""
-        vm_ref = vm_util.get_vm_ref_from_name(self._session, instance['name'])
-        if vm_ref is None:
-            raise exception.InstanceNotFound(instance_id=instance['uuid'])
-
+        vm_ref = vm_util.get_vm_ref(self._session, instance)
         pwr_state = self._session._call_method(vim_util,
                                      "get_dynamic_property", vm_ref,
                                      "VirtualMachine", "runtime.powerState")
@@ -797,9 +772,7 @@ class VMwareVMOps(object):
             - spawn a rescue VM (the vm name-label will be instance-N-rescue).
 
         """
-        vm_ref = vm_util.get_vm_ref_from_name(self._session, instance['name'])
-        if vm_ref is None:
-            raise exception.InstanceNotFound(instance_id=instance['uuid'])
+        vm_ref = vm_util.get_vm_ref(self._session, instance)
 
         self.power_off(instance)
         instance['name'] = instance['name'] + self._rescue_suffix
@@ -813,7 +786,10 @@ class VMwareVMOps(object):
             = vm_util.get_vmdk_path_and_adapter_type(hardware_devices)
         # Figure out the correct unit number
         unit_number = unit_number + 1
-        rescue_vm_ref = vm_util.get_vm_ref_from_name(self._session,
+        rescue_vm_ref = vm_util.get_vm_ref_from_uuid(self._session,
+                                                     instance['uuid'])
+        if rescue_vm_ref is None:
+            rescue_vm_ref = vm_util.get_vm_ref_from_name(self._session,
                                                      instance['name'])
         self._volumeops.attach_disk_to_vm(
                                 rescue_vm_ref, instance,
@@ -831,9 +807,7 @@ class VMwareVMOps(object):
 
     def power_off(self, instance):
         """Power off the specified instance."""
-        vm_ref = vm_util.get_vm_ref_from_name(self._session, instance['name'])
-        if vm_ref is None:
-            raise exception.InstanceNotFound(instance_id=instance['uuid'])
+        vm_ref = vm_util.get_vm_ref(self._session, instance)
 
         pwr_state = self._session._call_method(vim_util,
                     "get_dynamic_property", vm_ref,
@@ -856,9 +830,7 @@ class VMwareVMOps(object):
 
     def power_on(self, instance):
         """Power on the specified instance."""
-        vm_ref = vm_util.get_vm_ref_from_name(self._session, instance['name'])
-        if vm_ref is None:
-            raise exception.InstanceNotFound(instance_id=instance['uuid'])
+        vm_ref = vm_util.get_vm_ref(self._session, instance)
 
         pwr_state = self._session._call_method(vim_util,
                                      "get_dynamic_property", vm_ref,
@@ -906,9 +878,7 @@ class VMwareVMOps(object):
                                        step=0,
                                        total_steps=RESIZE_TOTAL_STEPS)
 
-        vm_ref = vm_util.get_vm_ref_from_name(self._session, instance['name'])
-        if vm_ref is None:
-            raise exception.InstanceNotFound(instance_id=instance['name'])
+        vm_ref = vm_util.get_vm_ref(self._session, instance)
         host_ref = self._get_host_ref_from_name(dest)
         if host_ref is None:
             raise exception.HostNotFound(host=dest)
@@ -959,7 +929,9 @@ class VMwareVMOps(object):
         """Confirms a resize, destroying the source VM."""
         instance_name = self._get_orig_vm_name_label(instance)
         # Destroy the original VM.
-        vm_ref = vm_util.get_vm_ref_from_name(self._session, instance_name)
+        vm_ref = vm_util.get_vm_ref_from_uuid(self._session, instance['uuid'])
+        if vm_ref is None:
+            vm_ref = vm_util.get_vm_ref_from_name(self._session, instance_name)
         if vm_ref is None:
             LOG.debug(_("instance not present"), instance=instance)
             return
@@ -991,7 +963,7 @@ class VMwareVMOps(object):
                   instance=instance)
         rename_task = self._session._call_method(
                             self._session._get_vim(),
-                            "Rename_Task", vm_ref, newName=instance['name'])
+                            "Rename_Task", vm_ref, newName=instance['uuid'])
         self._session._wait_for_task(instance['uuid'], rename_task)
         LOG.debug(_("Renamed the VM from %s") % name_label,
                   instance=instance)
@@ -1012,9 +984,8 @@ class VMwareVMOps(object):
     def live_migration(self, context, instance_ref, dest,
                        post_method, recover_method, block_migration=False):
         """Spawning live_migration operation for distributing high-load."""
-        vm_ref = vm_util.get_vm_ref_from_name(self._session, instance_ref.name)
-        if vm_ref is None:
-            raise exception.InstanceNotFound(instance_id=instance_ref.name)
+        vm_ref = vm_util.get_vm_ref(self._session, instance_ref)
+
         host_ref = self._get_host_ref_from_name(dest)
         if host_ref is None:
             raise exception.HostNotFound(host=dest)
@@ -1050,9 +1021,7 @@ class VMwareVMOps(object):
 
     def get_info(self, instance):
         """Return data about the VM instance."""
-        vm_ref = vm_util.get_vm_ref_from_name(self._session, instance['name'])
-        if vm_ref is None:
-            raise exception.InstanceNotFound(instance_id=instance['name'])
+        vm_ref = vm_util.get_vm_ref(self._session, instance)
 
         lst_properties = ["summary.config.numCpu",
                     "summary.config.memorySizeMB",
@@ -1086,9 +1055,8 @@ class VMwareVMOps(object):
 
     def get_console_output(self, instance):
         """Return snapshot of console."""
-        vm_ref = vm_util.get_vm_ref_from_name(self._session, instance['name'])
-        if vm_ref is None:
-            raise exception.InstanceNotFound(instance_id=instance['uuid'])
+        vm_ref = vm_util.get_vm_ref(self._session, instance)
+
         param_list = {"id": str(vm_ref.value)}
         base_url = "%s://%s/screen?%s" % (self._session._scheme,
                                          self._session._host_ip,
@@ -1107,9 +1075,7 @@ class VMwareVMOps(object):
 
     def get_vnc_console(self, instance):
         """Return connection info for a vnc console."""
-        vm_ref = vm_util.get_vm_ref_from_name(self._session, instance['name'])
-        if vm_ref is None:
-            raise exception.InstanceNotFound(instance_id=instance['uuid'])
+        vm_ref = vm_util.get_vm_ref(self._session, instance)
 
         return {'host': CONF.vmwareapi_host_ip,
                 'port': self._get_vnc_port(vm_ref),
@@ -1155,9 +1121,7 @@ class VMwareVMOps(object):
         Set the machine id of the VM for guest tools to pick up and reconfigure
         the network interfaces.
         """
-        vm_ref = vm_util.get_vm_ref_from_name(self._session, instance['name'])
-        if vm_ref is None:
-            raise exception.InstanceNotFound(instance_id=instance['uuid'])
+        vm_ref = vm_util.get_vm_ref(self._session, instance)
 
         machine_id_change_spec = vm_util.get_machine_id_change_spec(
                                  client_factory,
@@ -1176,9 +1140,7 @@ class VMwareVMOps(object):
         """
         Set the vnc configuration of the VM.
         """
-        vm_ref = vm_util.get_vm_ref_from_name(self._session, instance['name'])
-        if vm_ref is None:
-            raise exception.InstanceNotFound(instance_id=instance['uuid'])
+        vm_ref = vm_util.get_vm_ref(self._session, instance)
 
         vnc_config_spec = vm_util.get_vnc_config_spec(
                                       client_factory, port, password)