def update_container_data(storage, request: DeviceFactoryRequest,
container_name):
"""Update the container data in the device factory request.
:param storage: an instance of Blivet
:param request: a device factory request
:param container_name: a container name to apply
"""
# Reset all container data.
request.reset_container_data()
# Check the device type.
if request.device_type not in CONTAINER_DEVICE_TYPES:
raise StorageError("Invalid device type.")
# Find the container in the device tree if any.
container = storage.devicetree.get_device_by_name(container_name)
if container:
# Set the request from the found container.
request.container_spec = container.name
request.container_name = container.name
request.container_encrypted = container.encrypted
request.container_raid_level = get_device_raid_level_name(container)
request.container_size_policy = get_container_size_policy(container)
# Use the container's disks.
request.disks = [d.name for d in container.disks]
else:
# Set the request from the new container.
request.container_name = container_name
request.container_raid_level = get_default_container_raid_level_name(
request.device_type)
def generate_container_data(storage, request: DeviceFactoryRequest):
"""Generate the container data for the device factory request.
:param storage: an instance of Blivet
:param request: a device factory request
"""
# Reset all container data.
request.reset_container_data()
# Check the device type.
if request.device_type not in CONTAINER_DEVICE_TYPES:
return
# Find a container of the requested type.
device = storage.devicetree.resolve_device(request.device_spec)
container = get_container(storage, request.device_type, device.raw_device)
if container:
# Set the request from the found container.
request.container_spec = container.name
request.container_name = container.name
request.container_encrypted = container.encrypted
request.container_raid_level = get_device_raid_level_name(container)
request.container_size_policy = get_container_size_policy(container)
else:
# Set the request from a new container.
request.container_name = storage.suggest_container_name()
request.container_raid_level = get_default_container_raid_level_name(
request.device_type)
def _add_device(self,
storage,
request: DeviceFactoryRequest,
use_existing_container=False):
"""Add a device to the storage model.
:param storage: an instance of Blivet
:param request: a device factory request
:param use_existing_container: should we use an existing container?
:raise: StorageError if the device cannot be created
"""
# Create the device factory.
factory = devicefactory.get_device_factory(
storage,
device_type=request.device_type,
size=Size(request.device_size) if request.device_size else None)
# Find a container.
container = factory.get_container(
allow_existing=use_existing_container)
if use_existing_container and not container:
raise StorageError("No existing container found.")
# Update the device info.
if container:
# Don't override user-initiated changes to a defined container.
request.disks = [d.name for d in container.disks]
request.container_encrypted = container.encrypted
request.container_raid_level = get_device_raid_level_name(
container)
request.container_size_policy = get_container_size_policy(
container)
# The existing container has a name.
if use_existing_container:
request.container_name = container.name
# The container is already encrypted
if container.encrypted:
request.device_encrypted = False
# Create the device.
dev_info = get_device_factory_arguments(storage, request)
try:
storage.factory_device(**dev_info)
except StorageError as e:
log.error("The device creation has failed: %s", e)
raise
except OverflowError as e:
log.error("Invalid partition size set: %s", str(e))
raise StorageError(
"Invalid partition size set. Use a valid integer.") from None
def reset_device_factory_request_test(self):
"""Test reset_container_data."""
default = DeviceFactoryRequest()
request = DeviceFactoryRequest()
request.container_spec = "dev1"
request.container_name = "dev1"
request.container_size_policy = 123
request.container_encrypted = True
request.container_raid_level = "raid1"
request.reset_container_data()
self.assertEqual(compare_data(request, default), True)
def set_container_data(request: DeviceFactoryRequest, container):
"""Set the container data in the device factory request.
:param request: a device factory request
:param container: a container
"""
request.container_spec = container.name
request.container_name = container.name
request.container_encrypted = container.encrypted
request.container_raid_level = get_device_raid_level_name(container)
request.container_size_policy = get_container_size_policy(container)
if request.container_encrypted:
request.luks_version = get_container_luks_version(container)
def generate_device_factory_request(storage, device) -> DeviceFactoryRequest:
"""Generate a device info for the given device.
:param storage: an instance of Blivet
:param device: a device
:return: a device factory request
"""
device_type = devicefactory.get_device_type(device)
if device_type is None:
raise UnsupportedDeviceError("Unsupported type of {}.".format(
device.name))
request = DeviceFactoryRequest()
request.device_spec = device.name
request.device_name = getattr(device.raw_device, "lvname",
device.raw_device.name)
request.device_size = device.size.get_bytes()
request.device_type = device_type
request.reformat = not device.format.exists
request.format_type = device.format.type or ""
request.device_encrypted = isinstance(device, LUKSDevice)
request.luks_version = get_device_luks_version(device) or ""
request.label = getattr(device.format, "label", "") or ""
request.mount_point = getattr(device.format, "mountpoint", "") or ""
request.device_raid_level = get_device_raid_level_name(device)
if hasattr(device, "req_disks") and not device.exists:
disks = device.req_disks
else:
disks = device.disks
request.disks = [d.name for d in disks]
factory = devicefactory.get_device_factory(storage,
device_type=device_type,
device=device.raw_device)
container = factory.get_container()
if container:
request.container_spec = container.name
request.container_name = container.name
request.container_encrypted = container.encrypted
request.container_raid_level = get_device_raid_level_name(container)
request.container_size_policy = get_container_size_policy(container)
return request
def get_device_factory_arguments_test(self):
"""Test get_device_factory_arguments."""
dev1 = StorageDevice("dev1")
self._add_device(dev1)
dev2 = StorageDevice("dev2")
self._add_device(dev2)
dev3 = StorageDevice("dev3")
self._add_device(dev3)
request = DeviceFactoryRequest()
request.device_spec = "dev3"
request.disks = ["dev1", "dev2"]
request.device_name = "dev3"
request.device_type = devicefactory.DEVICE_TYPE_LVM_THINP
request.device_size = Size("10 GiB").get_bytes()
request.mount_point = "/"
request.format_type = "xfs"
request.label = "root"
request.device_encrypted = True
request.luks_version = "luks1"
request.device_raid_level = "raid1"
self.assertEqual(utils.get_device_factory_arguments(self.storage, request), {
"device": dev3,
"disks": [dev1, dev2],
"device_type": devicefactory.DEVICE_TYPE_LVM_THINP,
"device_name": "dev3",
"size": Size("10 GiB"),
"mountpoint": "/",
"fstype": "xfs",
"label": "root",
"encrypted": True,
"luks_version": "luks1",
"raid_level": raid.RAID1,
"container_name": None,
"container_size": devicefactory.SIZE_POLICY_AUTO,
"container_raid_level": None,
"container_encrypted": False
})
request = DeviceFactoryRequest()
request.device_spec = "dev3"
request.disks = ["dev1", "dev2"]
request.device_name = "dev3"
request.container_name = "container1"
request.container_size_policy = Size("10 GiB").get_bytes()
request.container_encrypted = True
request.container_raid_level = "raid1"
self.assertEqual(utils.get_device_factory_arguments(self.storage, request), {
"device": dev3,
"disks": [dev1, dev2],
"device_type": devicefactory.DEVICE_TYPE_LVM,
"device_name": "dev3",
"size": None,
"mountpoint": None,
"fstype": None,
"label": None,
"encrypted": False,
"luks_version": None,
"raid_level": None,
"container_name": "container1",
"container_size": Size("10 GiB"),
"container_raid_level": raid.RAID1,
"container_encrypted": True
})