Merge "DRYing up volume_in_mapping code."

nova/block_device.py

@@ -17,8 +17,11 @@
 
 import re
 
+from nova.openstack.common import log as logging
 from nova.virt import driver
 
+LOG = logging.getLogger(__name__)
+
 DEFAULT_ROOT_DEV_NAME = '/dev/sda1'
 _DEFAULT_MAPPINGS = {'ami': 'sda1',
                      'ephemeral0': 'sda2',
@@ -144,3 +147,25 @@ def match_device(device):
     if not match:
         return None
     return match.groups()
+
+
+def volume_in_mapping(mount_device, block_device_info, strip=strip_dev):
+    # FIXME(sirp): xen uses strip_prefix to be mountpoint agnostic. There is
+    # probably a better way to handle this so that strip_dev can be used
+    # exclusively.
+    block_device_list = [strip(vol['mount_device'])
+                         for vol in
+                         driver.block_device_info_get_mapping(
+                         block_device_info)]
+
+    swap = driver.block_device_info_get_swap(block_device_info)
+    if driver.swap_is_usable(swap):
+        block_device_list.append(strip(swap['device_name']))
+
+    block_device_list += [strip(ephemeral['device_name'])
+                          for ephemeral in
+                          driver.block_device_info_get_ephemerals(
+                          block_device_info)]
+
+    LOG.debug(_("block_device_list %s"), block_device_list)
+    return strip(mount_device) in block_device_list

nova/tests/test_block_device.py

@@ -91,3 +91,38 @@ class BlockDeviceTestCase(test.TestCase):
         self.assertEqual(block_device.strip_prefix('a'), 'a')
         self.assertEqual(block_device.strip_prefix('xvda'), 'a')
         self.assertEqual(block_device.strip_prefix('vda'), 'a')
+
+    def test_volume_in_mapping(self):
+        swap = {'device_name': '/dev/sdb',
+                'swap_size': 1}
+        ephemerals = [{'num': 0,
+                       'virtual_name': 'ephemeral0',
+                       'device_name': '/dev/sdc1',
+                       'size': 1},
+                      {'num': 2,
+                       'virtual_name': 'ephemeral2',
+                       'device_name': '/dev/sdd',
+                       'size': 1}]
+        block_device_mapping = [{'mount_device': '/dev/sde',
+                                 'device_path': 'fake_device'},
+                                {'mount_device': '/dev/sdf',
+                                 'device_path': 'fake_device'}]
+        block_device_info = {
+                'root_device_name': '/dev/sda',
+                'swap': swap,
+                'ephemerals': ephemerals,
+                'block_device_mapping': block_device_mapping}
+
+        def _assert_volume_in_mapping(device_name, true_or_false):
+            in_mapping = block_device.volume_in_mapping(
+                    device_name, block_device_info)
+            self.assertEquals(in_mapping, true_or_false)
+
+        _assert_volume_in_mapping('sda', False)
+        _assert_volume_in_mapping('sdb', True)
+        _assert_volume_in_mapping('sdc1', True)
+        _assert_volume_in_mapping('sdd', True)
+        _assert_volume_in_mapping('sde', True)
+        _assert_volume_in_mapping('sdf', True)
+        _assert_volume_in_mapping('sdg', False)
+        _assert_volume_in_mapping('sdh1', False)

nova/tests/test_libvirt.py

@@ -2883,42 +2883,6 @@ class LibvirtConnTestCase(test.TestCase):
 
             self.mox.UnsetStubs()
 
-    def test_volume_in_mapping(self):
-        conn = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), False)
-        swap = {'device_name': '/dev/sdb',
-                'swap_size': 1}
-        ephemerals = [{'num': 0,
-                       'virtual_name': 'ephemeral0',
-                       'device_name': '/dev/sdc1',
-                       'size': 1},
-                      {'num': 2,
-                       'virtual_name': 'ephemeral2',
-                       'device_name': '/dev/sdd',
-                       'size': 1}]
-        block_device_mapping = [{'mount_device': '/dev/sde',
-                                 'device_path': 'fake_device'},
-                                {'mount_device': '/dev/sdf',
-                                 'device_path': 'fake_device'}]
-        block_device_info = {
-                'root_device_name': '/dev/sda',
-                'swap': swap,
-                'ephemerals': ephemerals,
-                'block_device_mapping': block_device_mapping}
-
-        def _assert_volume_in_mapping(device_name, true_or_false):
-            self.assertEquals(conn._volume_in_mapping(device_name,
-                                                      block_device_info),
-                              true_or_false)
-
-        _assert_volume_in_mapping('sda', False)
-        _assert_volume_in_mapping('sdb', True)
-        _assert_volume_in_mapping('sdc1', True)
-        _assert_volume_in_mapping('sdd', True)
-        _assert_volume_in_mapping('sde', True)
-        _assert_volume_in_mapping('sdf', True)
-        _assert_volume_in_mapping('sdg', False)
-        _assert_volume_in_mapping('sdh1', False)
-
     def test_immediate_delete(self):
         def fake_lookup_by_name(instance_name):
             raise exception.InstanceNotFound(instance_id=instance_name)

nova/virt/libvirt/driver.py

@@ -1432,8 +1432,8 @@ class LibvirtDriver(driver.ComputeDriver):
         if size == 0 or suffix == '.rescue':
             size = None
 
-        if not self._volume_in_mapping(self.default_root_device,
+        if not block_device.volume_in_mapping(
-                                       block_device_info):
+                self.default_root_device, block_device_info):
             image('disk').cache(fetch_func=libvirt_utils.fetch_image,
                                 context=context,
                                 filename=root_fname,
@@ -1448,7 +1448,7 @@ class LibvirtDriver(driver.ComputeDriver):
             os_type_with_default = 'default'
 
         ephemeral_gb = instance['ephemeral_gb']
-        if ephemeral_gb and not self._volume_in_mapping(
+        if ephemeral_gb and not block_device.volume_in_mapping(
                 self.default_second_device, block_device_info):
             swap_device = self.default_third_device
             fn = functools.partial(self._create_ephemeral,
@@ -1480,7 +1480,8 @@ class LibvirtDriver(driver.ComputeDriver):
         if driver.swap_is_usable(swap):
             swap_mb = swap['swap_size']
         elif (inst_type['swap'] > 0 and
-              not self._volume_in_mapping(swap_device, block_device_info)):
+              not block_device.volume_in_mapping(
+                  swap_device, block_device_info)):
             swap_mb = inst_type['swap']
 
         if swap_mb > 0:
@@ -1557,24 +1558,6 @@ class LibvirtDriver(driver.ComputeDriver):
         if CONF.libvirt_type == 'uml':
             libvirt_utils.chown(image('disk').path, 'root')
 
-    @staticmethod
-    def _volume_in_mapping(mount_device, block_device_info):
-        block_device_list = [block_device.strip_dev(vol['mount_device'])
-                             for vol in
-                             driver.block_device_info_get_mapping(
-                                 block_device_info)]
-        swap = driver.block_device_info_get_swap(block_device_info)
-        if driver.swap_is_usable(swap):
-            block_device_list.append(
-                block_device.strip_dev(swap['device_name']))
-        block_device_list += [block_device.strip_dev(ephemeral['device_name'])
-                              for ephemeral in
-                              driver.block_device_info_get_ephemerals(
-                                  block_device_info)]
-
-        LOG.debug(_("block_device_list %s"), block_device_list)
-        return block_device.strip_dev(mount_device) in block_device_list
-
     def get_host_capabilities(self):
         """Returns an instance of config.LibvirtConfigCaps representing
            the capabilities of the host"""
@@ -1708,8 +1691,8 @@ class LibvirtDriver(driver.ComputeDriver):
                                    self.default_second_device)
                 devices.append(diskos)
             else:
-                ebs_root = self._volume_in_mapping(self.default_root_device,
+                ebs_root = block_device.volume_in_mapping(
-                                                   block_device_info)
+                        self.default_root_device, block_device_info)
 
                 if not ebs_root:
                     if root_device_type == "cdrom":
@@ -1723,8 +1706,8 @@ class LibvirtDriver(driver.ComputeDriver):
                     devices.append(diskos)
 
                 ephemeral_device = None
-                if not (self._volume_in_mapping(self.default_second_device,
+                if not (block_device.volume_in_mapping(
-                                                block_device_info) or
+                    self.default_second_device, block_device_info) or
                         0 in [eph['num'] for eph in
                               driver.block_device_info_get_ephemerals(
                             block_device_info)]):
@@ -1758,8 +1741,8 @@ class LibvirtDriver(driver.ComputeDriver):
                             swap['device_name']))
                     devices.append(diskswap)
                 elif (inst_type['swap'] > 0 and
-                      not self._volume_in_mapping(swap_device,
+                      not block_device.volume_in_mapping(
-                                                  block_device_info)):
+                          swap_device, block_device_info)):
                     diskswap = disk_info('disk.swap', swap_device)
                     devices.append(diskswap)
                     self.virtapi.instance_update(

nova/virt/vmwareapi/vmops.py

@@ -339,8 +339,8 @@ class VMwareVMOps(object):
                          "data_store_name": data_store_name},
                         instance=instance)
 
-        ebs_root = self._volume_in_mapping(self._default_root_device,
+        ebs_root = block_device.volume_in_mapping(
-                                           block_device_info)
+                self._default_root_device, block_device_info)
 
         if not ebs_root:
             linked_clone = CONF.use_linked_clone
@@ -1331,21 +1331,3 @@ class VMwareVMOps(object):
                 interfaces.append(device.key)
 
         return interfaces
-
-    @staticmethod
-    def _volume_in_mapping(mount_device, block_device_info):
-        block_device_list = [block_device.strip_dev(vol['mount_device'])
-                             for vol in
-                             driver.block_device_info_get_mapping(
-                                 block_device_info)]
-        swap = driver.block_device_info_get_swap(block_device_info)
-        if driver.swap_is_usable(swap):
-            block_device_list.append(
-                block_device.strip_dev(swap['device_name']))
-        block_device_list += [block_device.strip_dev(ephemeral['device_name'])
-                              for ephemeral in
-                              driver.block_device_info_get_ephemerals(
-                                  block_device_info)]
-
-        LOG.debug(_("block_device_list %s"), block_device_list)
-        return block_device.strip_dev(mount_device) in block_device_list

nova/virt/xenapi/vm_utils.py

@@ -47,7 +47,6 @@ from nova import utils
 from nova.virt import configdrive
 from nova.virt.disk import api as disk
 from nova.virt.disk.vfs import localfs as vfsimpl
-from nova.virt import driver
 from nova.virt.xenapi import agent
 from nova.virt.xenapi import volume_utils
 
@@ -489,29 +488,13 @@ def get_vdis_for_boot_from_vol(session, dev_params):
     return vdis
 
 
-def _volume_in_mapping(mount_device, block_device_info):
-    block_device_list = [block_device.strip_prefix(vol['mount_device'])
-                         for vol in
-                         driver.block_device_info_get_mapping(
-                         block_device_info)]
-    swap = driver.block_device_info_get_swap(block_device_info)
-    if driver.swap_is_usable(swap):
-        swap_dev = swap['device_name']
-        block_device_list.append(block_device.strip_prefix(swap_dev))
-    block_device_list += [block_device.strip_prefix(ephemeral['device_name'])
-                          for ephemeral in
-                          driver.block_device_info_get_ephemerals(
-                          block_device_info)]
-    LOG.debug(_("block_device_list %s"), block_device_list)
-    return block_device.strip_prefix(mount_device) in block_device_list
-
-
 def get_vdis_for_instance(context, session, instance, name_label, image,
                           image_type, block_device_info=None):
     if block_device_info:
         LOG.debug(_("block device info: %s"), block_device_info)
         rootdev = block_device_info['root_device_name']
-        if _volume_in_mapping(rootdev, block_device_info):
+        if block_device.volume_in_mapping(rootdev, block_device_info,
+                                          strip=block_device.strip_prefix):
             # call function to return the vdi in connection info of block
             # device.
             # make it a point to return from here.