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_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_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_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_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)
