def change_device_test(self): """Test ChangeDevice.""" dev1 = DiskDevice("dev1") dev2 = PartitionDevice("dev2", size=Size("5 GiB"), parents=[dev1], fmt=get_format("ext4", mountpoint="/", label="root")) self._add_device(dev1) self._add_device(dev2) original_request = self.module.generate_device_factory_request("dev2") request = copy.deepcopy(original_request) request.device_type = DEVICE_TYPE_LVM request.mount_point = "/home" request.size = Size("4 GiB") request.label = "home" self.storage.factory_device = Mock() self.interface.ChangeDevice( DeviceFactoryRequest.to_structure(request), DeviceFactoryRequest.to_structure(original_request)) self.storage.factory_device.assert_called_once()
def validate_device_factory_request_test(self): """Test ValidateDeviceFactoryRequest.""" dev1 = DiskDevice("dev1") dev2 = DiskDevice("dev2") dev3 = PartitionDevice("dev3", size=Size("10 GiB"), parents=[dev1]) self._add_device(dev1) self._add_device(dev2) self._add_device(dev3) request = self.module.generate_device_factory_request("dev3") request.device_type = DEVICE_TYPE_LVM request.disks = ["dev1", "dev2"] request.format_type = "ext4" request.mount_point = "/boot" request.label = "root" request.reformat = True request.luks_version = "luks1" request.device_size = Size("5 GiB").get_bytes() request.device_encrypted = True request.device_raid_level = "raid1" result = self.interface.ValidateDeviceFactoryRequest( DeviceFactoryRequest.to_structure(request)) self._check_report(result, "/boot cannot be encrypted") request.mount_point = "/" result = self.interface.ValidateDeviceFactoryRequest( DeviceFactoryRequest.to_structure(request)) self._check_report(result, None)
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. set_container_data(request, 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 update_container_data_test(self): """Test UpdateContainerData.""" pv1 = StorageDevice( "pv1", size=Size("1025 MiB"), fmt=get_format("lvmpv") ) pv2 = StorageDevice( "pv2", size=Size("513 MiB"), fmt=get_format("lvmpv") ) vg = LVMVolumeGroupDevice( "testvg", parents=[pv1, pv2] ) self._add_device(pv1) self._add_device(pv2) self._add_device(vg) request = DeviceFactoryRequest() request.device_type = DEVICE_TYPE_PARTITION with self.assertRaises(StorageError): self.interface.UpdateContainerData( DeviceFactoryRequest.to_structure(request), "anaconda" ) request.device_type = DEVICE_TYPE_BTRFS request = DeviceFactoryRequest.from_structure( self.interface.UpdateContainerData( DeviceFactoryRequest.to_structure(request), "anaconda" ) ) self.assertEqual(request.container_spec, "") self.assertEqual(request.container_name, "anaconda") self.assertEqual(request.container_encrypted, False) self.assertEqual(request.container_raid_level, "single") self.assertEqual(request.container_size_policy, 0) self.assertEqual(request.disks, []) request.device_type = DEVICE_TYPE_LVM request = DeviceFactoryRequest.from_structure( self.interface.UpdateContainerData( DeviceFactoryRequest.to_structure(request), "testvg" ) ) self.assertEqual(request.container_spec, "testvg") self.assertEqual(request.container_name, "testvg") self.assertEqual(request.container_encrypted, False) self.assertEqual(request.container_raid_level, "") self.assertEqual(request.container_size_policy, Size("1.5 GiB").get_bytes()) self.assertEqual(request.disks, [])
def GenerateContainerData(self, request: Structure) -> Structure: """Generate the container data for the device factory request. :param request: a device factory request :return: a device factory request """ request = DeviceFactoryRequest.from_structure(request) self.implementation.generate_container_data(request) return DeviceFactoryRequest.to_structure(request)
def UpdateContainerData(self, request: Structure, container_name: Str) -> Structure: """Update the container data in the device factory request. :param request: a device factory request :param container_name: a container name :return: a device factory request """ request = DeviceFactoryRequest.from_structure(request) self.implementation.update_container_data(request, container_name) return DeviceFactoryRequest.to_structure(request)
def ChangeDevice(self, request: Structure, original_request: Structure): """Change a device in the storage model. FIXME: Remove the original request from the arguments. :param request: a device factory request :param original_request: an original device factory request :raise: StorageError if the device cannot be changed """ self.implementation.change_device( DeviceFactoryRequest.from_structure(request), DeviceFactoryRequest.from_structure(original_request))
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 generate_device_factory_request_raid_test(self, blockdev): disk1 = DiskDevice("dev1", fmt=get_format("mdmember")) disk2 = DiskDevice("dev2", fmt=get_format("mdmember")) device = MDRaidArrayDevice("dev3", level="raid1", parents=[disk1, disk2]) request = utils.generate_device_factory_request(self.storage, device) self.assertEqual( DeviceFactoryRequest.to_structure(request), { "device-spec": get_variant(Str, "dev3"), "disks": get_variant(List[Str], ["dev1", "dev2"]), "mount-point": get_variant(Str, ""), "reformat": get_variant(Bool, True), "format-type": get_variant(Str, ""), "label": get_variant(Str, ""), "luks-version": get_variant(Str, ""), "device-type": get_variant(Int, devicefactory.DEVICE_TYPE_MD), "device-name": get_variant(Str, "dev3"), "device-size": get_variant(UInt64, 0), "device-encrypted": get_variant(Bool, False), "device-raid-level": get_variant(Str, "raid1"), "container-spec": get_variant(Str, ""), "container-name": get_variant(Str, ""), "container-size-policy": get_variant(Int64, 0), "container-encrypted": get_variant(Bool, False), "container-raid-level": get_variant(Str, ""), })
def test_generate_device_factory_request_btrfs(self, blockdev): dev1 = StorageDevice("dev1", fmt=get_format("btrfs"), size=Size("10 GiB")) dev2 = BTRFSVolumeDevice("dev2", data_level="single", parents=[dev1]) dev3 = BTRFSSubVolumeDevice( parents=[dev2], fmt=get_format("btrfs", mountpoint="/boot"), ) request = utils.generate_device_factory_request(self.storage, dev3) assert DeviceFactoryRequest.to_structure(request) == { "device-spec": get_variant(Str, dev3.name), "disks": get_variant(List[Str], []), "mount-point": get_variant(Str, "/boot"), "reformat": get_variant(Bool, True), "format-type": get_variant(Str, "btrfs"), "label": get_variant(Str, ""), "luks-version": get_variant(Str, ""), "device-type": get_variant(Int, devicefactory.DEVICE_TYPE_BTRFS), "device-name": get_variant(Str, dev3.name), "device-size": get_variant(UInt64, Size("10 GiB").get_bytes()), "device-encrypted": get_variant(Bool, False), "device-raid-level": get_variant(Str, ""), "container-spec": get_variant(Str, dev2.name), "container-name": get_variant(Str, dev2.name), "container-size-policy": get_variant(Int64, Size("10 GiB").get_bytes()), "container-encrypted": get_variant(Bool, False), "container-raid-level": get_variant(Str, "single"), }
def AddDevice(self, request: Structure): """Add a new device to the storage model. :param request: a device factory request :raise: StorageError if the device cannot be created """ self.implementation.add_device( DeviceFactoryRequest.from_structure(request))
def _complete_device_factory_request(self, storage, request: DeviceFactoryRequest): """Complete the device factory request. :param storage: an instance of Blivet :param request: a device factory request """ # Set the defaults. if not request.luks_version: request.luks_version = storage.default_luks_version # Set the file system type for the given mount point. if not request.format_type: request.format_type = storage.get_fstype(request.mount_point) # Fix the mount point. if lowerASCII(request.mount_point) in ("swap", "biosboot", "prepboot"): request.mount_point = "" # We should create a partition in some cases. # These devices should never be encrypted. if (request.mount_point.startswith("/boot") or request.format_type in PARTITION_ONLY_FORMAT_TYPES): request.device_type = devicefactory.DEVICE_TYPE_PARTITION request.device_encrypted = False # We shouldn't create swap on a thinly provisioned volume. if (request.format_type == "swap" and request.device_type == devicefactory.DEVICE_TYPE_LVM_THINP): request.device_type = devicefactory.DEVICE_TYPE_LVM # Encryption of thinly provisioned volumes isn't supported. if request.device_type == devicefactory.DEVICE_TYPE_LVM_THINP: request.device_encrypted = False
def ValidateDeviceFactoryRequest(self, request: Structure) -> Structure: """Validate the given device factory request. :param request: a device factory request :return: a validation report """ request = DeviceFactoryRequest.from_structure(request) report = self.implementation.validate_device_factory_request(request) return ValidationReport.to_structure(report)
def test_update_container_data(self): """Test UpdateContainerData.""" pv1 = StorageDevice("pv1", size=Size("1025 MiB"), fmt=get_format("lvmpv")) pv2 = StorageDevice("pv2", size=Size("513 MiB"), fmt=get_format("lvmpv")) vg = LVMVolumeGroupDevice("testvg", parents=[pv1, pv2]) self._add_device(pv1) self._add_device(pv2) self._add_device(vg) request = DeviceFactoryRequest() request.device_type = DEVICE_TYPE_PARTITION with pytest.raises(StorageError): self.interface.UpdateContainerData( DeviceFactoryRequest.to_structure(request), "anaconda") request.device_type = DEVICE_TYPE_BTRFS request = DeviceFactoryRequest.from_structure( self.interface.UpdateContainerData( DeviceFactoryRequest.to_structure(request), "anaconda")) assert request.container_spec == "" assert request.container_name == "anaconda" assert request.container_encrypted is False assert request.container_raid_level == "single" assert request.container_size_policy == 0 assert request.disks == [] request.device_type = DEVICE_TYPE_LVM request = DeviceFactoryRequest.from_structure( self.interface.UpdateContainerData( DeviceFactoryRequest.to_structure(request), "testvg")) assert request.container_spec == "testvg" assert request.container_name == "testvg" assert request.container_encrypted is False assert request.container_raid_level == "" assert request.container_size_policy == Size("1.5 GiB").get_bytes() assert request.disks == []
def GenerateDeviceFactoryRequest(self, device_name: Str) -> Structure: """Generate a device factory request for the given device. The request will reflect the current state of the device. It can be modified and used to change the device. :param device_name: a device name :return: a device factory request """ return DeviceFactoryRequest.to_structure( self.implementation.generate_device_factory_request(device_name))
def GenerateDeviceFactoryPermissions(self, request: Structure) -> Structure: """Generate device factory permissions for the given request. The permissions will reflect which device attributes we are allowed to change in the requested device. :param request: a device factory request :return: device factory permissions """ request = DeviceFactoryRequest.from_structure(request) permissions = self.implementation.generate_device_factory_permissions( request) return DeviceFactoryPermissions.to_structure(permissions)
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 add_device_test(self): """Test AddDevice.""" self._add_device( DiskDevice("dev1", exists=True, size=Size("15 GiB"), fmt=get_format("disklabel"))) request = DeviceFactoryRequest() request.device_type = DEVICE_TYPE_LVM request.mount_point = "/home" request.size = Size("5 GiB") request.disks = ["dev1"] self.storage.factory_device = Mock() self.interface.AddDevice(DeviceFactoryRequest.to_structure(request)) self.storage.factory_device.assert_called_once()
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_lvm_test(self, blockdev): pv1 = StorageDevice("pv1", size=Size("1025 MiB"), fmt=get_format("lvmpv")) pv2 = StorageDevice("pv2", size=Size("513 MiB"), fmt=get_format("lvmpv")) vg = LVMVolumeGroupDevice("testvg", parents=[pv1, pv2]) lv = LVMLogicalVolumeDevice("testlv", size=Size("512 MiB"), parents=[vg], fmt=get_format("xfs"), exists=False, seg_type="raid1", pvs=[pv1, pv2]) request = utils.generate_device_factory_request(self.storage, lv) self.assertEqual( DeviceFactoryRequest.to_structure(request), { "device-spec": get_variant(Str, "testvg-testlv"), "disks": get_variant(List[Str], []), "mount-point": get_variant(Str, ""), "reformat": get_variant(Bool, True), "format-type": get_variant(Str, "xfs"), "label": get_variant(Str, ""), "luks-version": get_variant(Str, ""), "device-type": get_variant(Int, devicefactory.DEVICE_TYPE_LVM), "device-name": get_variant(Str, "testlv"), "device-size": get_variant(UInt64, Size("508 MiB").get_bytes()), "device-encrypted": get_variant(Bool, False), "device-raid-level": get_variant(Str, ""), "container-spec": get_variant(Str, "testvg"), "container-name": get_variant(Str, "testvg"), "container-size-policy": get_variant(Int64, Size("1.5 GiB")), "container-encrypted": get_variant(Bool, False), "container-raid-level": get_variant(Str, ""), })
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 })
def generate_device_factory_request_test(self, blockdev): device = StorageDevice("dev1") with self.assertRaises(UnsupportedDeviceError): utils.generate_device_factory_request(self.storage, device) disk = DiskDevice("dev2") request = utils.generate_device_factory_request(self.storage, disk) self.assertEqual(DeviceFactoryRequest.to_structure(request), { "device-spec": get_variant(Str, "dev2"), "disks": get_variant(List[Str], ["dev2"]), "mount-point": get_variant(Str, ""), "reformat": get_variant(Bool, False), "format-type": get_variant(Str, ""), "label": get_variant(Str, ""), "luks-version": get_variant(Str, ""), "device-type": get_variant(Int, devicefactory.DEVICE_TYPE_DISK), "device-name": get_variant(Str, "dev2"), "device-size": get_variant(UInt64, 0), "device-encrypted": get_variant(Bool, False), "device-raid-level": get_variant(Str, ""), "container-spec": get_variant(Str, ""), "container-name": get_variant(Str, ""), "container-size-policy": get_variant(Int64, devicefactory.SIZE_POLICY_AUTO), "container-encrypted": get_variant(Bool, False), "container-raid-level": get_variant(Str, ""), }) partition = PartitionDevice( "dev3", size=Size("5 GiB"), parents=[disk], fmt=get_format("ext4", mountpoint="/", label="root") ) request = utils.generate_device_factory_request(self.storage, partition) self.assertEqual(DeviceFactoryRequest.to_structure(request), { "device-spec": get_variant(Str, "dev3"), "disks": get_variant(List[Str], ["dev2"]), "mount-point": get_variant(Str, "/"), "reformat": get_variant(Bool, True), "format-type": get_variant(Str, "ext4"), "label": get_variant(Str, "root"), "luks-version": get_variant(Str, ""), "device-type": get_variant(Int, devicefactory.DEVICE_TYPE_PARTITION), "device-name": get_variant(Str, "dev3"), "device-size": get_variant(UInt64, Size("5 GiB").get_bytes()), "device-encrypted": get_variant(Bool, False), "device-raid-level": get_variant(Str, ""), "container-spec": get_variant(Str, ""), "container-name": get_variant(Str, ""), "container-size-policy": get_variant(Int64, devicefactory.SIZE_POLICY_AUTO), "container-encrypted": get_variant(Bool, False), "container-raid-level": get_variant(Str, ""), }) pv1 = StorageDevice( "pv1", size=Size("1025 MiB"), fmt=get_format("lvmpv") ) pv2 = StorageDevice( "pv2", size=Size("513 MiB"), fmt=get_format("lvmpv") ) vg = LVMVolumeGroupDevice( "testvg", parents=[pv1, pv2] ) lv = LVMLogicalVolumeDevice( "testlv", size=Size("512 MiB"), parents=[vg], fmt=get_format("xfs"), exists=False, seg_type="raid1", pvs=[pv1, pv2] ) request = utils.generate_device_factory_request(self.storage, lv) self.assertEqual(DeviceFactoryRequest.to_structure(request), { "device-spec": get_variant(Str, "testvg-testlv"), "disks": get_variant(List[Str], []), "mount-point": get_variant(Str, ""), "reformat": get_variant(Bool, True), "format-type": get_variant(Str, "xfs"), "label": get_variant(Str, ""), "luks-version": get_variant(Str, ""), "device-type": get_variant(Int, devicefactory.DEVICE_TYPE_LVM), "device-name": get_variant(Str, "testlv"), "device-size": get_variant(UInt64, Size("508 MiB").get_bytes()), "device-encrypted": get_variant(Bool, False), "device-raid-level": get_variant(Str, ""), "container-spec": get_variant(Str, "testvg"), "container-name": get_variant(Str, "testvg"), "container-size-policy": get_variant(Int64, Size("1.5 GiB")), "container-encrypted": get_variant(Bool, False), "container-raid-level": get_variant(Str, ""), })
def generate_container_data_test(self, proxy_getter): """Test GenerateContainerData.""" network_proxy = Mock() network_proxy.Hostname = "localhost" network_proxy.GetCurrentHostname.return_value = "localhost" proxy_getter.return_value = network_proxy pv1 = StorageDevice("pv1", size=Size("1025 MiB"), fmt=get_format("lvmpv")) pv2 = StorageDevice("pv2", size=Size("513 MiB"), fmt=get_format("lvmpv")) vg = LVMVolumeGroupDevice("testvg", parents=[pv1, pv2]) lv = LVMLogicalVolumeDevice("testlv", size=Size("512 MiB"), parents=[vg], fmt=get_format("xfs"), exists=False, seg_type="raid1", pvs=[pv1, pv2]) self._add_device(pv1) self._add_device(pv2) self._add_device(vg) self._add_device(lv) request = DeviceFactoryRequest() request.device_spec = lv.name request.device_type = DEVICE_TYPE_LVM request = DeviceFactoryRequest.from_structure( self.interface.GenerateContainerData( DeviceFactoryRequest.to_structure(request))) self.assertEqual(request.container_spec, "testvg") self.assertEqual(request.container_name, "testvg") self.assertEqual(request.container_encrypted, False) self.assertEqual(request.container_raid_level, "") self.assertEqual(request.container_size_policy, Size("1.5 GiB").get_bytes()) request.device_type = DEVICE_TYPE_BTRFS request = DeviceFactoryRequest.from_structure( self.interface.GenerateContainerData( DeviceFactoryRequest.to_structure(request))) self.assertEqual(request.container_spec, "") self.assertEqual(request.container_name, "anaconda") self.assertEqual(request.container_encrypted, False) self.assertEqual(request.container_raid_level, "single") self.assertEqual(request.container_size_policy, 0) request.device_type = DEVICE_TYPE_PARTITION request = DeviceFactoryRequest.from_structure( self.interface.GenerateContainerData( DeviceFactoryRequest.to_structure(request))) self.assertEqual(request.container_spec, "") self.assertEqual(request.container_name, "") self.assertEqual(request.container_encrypted, False) self.assertEqual(request.container_raid_level, "") self.assertEqual(request.container_size_policy, 0)
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 generate_request_description_test(self): """Test generate_request_description.""" 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" expected = dedent(""" { container-encrypted = False container-name = '' container-raid-level = '' container-size-policy = 0 container-spec = '' device-encrypted = True device-name = 'dev3' device-raid-level = 'raid1' device-size = 10737418240 device-spec = 'dev3' device-type = 5 disks = ['dev1', 'dev2'] format-type = 'xfs' label = 'root' luks-version = 'luks1' mount-point = '/' reformat = False } """).strip() self.assertEqual(generate_request_description(request), expected) original = copy.deepcopy(request) self.assertEqual(generate_request_description(request, original), expected) request.device_name = "dev4" request.disks = ["dev1"] request.device_encrypted = False expected = dedent(""" { container-encrypted = False container-name = '' container-raid-level = '' container-size-policy = 0 container-spec = '' device-encrypted = True -> False device-name = 'dev3' -> 'dev4' device-raid-level = 'raid1' device-size = 10737418240 device-spec = 'dev3' device-type = 5 disks = ['dev1', 'dev2'] -> ['dev1'] format-type = 'xfs' label = 'root' luks-version = 'luks1' mount-point = '/' reformat = False } """).strip() self.assertEqual(generate_request_description(request, original), expected)
def generate_device_factory_request_partition_test(self, blockdev): disk = DiskDevice("dev2") request = utils.generate_device_factory_request(self.storage, disk) self.assertEqual( DeviceFactoryRequest.to_structure(request), { "device-spec": get_variant(Str, "dev2"), "disks": get_variant(List[Str], ["dev2"]), "mount-point": get_variant(Str, ""), "reformat": get_variant(Bool, False), "format-type": get_variant(Str, ""), "label": get_variant(Str, ""), "luks-version": get_variant(Str, ""), "device-type": get_variant(Int, devicefactory.DEVICE_TYPE_DISK), "device-name": get_variant(Str, "dev2"), "device-size": get_variant(UInt64, 0), "device-encrypted": get_variant(Bool, False), "device-raid-level": get_variant(Str, ""), "container-spec": get_variant(Str, ""), "container-name": get_variant(Str, ""), "container-size-policy": get_variant(Int64, devicefactory.SIZE_POLICY_AUTO), "container-encrypted": get_variant(Bool, False), "container-raid-level": get_variant(Str, ""), }) partition = PartitionDevice("dev3", size=Size("5 GiB"), parents=[disk], fmt=get_format("ext4", mountpoint="/", label="root")) request = utils.generate_device_factory_request( self.storage, partition) self.assertEqual( DeviceFactoryRequest.to_structure(request), { "device-spec": get_variant(Str, "dev3"), "disks": get_variant(List[Str], ["dev2"]), "mount-point": get_variant(Str, "/"), "reformat": get_variant(Bool, True), "format-type": get_variant(Str, "ext4"), "label": get_variant(Str, "root"), "luks-version": get_variant(Str, ""), "device-type": get_variant(Int, devicefactory.DEVICE_TYPE_PARTITION), "device-name": get_variant(Str, "dev3"), "device-size": get_variant(UInt64, Size("5 GiB").get_bytes()), "device-encrypted": get_variant(Bool, False), "device-raid-level": get_variant(Str, ""), "container-spec": get_variant(Str, ""), "container-name": get_variant(Str, ""), "container-size-policy": get_variant(Int64, devicefactory.SIZE_POLICY_AUTO), "container-encrypted": get_variant(Bool, False), "container-raid-level": get_variant(Str, ""), })