def test_swap_is_usable(self):
self.assertFalse(driver.swap_is_usable(None))
self.assertFalse(driver.swap_is_usable({'device_name': None}))
self.assertFalse(driver.swap_is_usable({'device_name': '/dev/sdb',
'swap_size': 0}))
self.assertTrue(driver.swap_is_usable({'device_name': '/dev/sdb',
'swap_size': 1}))
def test_swap_is_usable(self):
self.assertFalse(driver.swap_is_usable(None))
self.assertFalse(driver.swap_is_usable({'device_name': None}))
self.assertFalse(driver.swap_is_usable({'device_name': '/dev/sdb',
'swap_size': 0}))
self.assertTrue(driver.swap_is_usable({'device_name': '/dev/sdb',
'swap_size': 1}))
def volume_in_mapping(mount_device, block_device_info):
block_device_list = [
block_device.strip_dev(volume['mount_device'])
for volume in driver.block_device_info_get_mapping(block_device_info)
]
swap = driver.block_device_info_get_swap(block_device_info)
if driver.swap_is_usable(swap):
block_device_list.append(block_device.strip_dev(swap['device_name']))
block_device_list.extend([
block_device.strip_dev(ephemeral['device_name']) for ephemeral in
driver.block_device_info_get_ephemerals(block_device_info)
])
def volume_in_mapping(mount_device, block_device_info):
block_device_list = [
block_device.strip_dev(volume['mount_device']) for volume in
driver.block_device_info_get_mapping(block_device_info)
]
swap = driver.block_device_info_get_swap(block_device_info)
if driver.swap_is_usable(swap):
block_device_list.append(block_device.strip_dev(
swap['device_name']))
block_device_list.extend([
block_device.strip_dev(ephemeral['device_name']) for ephemeral in
driver.block_device_info_get_ephemerals(block_device_info)])
def create_container(self, instance, injected_files,
block_device_info, rescue):
LOG.debug('Creating container config')
# Ensure the directory exists and is writable
fileutils.ensure_tree(
self.container_dir.get_instance_dir(instance.name))
# Check to see if we are using swap.
swap = driver.block_device_info_get_swap(block_device_info)
if driver.swap_is_usable(swap):
msg = _('Swap space is not supported by LXD.')
raise exception.NovaException(msg)
# Check to see if ephemeral block devices exist.
ephemeral_gb = instance.ephemeral_gb
if ephemeral_gb > 0:
msg = _('Ephemeral block devices is not supported.')
raise exception.NovaException(msg)
container_config = self._init_container_config()
container_config = self.add_config(container_config, 'name',
instance.name)
container_config = self.add_config(container_config, 'profiles',
[str(CONF.lxd.default_profile)])
container_config = self.configure_container_config(container_config,
instance)
''' Create an LXD image '''
container_config = (
self.add_config(container_config, 'source',
self.configure_lxd_image(container_config,
instance)))
if configdrive.required_by(instance):
container_configdrive = (
self.configure_container_configdrive(
container_config,
instance,
injected_files))
LOG.debug(pprint.pprint(container_configdrive))
if rescue:
container_rescue_devices = (
self.configure_container_rescuedisk(
container_config,
instance))
LOG.debug(pprint.pprint(container_rescue_devices))
return container_config
def volume_in_mapping(mount_device, block_device_info):
block_device_list = [
strip_dev(vol["mount_device"]) for vol in driver.block_device_info_get_mapping(block_device_info)
]
swap = driver.block_device_info_get_swap(block_device_info)
if driver.swap_is_usable(swap):
block_device_list.append(strip_dev(swap["device_name"]))
block_device_list += [
strip_dev(ephemeral["device_name"]) for ephemeral in driver.block_device_info_get_ephemerals(block_device_info)
]
LOG.debug(_("block_device_list %s"), block_device_list)
return strip_dev(mount_device) in block_device_list
def volume_in_mapping(self, mount_device, block_device_info):
block_device_list = [block_device.strip_dev(vol['mount_device'])
for vol in
driver.block_device_info_get_mapping(
block_device_info)]
swap = driver.block_device_info_get_swap(block_device_info)
if driver.swap_is_usable(swap):
block_device_list.append(
block_device.strip_dev(swap['device_name']))
block_device_list += [block_device.strip_dev(
ephemeral['device_name'])
for ephemeral in
driver.block_device_info_get_ephemerals(block_device_info)]
LOG.debug(_("block_device_list %s"), block_device_list)
return block_device.strip_dev(mount_device) in block_device_list
def volume_in_mapping(self, mount_device, block_device_info):
block_device_list = [block_device.strip_dev(vol['mount_device'])
for vol in
driver.block_device_info_get_mapping(
block_device_info)]
swap = driver.block_device_info_get_swap(block_device_info)
if driver.swap_is_usable(swap):
block_device_list.append(
block_device.strip_dev(swap['device_name']))
block_device_list += [block_device.strip_dev(
ephemeral['device_name'])
for ephemeral in
driver.block_device_info_get_ephemerals(block_device_info)]
LOG.debug("block_device_list %s", block_device_list)
return block_device.strip_dev(mount_device) in block_device_list
def volume_in_mapping(mount_device, block_device_info):
block_device_list = [strip_dev(vol['mount_device'])
for vol in
driver.block_device_info_get_mapping(
block_device_info)]
swap = driver.block_device_info_get_swap(block_device_info)
if driver.swap_is_usable(swap):
block_device_list.append(strip_dev(swap['device_name']))
block_device_list += [strip_dev(ephemeral['device_name'])
for ephemeral in
driver.block_device_info_get_ephemerals(
block_device_info)]
LOG.debug("block_device_list %s", sorted(filter(None, block_device_list)))
return strip_dev(mount_device) in block_device_list
def get_disk_mapping(virt_type,
instance,
disk_bus,
cdrom_bus,
block_device_info=None,
image_meta=None,
rescue=False):
"""Determine how to map default disks to the virtual machine.
This is about figuring out whether the default 'disk',
'disk.local', 'disk.swap' and 'disk.config' images have
been overriden by the block device mapping.
Returns the guest disk mapping for the devices."""
inst_type = flavors.extract_instance_type(instance)
mapping = {}
if virt_type == "lxc":
# NOTE(zul): This information is not used by the libvirt driver
# however we need to populate mapping so the image can be
# created when the instance is started. This can
# be removed when we convert LXC to use block devices.
root_disk_bus = disk_bus
root_device_type = 'disk'
root_info = get_next_disk_info(mapping, root_disk_bus,
root_device_type)
mapping['root'] = root_info
mapping['disk'] = root_info
return mapping
if rescue:
rescue_info = get_next_disk_info(mapping, disk_bus)
mapping['disk.rescue'] = rescue_info
mapping['root'] = rescue_info
os_info = get_next_disk_info(mapping, disk_bus)
mapping['disk'] = os_info
return mapping
if image_meta and image_meta.get('disk_format') == 'iso':
root_disk_bus = cdrom_bus
root_device_type = 'cdrom'
else:
root_disk_bus = disk_bus
root_device_type = 'disk'
root_device_name = driver.block_device_info_get_root(block_device_info)
if root_device_name is not None:
root_device = block_device.strip_dev(root_device_name)
root_info = {
'bus': get_disk_bus_for_disk_dev(virt_type, root_device),
'dev': root_device,
'type': root_device_type
}
else:
root_info = get_next_disk_info(mapping, root_disk_bus,
root_device_type)
mapping['root'] = root_info
if not block_device.volume_in_mapping(root_info['dev'], block_device_info):
mapping['disk'] = root_info
eph_info = get_next_disk_info(mapping, disk_bus)
ephemeral_device = False
if not (block_device.volume_in_mapping(eph_info['dev'], block_device_info)
or 0 in [
eph['num'] for eph in driver.block_device_info_get_ephemerals(
block_device_info)
]):
if instance['ephemeral_gb'] > 0:
ephemeral_device = True
if ephemeral_device:
mapping['disk.local'] = eph_info
for eph in driver.block_device_info_get_ephemerals(block_device_info):
disk_dev = block_device.strip_dev(eph['device_name'])
disk_bus = get_disk_bus_for_disk_dev(virt_type, disk_dev)
mapping[get_eph_disk(eph)] = {
'bus': disk_bus,
'dev': disk_dev,
'type': 'disk'
}
swap = driver.block_device_info_get_swap(block_device_info)
if driver.swap_is_usable(swap):
disk_dev = block_device.strip_dev(swap['device_name'])
disk_bus = get_disk_bus_for_disk_dev(virt_type, disk_dev)
mapping['disk.swap'] = {
'bus': disk_bus,
'dev': disk_dev,
'type': 'disk'
}
elif inst_type['swap'] > 0:
swap_info = get_next_disk_info(mapping, disk_bus)
if not block_device.volume_in_mapping(swap_info['dev'],
block_device_info):
mapping['disk.swap'] = swap_info
block_device_mapping = driver.block_device_info_get_mapping(
block_device_info)
for vol in block_device_mapping:
disk_dev = vol['mount_device'].rpartition("/")[2]
disk_bus = get_disk_bus_for_disk_dev(virt_type, disk_dev)
mapping[vol['mount_device']] = {
'bus': disk_bus,
'dev': disk_dev,
'type': 'disk'
}
if configdrive.enabled_for(instance):
config_info = get_next_disk_info(mapping, disk_bus, last_device=True)
mapping['disk.config'] = config_info
return mapping
def get_disk_mapping(virt_type, instance,
disk_bus, cdrom_bus,
block_device_info=None,
image_meta=None, rescue=False):
"""Determine how to map default disks to the virtual machine.
This is about figuring out whether the default 'disk',
'disk.local', 'disk.swap' and 'disk.config' images have
been overriden by the block device mapping.
Returns the guest disk mapping for the devices.
"""
inst_type = flavors.extract_flavor(instance)
mapping = {}
if virt_type == "lxc":
# NOTE(zul): This information is not used by the libvirt driver
# however we need to populate mapping so the image can be
# created when the instance is started. This can
# be removed when we convert LXC to use block devices.
root_disk_bus = disk_bus
root_device_type = 'disk'
root_info = get_next_disk_info(mapping,
root_disk_bus,
root_device_type)
mapping['root'] = root_info
mapping['disk'] = root_info
return mapping
if rescue:
rescue_info = get_next_disk_info(mapping,
disk_bus)
mapping['disk.rescue'] = rescue_info
mapping['root'] = rescue_info
os_info = get_next_disk_info(mapping,
disk_bus)
mapping['disk'] = os_info
return mapping
if image_meta and image_meta.get('disk_format') == 'iso':
root_disk_bus = cdrom_bus
root_device_type = 'cdrom'
else:
root_disk_bus = disk_bus
root_device_type = 'disk'
root_device_name = driver.block_device_info_get_root(block_device_info)
if root_device_name is not None:
root_device = block_device.strip_dev(root_device_name)
root_info = {'bus': get_disk_bus_for_disk_dev(virt_type,
root_device),
'dev': root_device,
'type': root_device_type}
else:
root_info = get_next_disk_info(mapping,
root_disk_bus,
root_device_type)
mapping['root'] = root_info
if not block_device.volume_in_mapping(root_info['dev'],
block_device_info):
mapping['disk'] = root_info
eph_info = get_next_disk_info(mapping,
disk_bus)
ephemeral_device = False
if not (block_device.volume_in_mapping(eph_info['dev'],
block_device_info) or
0 in [eph['num'] for eph in
driver.block_device_info_get_ephemerals(
block_device_info)]):
if instance['ephemeral_gb'] > 0:
ephemeral_device = True
if ephemeral_device:
mapping['disk.local'] = eph_info
for eph in driver.block_device_info_get_ephemerals(
block_device_info):
disk_dev = block_device.strip_dev(eph['device_name'])
disk_bus = get_disk_bus_for_disk_dev(virt_type, disk_dev)
mapping[get_eph_disk(eph)] = {'bus': disk_bus,
'dev': disk_dev,
'type': 'disk'}
swap = driver.block_device_info_get_swap(block_device_info)
if driver.swap_is_usable(swap):
disk_dev = block_device.strip_dev(swap['device_name'])
disk_bus = get_disk_bus_for_disk_dev(virt_type, disk_dev)
mapping['disk.swap'] = {'bus': disk_bus,
'dev': disk_dev,
'type': 'disk'}
elif inst_type['swap'] > 0:
swap_info = get_next_disk_info(mapping,
disk_bus)
if not block_device.volume_in_mapping(swap_info['dev'],
block_device_info):
mapping['disk.swap'] = swap_info
block_device_mapping = driver.block_device_info_get_mapping(
block_device_info)
for vol in block_device_mapping:
disk_dev = vol['mount_device'].rpartition("/")[2]
disk_bus = get_disk_bus_for_disk_dev(virt_type, disk_dev)
mapping[vol['mount_device']] = {'bus': disk_bus,
'dev': disk_dev,
'type': 'disk'}
if configdrive.required_by(instance):
config_info = get_next_disk_info(mapping,
disk_bus,
last_device=True)
mapping['disk.config'] = config_info
return mapping
def test_swap_is_usable(self):
self.assertFalse(driver.swap_is_usable(None))
self.assertFalse(driver.swap_is_usable({"device_name": None}))
self.assertFalse(driver.swap_is_usable({"device_name": "/dev/sdb", "swap_size": 0}))
self.assertTrue(driver.swap_is_usable({"device_name": "/dev/sdb", "swap_size": 1}))
def create_container(self, context, instance, image_meta, injected_files,
admin_password, network_info, block_device_info,
name_label=None, rescue=False, host=None):
LOG.debug('Creating instance')
name = instance.uuid
if rescue:
name = name_label
# Ensure the directory exists and is writable
fileutils.ensure_tree(
self.container_dir.get_instance_dir(name))
# Check to see if we are using swap.
swap = driver.block_device_info_get_swap(block_device_info)
if driver.swap_is_usable(swap):
msg = _('Swap space is not supported by LXD.')
raise exception.NovaException(msg)
# Check to see if ephemeral block devices exist.
ephemeral_gb = instance.ephemeral_gb
if ephemeral_gb > 0:
msg = _('Ephemeral block devices is not supported.')
raise exception.NovaException(msg)
name = instance.uuid
if rescue:
name = name_label
container_config = self._init_container_config()
container_config = self.configure_container_config(name,
container_config, instance)
''' Create an LXD image '''
self.img_driver.setup_image(context, instance, image_meta, host=host)
container_config = (
self.add_config(container_config, 'source',
self.configure_lxd_image(container_config,
instance, image_meta)))
LOG.debug(pprint.pprint(container_config))
(state, data) = self.container_client.client('init', container_config=container_config,
host=host)
self.container_client.client('wait', oid=data.get('operation').split('/')[3],
host=host)
if configdrive.required_by(instance):
container_configdrive = (
self.configure_container_configdrive(
container_config,
instance,
injected_files,
admin_password))
LOG.debug(pprint.pprint(container_configdrive))
self.container_client.client('update', instnace=name,
container_config=container_configdrive,
host=host)
if network_info:
container_network_devices = (
self.configure_network_devices(
container_config,
instance,
network_info))
LOG.debug(pprint.pprint(container_network_devices))
self.container_client.client('update', instance=name,
container_config=container_network_devices,
host=host)
if rescue:
container_rescue_devices = (
self.configure_container_rescuedisk(
container_config,
instance))
LOG.debug(pprint.pprint(container_rescue_devices))
self.container_client.client('update', instnace=name,
container_config=container_rescue_devices,
host=host)
return container_config
