def test_get_disk_mapping_updates_original(self): user_context = context.RequestContext(self.user_id, self.project_id) instance_ref = db.instance_create(user_context, self.test_instance) block_device_info = { "root_device_name": "/dev/vda", "swap": {"device_name": "/dev/vdb", "device_type": "really_lame_type", "swap_size": 10}, "ephemerals": [ {"disk_bus": "no_such_bus", "device_type": "yeah_right", "device_name": "/dev/vdc", "size": 10} ], "block_device_mapping": [ { "connection_info": "fake", "mount_device": None, "device_type": "lawnmower", "delete_on_termination": True, } ], } expected_swap = {"device_name": "/dev/vdb", "disk_bus": "virtio", "device_type": "disk", "swap_size": 10} expected_ephemeral = {"disk_bus": "virtio", "device_type": "disk", "device_name": "/dev/vdc", "size": 10} expected_bdm = { "connection_info": "fake", "mount_device": "/dev/vdd", "device_type": "disk", "disk_bus": "virtio", "delete_on_termination": True, } blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide", block_device_info) self.assertEqual(expected_swap, block_device_info["swap"]) self.assertEqual(expected_ephemeral, block_device_info["ephemerals"][0]) self.assertEqual(expected_bdm, block_device_info["block_device_mapping"][0])
def test_get_disk_mapping_updates_original(self): instance_ref = objects.Instance(**self.test_instance) image_meta = {} block_device_info = { "root_device_name": "/dev/vda", "swap": {"device_name": "/dev/vdb", "device_type": "really_lame_type", "swap_size": 10}, "ephemerals": [ {"disk_bus": "no_such_bus", "device_type": "yeah_right", "device_name": "/dev/vdc", "size": 10} ], "block_device_mapping": [ { "connection_info": "fake", "mount_device": None, "device_type": "lawnmower", "delete_on_termination": True, } ], } expected_swap = {"device_name": "/dev/vdb", "disk_bus": "virtio", "device_type": "disk", "swap_size": 10} expected_ephemeral = {"disk_bus": "virtio", "device_type": "disk", "device_name": "/dev/vdc", "size": 10} expected_bdm = { "connection_info": "fake", "mount_device": "/dev/vdd", "device_type": "disk", "disk_bus": "virtio", "delete_on_termination": True, } blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide", image_meta, block_device_info) self.assertEqual(expected_swap, block_device_info["swap"]) self.assertEqual(expected_ephemeral, block_device_info["ephemerals"][0]) self.assertEqual(expected_bdm, block_device_info["block_device_mapping"][0])
def test_get_disk_mapping_cdrom_configdrive(self): # A simple disk mapping setup, with configdrive added as cdrom self.flags(force_config_drive=True) self.flags(config_drive_format='iso9660') user_context = context.RequestContext(self.user_id, self.project_id) instance_ref = db.instance_create(user_context, self.test_instance) mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide") expect = { 'disk': { 'bus': 'virtio', 'dev': 'vda', 'type': 'disk' }, 'disk.local': { 'bus': 'virtio', 'dev': 'vdb', 'type': 'disk' }, 'disk.config': { 'bus': 'ide', 'dev': 'hdd', 'type': 'cdrom' }, 'root': { 'bus': 'virtio', 'dev': 'vda', 'type': 'disk' } } self.assertEqual(expect, mapping)
def test_get_disk_mapping_simple(self): # The simplest possible disk mapping setup, all defaults instance_ref = objects.Instance(**self.test_instance) image_meta = {} mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide", image_meta) expect = { 'disk': { 'bus': 'virtio', 'dev': 'vda', 'type': 'disk', 'boot_index': '1' }, 'disk.local': { 'bus': 'virtio', 'dev': 'vdb', 'type': 'disk' }, 'root': { 'bus': 'virtio', 'dev': 'vda', 'type': 'disk', 'boot_index': '1' } } self.assertEqual(expect, mapping)
def test_get_disk_mapping_simple_configdrive(self): # A simple disk mapping setup, but with configdrive added # It's necessary to check if the architecture is power, because # power doesn't have support to ide, and so libvirt translate # all ide calls to scsi self.flags(force_config_drive=True) user_context = context.RequestContext(self.user_id, self.project_id) instance_ref = db.instance_create(user_context, self.test_instance) mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide") # The last device is selected for this. on x86 is the last ide # device (hdd). Since power only support scsi, the last device # is sdz bus_ppc = ("scsi", "sdz") expect_bus = {"ppc": bus_ppc, "ppc64": bus_ppc} bus, dev = expect_bus.get(blockinfo.libvirt_utils.get_arch({}), ("ide", "hdd")) expect = { "disk": {"bus": "virtio", "dev": "vda", "type": "disk", "boot_index": "1"}, "disk.local": {"bus": "virtio", "dev": "vdb", "type": "disk"}, "disk.config": {"bus": bus, "dev": dev, "type": "cdrom"}, "root": {"bus": "virtio", "dev": "vda", "type": "disk", "boot_index": "1"}, } self.assertEqual(expect, mapping)
def test_get_disk_mapping_simple_swap(self): # A simple disk mapping setup, but with a swap device added user_context = context.RequestContext(self.user_id, self.project_id) self.test_instance['system_metadata']['instance_type_swap'] = 5 instance_ref = db.instance_create(user_context, self.test_instance) mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide") expect = { 'disk': { 'bus': 'virtio', 'dev': 'vda', 'type': 'disk', 'boot_index': '1' }, 'disk.local': { 'bus': 'virtio', 'dev': 'vdb', 'type': 'disk' }, 'disk.swap': { 'bus': 'virtio', 'dev': 'vdc', 'type': 'disk' }, 'root': { 'bus': 'virtio', 'dev': 'vda', 'type': 'disk', 'boot_index': '1' }, } self.assertEqual(expect, mapping)
def test_get_disk_mapping_custom_swap(self): # A disk mapping with a swap device at position vdb. This # should cause disk.local to be removed user_context = context.RequestContext(self.user_id, self.project_id) instance_ref = db.instance_create(user_context, self.test_instance) block_device_info = { 'swap': { 'device_name': '/dev/vdb', 'swap_size': 10 }, } mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide", block_device_info) expect = { 'disk': { 'bus': 'virtio', 'dev': 'vda', 'type': 'disk', 'boot_index': '1' }, 'disk.swap': { 'bus': 'virtio', 'dev': 'vdb', 'type': 'disk' }, 'root': { 'bus': 'virtio', 'dev': 'vda', 'type': 'disk', 'boot_index': '1' }, } self.assertEqual(expect, mapping)
def test_get_disk_mapping_complex(self): # The strangest possible disk mapping setup user_context = context.RequestContext(self.user_id, self.project_id) instance_ref = db.instance_create(user_context, self.test_instance) block_device_info = { 'root_device_name': '/dev/vdf', 'swap': {'device_name': '/dev/vdy', 'swap_size': 10}, 'ephemerals': [ {'num': 0, 'virtual_name': 'ephemeral0', 'device_name': '/dev/vdb', 'size': 10}, {'num': 1, 'virtual_name': 'ephemeral1', 'device_name': '/dev/vdc', 'size': 10}, ], 'block_device_mapping': [ {'connection_info': "fake", 'mount_device': "/dev/vda", 'delete_on_termination': True}, ] } mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide", block_device_info) expect = { 'disk': {'bus': 'virtio', 'dev': 'vdf', 'type': 'disk'}, '/dev/vda': {'bus': 'virtio', 'dev': 'vda', 'type': 'disk'}, 'disk.eph0': {'bus': 'virtio', 'dev': 'vdb', 'type': 'disk'}, 'disk.eph1': {'bus': 'virtio', 'dev': 'vdc', 'type': 'disk'}, 'disk.swap': {'bus': 'virtio', 'dev': 'vdy', 'type': 'disk'}, 'root': {'bus': 'virtio', 'dev': 'vdf', 'type': 'disk'} } self.assertEqual(mapping, expect)
def test_get_disk_mapping_blockdev_many(self): # A disk mapping with a blockdev replacing all devices instance_ref = objects.Instance(**self.test_instance) block_device_info = { 'block_device_mapping': [ {'connection_info': "fake", 'mount_device': "/dev/vda", 'boot_index': 0, 'disk_bus': 'scsi', 'delete_on_termination': True}, {'connection_info': "fake", 'mount_device': "/dev/vdb", 'boot_index': -1, 'delete_on_termination': True}, {'connection_info': "fake", 'mount_device': "/dev/vdc", 'boot_index': -1, 'device_type': 'cdrom', 'delete_on_termination': True}, ] } mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide", block_device_info) expect = { '/dev/vda': {'bus': 'scsi', 'dev': 'vda', 'type': 'disk', 'boot_index': '1'}, '/dev/vdb': {'bus': 'virtio', 'dev': 'vdb', 'type': 'disk'}, '/dev/vdc': {'bus': 'virtio', 'dev': 'vdc', 'type': 'cdrom'}, 'root': {'bus': 'scsi', 'dev': 'vda', 'type': 'disk', 'boot_index': '1'}, } self.assertEqual(expect, mapping)
def test_get_disk_mapping_rescue(self): # A simple disk mapping setup, but in rescue mode instance_ref = objects.Instance(**self.test_instance) image_meta = {} mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide", image_meta, rescue=True) expect = { 'disk.rescue': { 'bus': 'virtio', 'dev': 'vda', 'type': 'disk', 'boot_index': '1' }, 'disk': { 'bus': 'virtio', 'dev': 'vdb', 'type': 'disk' }, 'root': { 'bus': 'virtio', 'dev': 'vda', 'type': 'disk', 'boot_index': '1' }, } self.assertEqual(expect, mapping)
def test_get_disk_mapping_simple_swap(self): # A simple disk mapping setup, but with a swap device added self.test_instance['system_metadata']['instance_type_swap'] = 5 instance_ref = objects.Instance(**self.test_instance) image_meta = {} mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide", image_meta) expect = { 'disk': { 'bus': 'virtio', 'dev': 'vda', 'type': 'disk', 'boot_index': '1' }, 'disk.local': { 'bus': 'virtio', 'dev': 'vdb', 'type': 'disk' }, 'disk.swap': { 'bus': 'virtio', 'dev': 'vdc', 'type': 'disk' }, 'root': { 'bus': 'virtio', 'dev': 'vda', 'type': 'disk', 'boot_index': '1' }, } self.assertEqual(expect, mapping)
def test_get_disk_mapping_ephemeral(self): # A disk mapping with ephemeral devices self.test_instance['system_metadata']['instance_type_swap'] = 5 instance_ref = objects.Instance(**self.test_instance) block_device_info = { 'ephemerals': [ {'device_type': 'disk', 'guest_format': 'ext3', 'device_name': '/dev/vdb', 'size': 10}, {'disk_bus': 'ide', 'guest_format': None, 'device_name': '/dev/vdc', 'size': 10}, {'device_type': 'floppy', 'device_name': '/dev/vdd', 'size': 10}, ] } mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide", block_device_info) expect = { 'disk': {'bus': 'virtio', 'dev': 'vda', 'type': 'disk', 'boot_index': '1'}, 'disk.eph0': {'bus': 'virtio', 'dev': 'vdb', 'type': 'disk', 'format': 'ext3'}, 'disk.eph1': {'bus': 'ide', 'dev': 'vdc', 'type': 'disk'}, 'disk.eph2': {'bus': 'virtio', 'dev': 'vdd', 'type': 'floppy'}, 'disk.swap': {'bus': 'virtio', 'dev': 'vde', 'type': 'disk'}, 'root': {'bus': 'virtio', 'dev': 'vda', 'type': 'disk', 'boot_index': '1'}, } self.assertEqual(expect, mapping)
def test_get_disk_mapping_blockdev_root_on_spawn(self): # A disk mapping with a blockdev initializing the default root instance_ref = objects.Instance(**self.test_instance) image_meta = {} block_device_info = { 'block_device_mapping': [ {'connection_info': None, 'mount_device': None, 'boot_index': 0, 'device_type': None, 'delete_on_termination': True}, ] } mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide", image_meta, block_device_info) expect = { '/dev/vda': {'bus': 'virtio', 'dev': 'vda', 'type': 'disk', 'boot_index': '1'}, 'disk.local': {'bus': 'virtio', 'dev': 'vdb', 'type': 'disk'}, 'root': {'bus': 'virtio', 'dev': 'vda', 'type': 'disk', 'boot_index': '1'}, } self.assertEqual(expect, mapping)
def test_get_disk_mapping_cdrom_configdrive(self): # A simple disk mapping setup, with configdrive added as cdrom # It's necessary to check if the architecture is power, because # power doesn't have support to ide, and so libvirt translate # all ide calls to scsi self.flags(force_config_drive=True) self.flags(config_drive_format='iso9660') instance_ref = objects.Instance(**self.test_instance) mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide") bus_ppc = ("scsi", "sdz") expect_bus = {"ppc": bus_ppc, "ppc64": bus_ppc} bus, dev = expect_bus.get(blockinfo.libvirt_utils.get_arch({}), ("ide", "hdd")) expect = { 'disk': {'bus': 'virtio', 'dev': 'vda', 'type': 'disk', 'boot_index': '1'}, 'disk.local': {'bus': 'virtio', 'dev': 'vdb', 'type': 'disk'}, 'disk.config': {'bus': bus, 'dev': dev, 'type': 'cdrom'}, 'root': {'bus': 'virtio', 'dev': 'vda', 'type': 'disk', 'boot_index': '1'} } self.assertEqual(expect, mapping)
def test_get_disk_mapping_ephemeral(self): # A disk mapping with ephemeral devices user_context = context.RequestContext(self.user_id, self.project_id) self.test_instance['system_metadata']['instance_type_swap'] = 5 instance_ref = db.instance_create(user_context, self.test_instance) block_device_info = { 'ephemerals': [ {'device_type': 'disk', 'guest_format': 'ext3', 'device_name': '/dev/vdb', 'size': 10}, {'disk_bus': 'ide', 'guest_format': None, 'device_name': '/dev/vdc', 'size': 10}, {'device_type': 'floppy', 'device_name': '/dev/vdd', 'size': 10}, ] } mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide", block_device_info) expect = { 'disk': {'bus': 'virtio', 'dev': 'vda', 'type': 'disk', 'boot_index': '1'}, 'disk.eph0': {'bus': 'virtio', 'dev': 'vdb', 'type': 'disk', 'format': 'ext3'}, 'disk.eph1': {'bus': 'ide', 'dev': 'vdc', 'type': 'disk'}, 'disk.eph2': {'bus': 'virtio', 'dev': 'vdd', 'type': 'floppy'}, 'disk.swap': {'bus': 'virtio', 'dev': 'vde', 'type': 'disk'}, 'root': {'bus': 'virtio', 'dev': 'vda', 'type': 'disk', 'boot_index': '1'}, } self.assertEqual(mapping, expect)
def test_get_disk_mapping_blockdev_eph(self): # A disk mapping with a blockdev replacing the ephemeral device user_context = context.RequestContext(self.user_id, self.project_id) instance_ref = db.instance_create(user_context, self.test_instance) block_device_info = { 'block_device_mapping': [ {'connection_info': "fake", 'mount_device': "/dev/vdb", 'boot_index': -1, 'delete_on_termination': True}, ] } mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide", block_device_info) expect = { 'disk': {'bus': 'virtio', 'dev': 'vda', 'type': 'disk', 'boot_index': '1'}, '/dev/vdb': {'bus': 'virtio', 'dev': 'vdb', 'type': 'disk'}, 'root': {'bus': 'virtio', 'dev': 'vda', 'type': 'disk', 'boot_index': '1'}, } self.assertEqual(mapping, expect)
def test_get_disk_mapping_blockdev_eph(self): # A disk mapping with a blockdev replacing the ephemeral device user_context = context.RequestContext(self.user_id, self.project_id) instance_ref = db.instance_create(user_context, self.test_instance) block_device_info = { 'block_device_mapping': [ { 'connection_info': "fake", 'mount_device': "/dev/vdb", 'delete_on_termination': True }, ] } mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide", block_device_info) expect = { 'disk': { 'bus': 'virtio', 'dev': 'vda', 'type': 'disk' }, '/dev/vdb': { 'bus': 'virtio', 'dev': 'vdb', 'type': 'disk' }, 'root': { 'bus': 'virtio', 'dev': 'vda', 'type': 'disk' } } self.assertEqual(mapping, expect)
def test_get_disk_mapping_simple_configdrive(self): # A simple disk mapping setup, but with configdrive added self.flags(force_config_drive=True) user_context = context.RequestContext(self.user_id, self.project_id) instance_ref = db.instance_create(user_context, self.test_instance) mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide") expect = { 'disk': { 'bus': 'virtio', 'dev': 'vda', 'type': 'disk' }, 'disk.local': { 'bus': 'virtio', 'dev': 'vdb', 'type': 'disk' }, 'disk.config': { 'bus': 'virtio', 'dev': 'vdz', 'type': 'disk' }, 'root': { 'bus': 'virtio', 'dev': 'vda', 'type': 'disk' } } self.assertEqual(mapping, expect)
def test_get_disk_mapping_complex(self): # The strangest possible disk mapping setup instance_ref = objects.Instance(**self.test_instance) image_meta = objects.ImageMeta.from_dict(self.test_image_meta) block_device_info = { "root_device_name": "/dev/vdf", "swap": {"device_name": "/dev/vdy", "swap_size": 10}, "ephemerals": [ {"device_type": "disk", "guest_format": "ext4", "device_name": "/dev/vdb", "size": 10}, {"disk_bus": "ide", "guest_format": None, "device_name": "/dev/vdc", "size": 10}, ], "block_device_mapping": [ {"connection_info": "fake", "mount_device": "/dev/vda", "boot_index": 1, "delete_on_termination": True} ], } mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide", image_meta, block_device_info) expect = { "disk": {"bus": "virtio", "dev": "vdf", "type": "disk", "boot_index": "1"}, "/dev/vda": {"bus": "virtio", "dev": "vda", "type": "disk", "boot_index": "2"}, "disk.eph0": {"bus": "virtio", "dev": "vdb", "type": "disk", "format": "ext4"}, "disk.eph1": {"bus": "ide", "dev": "vdc", "type": "disk"}, "disk.swap": {"bus": "virtio", "dev": "vdy", "type": "disk"}, "root": {"bus": "virtio", "dev": "vdf", "type": "disk", "boot_index": "1"}, } self.assertEqual(expect, mapping)
def test_get_disk_mapping_blockdev_eph(self): # A disk mapping with a blockdev replacing the ephemeral device instance_ref = objects.Instance(**self.test_instance) image_meta = objects.ImageMeta.from_dict(self.test_image_meta) block_device_info = { 'block_device_mapping': [ {'connection_info': "fake", 'mount_device': "/dev/vdb", 'boot_index': -1, 'delete_on_termination': True}, ] } mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide", image_meta, block_device_info) expect = { 'disk': {'bus': 'virtio', 'dev': 'vda', 'type': 'disk', 'boot_index': '1'}, '/dev/vdb': {'bus': 'virtio', 'dev': 'vdb', 'type': 'disk'}, 'root': {'bus': 'virtio', 'dev': 'vda', 'type': 'disk', 'boot_index': '1'}, } self.assertEqual(expect, mapping)
def test_get_disk_mapping_simple(self): # The simplest possible disk mapping setup, all defaults user_context = context.RequestContext(self.user_id, self.project_id) instance_ref = db.instance_create(user_context, self.test_instance) mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide") expect = { 'disk': { 'bus': 'virtio', 'dev': 'vda', 'type': 'disk', 'boot_index': '1' }, 'disk.local': { 'bus': 'virtio', 'dev': 'vdb', 'type': 'disk' }, 'root': { 'bus': 'virtio', 'dev': 'vda', 'type': 'disk', 'boot_index': '1' } } self.assertEqual(expect, mapping)
def test_get_disk_mapping_simple_rootdev(self): # A simple disk mapping setup, but with custom root device name instance_ref = objects.Instance(**self.test_instance) image_meta = {} block_device_info = {'root_device_name': '/dev/sda'} mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide", image_meta, block_device_info) expect = { 'disk': { 'bus': 'scsi', 'dev': 'sda', 'type': 'disk', 'boot_index': '1' }, 'disk.local': { 'bus': 'virtio', 'dev': 'vda', 'type': 'disk' }, 'root': { 'bus': 'scsi', 'dev': 'sda', 'type': 'disk', 'boot_index': '1' } } self.assertEqual(expect, mapping)
def test_get_disk_mapping_simple_rootdev(self): # A simple disk mapping setup, but with custom root device name user_context = context.RequestContext(self.user_id, self.project_id) instance_ref = db.instance_create(user_context, self.test_instance) block_device_info = {'root_device_name': '/dev/sda'} mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide", block_device_info) expect = { 'disk': { 'bus': 'scsi', 'dev': 'sda', 'type': 'disk', 'boot_index': '1' }, 'disk.local': { 'bus': 'virtio', 'dev': 'vda', 'type': 'disk' }, 'root': { 'bus': 'scsi', 'dev': 'sda', 'type': 'disk', 'boot_index': '1' } } self.assertEqual(expect, mapping)
def test_get_disk_mapping_complex(self): # The strangest possible disk mapping setup user_context = context.RequestContext(self.user_id, self.project_id) instance_ref = db.instance_create(user_context, self.test_instance) block_device_info = { "root_device_name": "/dev/vdf", "swap": {"device_name": "/dev/vdy", "swap_size": 10}, "ephemerals": [ {"num": 0, "virtual_name": "ephemeral0", "device_name": "/dev/vdb", "size": 10}, {"num": 1, "virtual_name": "ephemeral1", "device_name": "/dev/vdc", "size": 10}, ], "block_device_mapping": [ {"connection_info": "fake", "mount_device": "/dev/vda", "delete_on_termination": True} ], } mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide", block_device_info) expect = { "disk": {"bus": "virtio", "dev": "vdf", "type": "disk"}, "/dev/vda": {"bus": "virtio", "dev": "vda", "type": "disk"}, "disk.eph0": {"bus": "virtio", "dev": "vdb", "type": "disk"}, "disk.eph1": {"bus": "virtio", "dev": "vdc", "type": "disk"}, "disk.swap": {"bus": "virtio", "dev": "vdy", "type": "disk"}, "root": {"bus": "virtio", "dev": "vdf", "type": "disk"}, } self.assertEqual(mapping, expect)
def test_get_disk_mapping_rescue(self): # A simple disk mapping setup, but in rescue mode user_context = context.RequestContext(self.user_id, self.project_id) instance_ref = db.instance_create(user_context, self.test_instance) mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide", rescue=True) expect = { 'disk.rescue': { 'bus': 'virtio', 'dev': 'vda', 'type': 'disk', 'boot_index': '1' }, 'disk': { 'bus': 'virtio', 'dev': 'vdb', 'type': 'disk' }, 'root': { 'bus': 'virtio', 'dev': 'vda', 'type': 'disk', 'boot_index': '1' }, } self.assertEqual(expect, mapping)
def test_get_disk_mapping_simple_configdrive(self): # A simple disk mapping setup, but with configdrive added # It's necessary to check if the architecture is power, because # power doesn't have support to ide, and so libvirt translate # all ide calls to scsi self.flags(force_config_drive=True) user_context = context.RequestContext(self.user_id, self.project_id) instance_ref = db.instance_create(user_context, self.test_instance) mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide") # The last device is selected for this. on x86 is the last ide # device (hdd). Since power only support scsi, the last device # is sdz bus_ppc = ("scsi", "sdz") expect_bus = {"ppc": bus_ppc, "ppc64": bus_ppc} bus, dev = expect_bus.get(blockinfo.libvirt_utils.get_arch({}), ("ide", "hdd")) expect = { 'disk': {'bus': 'virtio', 'dev': 'vda', 'type': 'disk', 'boot_index': '1'}, 'disk.local': {'bus': 'virtio', 'dev': 'vdb', 'type': 'disk'}, 'disk.config': {'bus': bus, 'dev': dev, 'type': 'cdrom'}, 'root': {'bus': 'virtio', 'dev': 'vda', 'type': 'disk', 'boot_index': '1'} } self.assertEqual(expect, mapping)
def test_get_disk_mapping_simple_iso(self): # A simple disk mapping setup, but with a ISO for root device user_context = context.RequestContext(self.user_id, self.project_id) instance_ref = db.instance_create(user_context, self.test_instance) image_meta = {'disk_format': 'iso'} mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide", None, image_meta) expect = { 'disk': { 'bus': 'ide', 'dev': 'hda', 'type': 'cdrom', 'boot_index': '1' }, 'disk.local': { 'bus': 'virtio', 'dev': 'vda', 'type': 'disk' }, 'root': { 'bus': 'ide', 'dev': 'hda', 'type': 'cdrom', 'boot_index': '1' }, } self.assertEqual(expect, mapping)
def test_get_disk_mapping_ephemeral(self): # A disk mapping with ephemeral devices instance_ref = objects.Instance(**self.test_instance) instance_ref.flavor.swap = 5 image_meta = objects.ImageMeta.from_dict(self.test_image_meta) block_device_info = { 'ephemerals': [ {'device_type': 'disk', 'guest_format': 'ext4', 'device_name': '/dev/vdb', 'size': 10}, {'disk_bus': 'ide', 'guest_format': None, 'device_name': '/dev/vdc', 'size': 10}, {'device_type': 'floppy', 'device_name': '/dev/vdd', 'size': 10}, ] } mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide", image_meta, block_device_info) expect = { 'disk': {'bus': 'virtio', 'dev': 'vda', 'type': 'disk', 'boot_index': '1'}, 'disk.eph0': {'bus': 'virtio', 'dev': 'vdb', 'type': 'disk', 'format': 'ext4'}, 'disk.eph1': {'bus': 'ide', 'dev': 'vdc', 'type': 'disk'}, 'disk.eph2': {'bus': 'virtio', 'dev': 'vdd', 'type': 'floppy'}, 'disk.swap': {'bus': 'virtio', 'dev': 'vde', 'type': 'disk'}, 'root': {'bus': 'virtio', 'dev': 'vda', 'type': 'disk', 'boot_index': '1'}, } self.assertEqual(expect, mapping)
def test_get_disk_mapping_cdrom_configdrive(self): # A simple disk mapping setup, with configdrive added as cdrom # It's necessary to check if the architecture is power, because # power doesn't have support to ide, and so libvirt translate # all ide calls to scsi self.flags(force_config_drive=True) self.flags(config_drive_format="iso9660") instance_ref = objects.Instance(**self.test_instance) image_meta = objects.ImageMeta.from_dict(self.test_image_meta) mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide", image_meta) bus_ppc = ("scsi", "sdz") bus_aarch64 = ("scsi", "sdz") expect_bus = {"ppc": bus_ppc, "ppc64": bus_ppc, "ppc64le": bus_ppc, "aarch64": bus_aarch64} bus, dev = expect_bus.get(blockinfo.libvirt_utils.get_arch({}), ("ide", "hdd")) expect = { "disk": {"bus": "virtio", "dev": "vda", "type": "disk", "boot_index": "1"}, "disk.local": {"bus": "virtio", "dev": "vdb", "type": "disk"}, "disk.config": {"bus": bus, "dev": dev, "type": "cdrom"}, "root": {"bus": "virtio", "dev": "vda", "type": "disk", "boot_index": "1"}, } self.assertEqual(expect, mapping)
def test_get_disk_mapping_cdrom_configdrive(self): # A simple disk mapping setup, with configdrive added as cdrom # It's necessary to check if the architecture is power, because # power doesn't have support to ide, and so libvirt translate # all ide calls to scsi self.flags(force_config_drive=True) self.flags(config_drive_format='iso9660') instance_ref = objects.Instance(**self.test_instance) image_meta = objects.ImageMeta.from_dict(self.test_image_meta) mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide", image_meta) bus_ppc = ("scsi", "sdz") expect_bus = {"ppc": bus_ppc, "ppc64": bus_ppc} bus, dev = expect_bus.get(blockinfo.libvirt_utils.get_arch({}), ("ide", "hdd")) expect = { 'disk': {'bus': 'virtio', 'dev': 'vda', 'type': 'disk', 'boot_index': '1'}, 'disk.local': {'bus': 'virtio', 'dev': 'vdb', 'type': 'disk'}, 'disk.config': {'bus': bus, 'dev': dev, 'type': 'cdrom'}, 'root': {'bus': 'virtio', 'dev': 'vda', 'type': 'disk', 'boot_index': '1'} } self.assertEqual(expect, mapping)
def test_get_disk_mapping_simple_iso(self): # A simple disk mapping setup, but with a ISO for root device instance_ref = objects.Instance(**self.test_instance) image_meta = {'disk_format': 'iso'} mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide", image_meta) expect = { 'disk': { 'bus': 'ide', 'dev': 'hda', 'type': 'cdrom', 'boot_index': '1' }, 'disk.local': { 'bus': 'virtio', 'dev': 'vda', 'type': 'disk' }, 'root': { 'bus': 'ide', 'dev': 'hda', 'type': 'cdrom', 'boot_index': '1' }, } self.assertEqual(expect, mapping)
def test_get_disk_mapping_simple_configdrive(self): # A simple disk mapping setup, but with configdrive added # It's necessary to check if the architecture is power, because # power doesn't have support to ide, and so libvirt translate # all ide calls to scsi self.flags(force_config_drive=True) instance_ref = objects.Instance(**self.test_instance) image_meta = {} mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide", image_meta) # The last device is selected for this. on x86 is the last ide # device (hdd). Since power only support scsi, the last device # is sdz bus_ppc = ("scsi", "sdz") expect_bus = {"ppc": bus_ppc, "ppc64": bus_ppc} bus, dev = expect_bus.get(blockinfo.libvirt_utils.get_arch({}), ("ide", "hdd")) expect = { 'disk': {'bus': 'virtio', 'dev': 'vda', 'type': 'disk', 'boot_index': '1'}, 'disk.local': {'bus': 'virtio', 'dev': 'vdb', 'type': 'disk'}, 'disk.config': {'bus': bus, 'dev': dev, 'type': 'cdrom'}, 'root': {'bus': 'virtio', 'dev': 'vda', 'type': 'disk', 'boot_index': '1'} } self.assertEqual(expect, mapping)
def test_get_disk_mapping_ephemeral(self): # A disk mapping with ephemeral devices user_context = context.RequestContext(self.user_id, self.project_id) instance_ref = db.instance_create(user_context, self.test_instance) instance_ref['instance_type']['swap'] = 5 block_device_info = { 'ephemerals': [ {'num': 0, 'virtual_name': 'ephemeral0', 'device_name': '/dev/vdb', 'size': 10}, {'num': 1, 'virtual_name': 'ephemeral1', 'device_name': '/dev/vdc', 'size': 10}, {'num': 2, 'virtual_name': 'ephemeral2', 'device_name': '/dev/vdd', 'size': 10}, ] } mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide", block_device_info) expect = { 'disk': {'bus': 'virtio', 'dev': 'vda', 'type': 'disk'}, 'disk.eph0': {'bus': 'virtio', 'dev': 'vdb', 'type': 'disk'}, 'disk.eph1': {'bus': 'virtio', 'dev': 'vdc', 'type': 'disk'}, 'disk.eph2': {'bus': 'virtio', 'dev': 'vdd', 'type': 'disk'}, 'disk.swap': {'bus': 'virtio', 'dev': 'vde', 'type': 'disk'}, 'root': {'bus': 'virtio', 'dev': 'vda', 'type': 'disk'} } self.assertEqual(mapping, expect)
def test_get_disk_mapping_blockdev_many(self): # A disk mapping with a blockdev replacing all devices user_context = context.RequestContext(self.user_id, self.project_id) instance_ref = db.instance_create(user_context, self.test_instance) block_device_info = { 'block_device_mapping': [ { 'connection_info': "fake", 'mount_device': "/dev/vda", 'boot_index': 0, 'disk_bus': 'scsi', 'delete_on_termination': True }, { 'connection_info': "fake", 'mount_device': "/dev/vdb", 'boot_index': -1, 'delete_on_termination': True }, { 'connection_info': "fake", 'mount_device': "/dev/vdc", 'boot_index': -1, 'device_type': 'cdrom', 'delete_on_termination': True }, ] } mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide", block_device_info) expect = { '/dev/vda': { 'bus': 'scsi', 'dev': 'vda', 'type': 'disk', 'boot_index': '1' }, '/dev/vdb': { 'bus': 'virtio', 'dev': 'vdb', 'type': 'disk' }, '/dev/vdc': { 'bus': 'virtio', 'dev': 'vdc', 'type': 'cdrom' }, 'root': { 'bus': 'scsi', 'dev': 'vda', 'type': 'disk', 'boot_index': '1' }, } self.assertEqual(mapping, expect)
def test_get_disk_mapping_lxc(self): # A simple disk mapping setup, but for lxc user_context = context.RequestContext(self.user_id, self.project_id) instance_ref = db.instance_create(user_context, self.test_instance) mapping = blockinfo.get_disk_mapping("lxc", instance_ref, "lxc", "lxc", None) expect = { "disk": {"bus": "lxc", "dev": None, "type": "disk"}, "root": {"bus": "lxc", "dev": None, "type": "disk"}, } self.assertEqual(mapping, expect)
def test_get_disk_mapping_updates_original(self): instance_ref = objects.Instance(**self.test_instance) image_meta = objects.ImageMeta.from_dict(self.test_image_meta) block_device_info = { 'root_device_name': '/dev/vda', 'swap': {'device_name': '/dev/vdb', 'device_type': 'really_lame_type', 'swap_size': 10}, 'ephemerals': [{'disk_bus': 'no_such_bus', 'device_type': 'yeah_right', 'device_name': '/dev/vdc', 'size': 10}], 'block_device_mapping': [ {'connection_info': "fake", 'mount_device': None, 'device_type': 'lawnmower', 'delete_on_termination': True}] } expected_swap = {'device_name': '/dev/vdb', 'disk_bus': 'virtio', 'device_type': 'disk', 'swap_size': 10} expected_ephemeral = {'disk_bus': 'virtio', 'device_type': 'disk', 'device_name': '/dev/vdc', 'size': 10} expected_bdm = {'connection_info': "fake", 'mount_device': '/dev/vdd', 'device_type': 'disk', 'disk_bus': 'virtio', 'delete_on_termination': True} blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide", image_meta, block_device_info) self.assertEqual(expected_swap, block_device_info['swap']) self.assertEqual(expected_ephemeral, block_device_info['ephemerals'][0]) self.assertEqual(expected_bdm, block_device_info['block_device_mapping'][0])
def test_get_disk_mapping_lxc(self): # A simple disk mapping setup, but for lxc self.test_instance["ephemeral_gb"] = 0 instance_ref = objects.Instance(**self.test_instance) image_meta = objects.ImageMeta.from_dict(self.test_image_meta) mapping = blockinfo.get_disk_mapping("lxc", instance_ref, "lxc", "lxc", image_meta) expect = { "disk": {"bus": "lxc", "dev": None, "type": "disk", "boot_index": "1"}, "root": {"bus": "lxc", "dev": None, "type": "disk", "boot_index": "1"}, } self.assertEqual(expect, mapping)
def test_get_disk_mapping_updates_original(self): instance_ref = objects.Instance(**self.test_instance) image_meta = {} block_device_info = { 'root_device_name': '/dev/vda', 'swap': {'device_name': '/dev/vdb', 'device_type': 'really_lame_type', 'swap_size': 10}, 'ephemerals': [{'disk_bus': 'no_such_bus', 'device_type': 'yeah_right', 'device_name': '/dev/vdc', 'size': 10}], 'block_device_mapping': [ {'connection_info': "fake", 'mount_device': None, 'device_type': 'lawnmower', 'delete_on_termination': True}] } expected_swap = {'device_name': '/dev/vdb', 'disk_bus': 'virtio', 'device_type': 'disk', 'swap_size': 10} expected_ephemeral = {'disk_bus': 'virtio', 'device_type': 'disk', 'device_name': '/dev/vdc', 'size': 10} expected_bdm = {'connection_info': "fake", 'mount_device': '/dev/vdd', 'device_type': 'disk', 'disk_bus': 'virtio', 'delete_on_termination': True} blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide", image_meta, block_device_info) self.assertEqual(expected_swap, block_device_info['swap']) self.assertEqual(expected_ephemeral, block_device_info['ephemerals'][0]) self.assertEqual(expected_bdm, block_device_info['block_device_mapping'][0])
def test_get_disk_mapping_updates_original(self): instance_ref = objects.Instance(**self.test_instance) image_meta = objects.ImageMeta.from_dict(self.test_image_meta) block_device_info = { "root_device_name": "/dev/vda", "swap": {"device_name": "/dev/vdb", "device_type": "really_lame_type", "swap_size": 10}, "ephemerals": [ {"disk_bus": "no_such_bus", "device_type": "yeah_right", "device_name": "/dev/vdc", "size": 10} ], "block_device_mapping": [ { "connection_info": "fake", "mount_device": None, "device_type": "lawnmower", "delete_on_termination": True, } ], } expected_swap = {"device_name": "/dev/vdb", "disk_bus": "virtio", "device_type": "disk", "swap_size": 10} expected_ephemeral = {"disk_bus": "virtio", "device_type": "disk", "device_name": "/dev/vdc", "size": 10} expected_bdm = { "connection_info": "fake", "mount_device": "/dev/vdd", "device_type": "disk", "disk_bus": "virtio", "delete_on_termination": True, } with mock.patch.object(instance_ref, "get_flavor") as get_flavor_mock: blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide", image_meta, block_device_info) # we should have gotten the swap info from block_device_info rather # than the flavor information on the instance self.assertFalse(get_flavor_mock.called) self.assertEqual(expected_swap, block_device_info["swap"]) self.assertEqual(expected_ephemeral, block_device_info["ephemerals"][0]) self.assertEqual(expected_bdm, block_device_info["block_device_mapping"][0])
def test_get_disk_mapping_lxc(self): # A simple disk mapping setup, but for lxc user_context = context.RequestContext(self.user_id, self.project_id) instance_ref = db.instance_create(user_context, self.test_instance) mapping = blockinfo.get_disk_mapping("lxc", instance_ref, "lxc", "lxc", None) expect = { 'disk': {'bus': 'lxc', 'dev': None, 'type': 'disk'}, 'root': {'bus': 'lxc', 'dev': None, 'type': 'disk'} } self.assertEqual(mapping, expect)
def test_get_disk_mapping_simple(self): # The simplest possible disk mapping setup, all defaults instance_ref = objects.Instance(**self.test_instance) image_meta = {} mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide", image_meta) expect = { "disk": {"bus": "virtio", "dev": "vda", "type": "disk", "boot_index": "1"}, "disk.local": {"bus": "virtio", "dev": "vdb", "type": "disk"}, "root": {"bus": "virtio", "dev": "vda", "type": "disk", "boot_index": "1"}, } self.assertEqual(expect, mapping)
def test_get_disk_mapping_rescue(self): # A simple disk mapping setup, but in rescue mode user_context = context.RequestContext(self.user_id, self.project_id) instance_ref = db.instance_create(user_context, self.test_instance) mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide", rescue=True) expect = { "disk.rescue": {"bus": "virtio", "dev": "vda", "type": "disk"}, "disk": {"bus": "virtio", "dev": "vdb", "type": "disk"}, "root": {"bus": "virtio", "dev": "vda", "type": "disk"}, } self.assertEqual(mapping, expect)
def test_get_disk_mapping_rescue(self): # A simple disk mapping setup, but in rescue mode instance_ref = objects.Instance(**self.test_instance) image_meta = objects.ImageMeta.from_dict(self.test_image_meta) mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide", image_meta, rescue=True) expect = { "disk.rescue": {"bus": "virtio", "dev": "vda", "type": "disk", "boot_index": "1"}, "disk": {"bus": "virtio", "dev": "vdb", "type": "disk"}, "root": {"bus": "virtio", "dev": "vda", "type": "disk", "boot_index": "1"}, } self.assertEqual(expect, mapping)
def test_get_disk_mapping_simple(self): # The simplest possible disk mapping setup, all defaults user_context = context.RequestContext(self.user_id, self.project_id) instance_ref = db.instance_create(user_context, self.test_instance) mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide") expect = { "disk": {"bus": "virtio", "dev": "vda", "type": "disk"}, "disk.local": {"bus": "virtio", "dev": "vdb", "type": "disk"}, "root": {"bus": "virtio", "dev": "vda", "type": "disk"}, } self.assertEqual(mapping, expect)
def test_get_disk_mapping_simple_iso(self): # A simple disk mapping setup, but with a ISO for root device instance_ref = objects.Instance(**self.test_instance) image_meta = objects.ImageMeta.from_dict({"disk_format": "iso"}) mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide", image_meta) expect = { "disk": {"bus": "ide", "dev": "hda", "type": "cdrom", "boot_index": "1"}, "disk.local": {"bus": "virtio", "dev": "vda", "type": "disk"}, "root": {"bus": "ide", "dev": "hda", "type": "cdrom", "boot_index": "1"}, } self.assertEqual(expect, mapping)
def test_get_disk_mapping_updates_original(self): user_context = context.RequestContext(self.user_id, self.project_id) instance_ref = db.instance_create(user_context, self.test_instance) block_device_info = { 'root_device_name': '/dev/vda', 'swap': {'device_name': '/dev/vdb', 'device_type': 'really_lame_type', 'swap_size': 10}, 'ephemerals': [{'disk_bus': 'no_such_bus', 'device_type': 'yeah_right', 'device_name': '/dev/vdc', 'size': 10}], 'block_device_mapping': [ {'connection_info': "fake", 'mount_device': None, 'device_type': 'lawnmower', 'delete_on_termination': True}] } expected_swap = {'device_name': '/dev/vdb', 'disk_bus': 'virtio', 'device_type': 'disk', 'swap_size': 10} expected_ephemeral = {'disk_bus': 'virtio', 'device_type': 'disk', 'device_name': '/dev/vdc', 'size': 10} expected_bdm = {'connection_info': "fake", 'mount_device': '/dev/vdd', 'device_type': 'disk', 'disk_bus': 'virtio', 'delete_on_termination': True} blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide", block_device_info) self.assertEqual(expected_swap, block_device_info['swap']) self.assertEqual(expected_ephemeral, block_device_info['ephemerals'][0]) self.assertEqual(expected_bdm, block_device_info['block_device_mapping'][0])
def test_get_disk_mapping_simple(self): # The simplest possible disk mapping setup, all defaults user_context = context.RequestContext(self.user_id, self.project_id) instance_ref = db.instance_create(user_context, self.test_instance) mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide") expect = { 'disk': {'bus': 'virtio', 'dev': 'vda', 'type': 'disk'}, 'disk.local': {'bus': 'virtio', 'dev': 'vdb', 'type': 'disk'}, 'root': {'bus': 'virtio', 'dev': 'vda', 'type': 'disk'} } self.assertEqual(mapping, expect)
def test_get_disk_mapping_custom_swap(self): # A disk mapping with a swap device at position vdb. This # should cause disk.local to be removed instance_ref = objects.Instance(**self.test_instance) image_meta = objects.ImageMeta.from_dict(self.test_image_meta) block_device_info = {"swap": {"device_name": "/dev/vdb", "swap_size": 10}} mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide", image_meta, block_device_info) expect = { "disk": {"bus": "virtio", "dev": "vda", "type": "disk", "boot_index": "1"}, "disk.swap": {"bus": "virtio", "dev": "vdb", "type": "disk"}, "root": {"bus": "virtio", "dev": "vda", "type": "disk", "boot_index": "1"}, } self.assertEqual(expect, mapping)
def test_get_disk_mapping_simple_rootdev(self): # A simple disk mapping setup, but with custom root device name instance_ref = objects.Instance(**self.test_instance) image_meta = objects.ImageMeta.from_dict(self.test_image_meta) block_device_info = {"root_device_name": "/dev/sda"} mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide", image_meta, block_device_info) expect = { "disk": {"bus": "scsi", "dev": "sda", "type": "disk", "boot_index": "1"}, "disk.local": {"bus": "virtio", "dev": "vda", "type": "disk"}, "root": {"bus": "scsi", "dev": "sda", "type": "disk", "boot_index": "1"}, } self.assertEqual(expect, mapping)
def test_get_disk_mapping_lxc(self): # A simple disk mapping setup, but for lxc self.test_instance['ephemeral_gb'] = 0 instance_ref = objects.Instance(**self.test_instance) mapping = blockinfo.get_disk_mapping("lxc", instance_ref, "lxc", "lxc", None) expect = { 'disk': {'bus': 'lxc', 'dev': None, 'type': 'disk', 'boot_index': '1'}, 'root': {'bus': 'lxc', 'dev': None, 'type': 'disk', 'boot_index': '1'}, } self.assertEqual(expect, mapping)
def test_get_disk_mapping_disk_configdrive(self): # A simple disk mapping setup, with configdrive added as disk self.flags(force_config_drive=True) self.flags(config_drive_format='vfat') instance_ref = objects.Instance(**self.test_instance) mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide") expect = { 'disk': {'bus': 'virtio', 'dev': 'vda', 'type': 'disk', 'boot_index': '1'}, 'disk.local': {'bus': 'virtio', 'dev': 'vdb', 'type': 'disk'}, 'disk.config': {'bus': 'virtio', 'dev': 'vdz', 'type': 'disk'}, 'root': {'bus': 'virtio', 'dev': 'vda', 'type': 'disk', 'boot_index': '1'}, } self.assertEqual(expect, mapping)
def test_get_disk_mapping_complex(self): # The strangest possible disk mapping setup instance_ref = objects.Instance(**self.test_instance) image_meta = {} block_device_info = { 'root_device_name': '/dev/vdf', 'swap': {'device_name': '/dev/vdy', 'swap_size': 10}, 'ephemerals': [ {'device_type': 'disk', 'guest_format': 'ext4', 'device_name': '/dev/vdb', 'size': 10}, {'disk_bus': 'ide', 'guest_format': None, 'device_name': '/dev/vdc', 'size': 10}, ], 'block_device_mapping': [ {'connection_info': "fake", 'mount_device': "/dev/vda", 'boot_index': 1, 'delete_on_termination': True}, ] } mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide", image_meta, block_device_info) expect = { 'disk': {'bus': 'virtio', 'dev': 'vdf', 'type': 'disk', 'boot_index': '1'}, '/dev/vda': {'bus': 'virtio', 'dev': 'vda', 'type': 'disk', 'boot_index': '2'}, 'disk.eph0': {'bus': 'virtio', 'dev': 'vdb', 'type': 'disk', 'format': 'ext4'}, 'disk.eph1': {'bus': 'ide', 'dev': 'vdc', 'type': 'disk'}, 'disk.swap': {'bus': 'virtio', 'dev': 'vdy', 'type': 'disk'}, 'root': {'bus': 'virtio', 'dev': 'vdf', 'type': 'disk', 'boot_index': '1'}, } self.assertEqual(expect, mapping)
def test_get_disk_mapping_blockdev_root(self): # A disk mapping with a blockdev replacing the default root instance_ref = objects.Instance(**self.test_instance) image_meta = {} block_device_info = { 'block_device_mapping': [ { 'connection_info': "fake", 'mount_device': "/dev/vda", 'boot_index': 0, 'device_type': 'disk', 'delete_on_termination': True }, ] } mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide", image_meta, block_device_info) expect = { '/dev/vda': { 'bus': 'virtio', 'dev': 'vda', 'type': 'disk', 'boot_index': '1' }, 'disk.local': { 'bus': 'virtio', 'dev': 'vdb', 'type': 'disk' }, 'root': { 'bus': 'virtio', 'dev': 'vda', 'type': 'disk', 'boot_index': '1' }, } self.assertEqual(expect, mapping)
def test_get_disk_mapping_complex(self): # The strangest possible disk mapping setup user_context = context.RequestContext(self.user_id, self.project_id) instance_ref = db.instance_create(user_context, self.test_instance) block_device_info = { 'root_device_name': '/dev/vdf', 'swap': {'device_name': '/dev/vdy', 'swap_size': 10}, 'ephemerals': [ {'device_type': 'disk', 'guest_format': 'ext3', 'device_name': '/dev/vdb', 'size': 10}, {'disk_bus': 'ide', 'guest_format': None, 'device_name': '/dev/vdc', 'size': 10}, ], 'block_device_mapping': [ {'connection_info': "fake", 'mount_device': "/dev/vda", 'boot_index': 1, 'delete_on_termination': True}, ] } mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide", block_device_info) expect = { 'disk': {'bus': 'virtio', 'dev': 'vdf', 'type': 'disk', 'boot_index': '1'}, '/dev/vda': {'bus': 'virtio', 'dev': 'vda', 'type': 'disk', 'boot_index': '2'}, 'disk.eph0': {'bus': 'virtio', 'dev': 'vdb', 'type': 'disk', 'format': 'ext3'}, 'disk.eph1': {'bus': 'ide', 'dev': 'vdc', 'type': 'disk'}, 'disk.swap': {'bus': 'virtio', 'dev': 'vdy', 'type': 'disk'}, 'root': {'bus': 'virtio', 'dev': 'vdf', 'type': 'disk', 'boot_index': '1'}, } self.assertEqual(expect, mapping)
def test_get_disk_mapping_custom_swap(self): # A disk mapping with a swap device at position vdb. This # should cause disk.local to be removed instance_ref = objects.Instance(**self.test_instance) image_meta = {} block_device_info = { 'swap': {'device_name': '/dev/vdb', 'swap_size': 10}, } mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide", image_meta, block_device_info) expect = { 'disk': {'bus': 'virtio', 'dev': 'vda', 'type': 'disk', 'boot_index': '1'}, 'disk.swap': {'bus': 'virtio', 'dev': 'vdb', 'type': 'disk'}, 'root': {'bus': 'virtio', 'dev': 'vda', 'type': 'disk', 'boot_index': '1'}, } self.assertEqual(expect, mapping)
def test_get_disk_mapping_ephemeral(self): # A disk mapping with ephemeral devices user_context = context.RequestContext(self.user_id, self.project_id) self.test_instance['system_metadata']['instance_type_swap'] = 5 instance_ref = db.instance_create(user_context, self.test_instance) block_device_info = { 'ephemerals': [ { 'num': 0, 'virtual_name': 'ephemeral0', 'device_name': '/dev/vdb', 'size': 10 }, { 'num': 1, 'virtual_name': 'ephemeral1', 'device_name': '/dev/vdc', 'size': 10 }, { 'num': 2, 'virtual_name': 'ephemeral2', 'device_name': '/dev/vdd', 'size': 10 }, ] } mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide", block_device_info) expect = { 'disk': { 'bus': 'virtio', 'dev': 'vda', 'type': 'disk' }, 'disk.eph0': { 'bus': 'virtio', 'dev': 'vdb', 'type': 'disk' }, 'disk.eph1': { 'bus': 'virtio', 'dev': 'vdc', 'type': 'disk' }, 'disk.eph2': { 'bus': 'virtio', 'dev': 'vdd', 'type': 'disk' }, 'disk.swap': { 'bus': 'virtio', 'dev': 'vde', 'type': 'disk' }, 'root': { 'bus': 'virtio', 'dev': 'vda', 'type': 'disk' } } self.assertEqual(mapping, expect)