def verify_root(storage, constraints, report_error, report_warning): """ Verify the root. :param storage: a storage to check :param constraints: a dictionary of constraints :param report_error: a function for error reporting :param report_warning: a function for warning reporting """ root = storage.fsset.root_device if not root: report_error( _("You have not defined a root partition (/), " "which is required for installation of %s" " to continue.") % (productName, )) if root and root.format.exists and root.format.mountable and root.format.mountpoint == "/": report_error( _("You must create a new file system on the root device.")) if storage.root_device and constraints[STORAGE_ROOT_DEVICE_TYPES]: device_type = get_device_type(storage.root_device) device_types = constraints[STORAGE_ROOT_DEVICE_TYPES] if device_type not in device_types: report_error( _("Your root partition must be on a device of type: %s.") % ", ".join(DEVICE_TEXT_MAP[t] for t in device_types))
def _validate_factory_device(self, *args, **kwargs): """ Validate the factory device against the factory args. """ device = args[0] device_type = args[1] if kwargs.get("encrypted"): device_class = LUKSDevice else: device_class = self.device_class self.assertIsInstance(device, device_class) self.assertEqual(devicefactory.get_device_type(device), device_type) self.assertEqual(device.format.type, kwargs['fstype']) if hasattr(device.format, "mountpoint"): self.assertEqual(device.format.mountpoint, kwargs.get('mountpoint')) if hasattr(device.format, "label"): self.assertEqual(device.format.label, kwargs.get('label')) self.assertLessEqual(device.size, kwargs.get("size")) self.assertGreaterEqual(device.size, device.format.min_size) if device.format.max_size: self.assertLessEqual(device.size, device.format.max_size) self.assertEqual( device.encrypted, kwargs.get("encrypted", False) or kwargs.get("container_encrypted", False)) self.assertTrue(set(device.disks).issubset(kwargs["disks"]))
def _validate_factory_device(self, *args, **kwargs): """ Validate the factory device against the factory args. """ device = args[0] device_type = args[1] size = args[2] if kwargs.get("encrypted"): device_class = LUKSDevice else: device_class = self.device_class self.assertIsInstance(device, device_class) self.assertEqual(devicefactory.get_device_type(device), device_type) self.assertEqual(device.format.type, kwargs['fstype']) if hasattr(device.format, "mountpoint"): self.assertEqual(device.format.mountpoint, kwargs.get('mountpoint')) if hasattr(device.format, "label"): self.assertEqual(device.format.label, kwargs.get('label')) self.assertLessEqual(device.size, size) self.assertGreaterEqual(device.size, device.format.min_size) if device.format.max_size: self.assertLessEqual(device.size, device.format.max_size) self.assertEqual(device.encrypted, kwargs.get("encrypted", False) or kwargs.get("container_encrypted", False)) self.assertTrue(set(device.disks).issubset(kwargs["disks"]))
def collect_device_types(device, disks): """Collect supported device types for the given device. :param device: a device :param disks: a list of selected disks :return: a list of device types """ # Collect the supported device types. supported_types = set(SUPPORTED_DEVICE_TYPES) # Include the type of the given device. supported_types.add(devicefactory.get_device_type(device)) # Include md only if there are two or more disks. if len(disks) > 1: supported_types.add(devicefactory.DEVICE_TYPE_MD) # Include btrfs if it is both allowed and supported. fmt = get_format("btrfs") if fmt.supported \ and fmt.formattable \ and device.raw_device.format.type not in PARTITION_ONLY_FORMAT_TYPES + ("swap",): supported_types.add(devicefactory.DEVICE_TYPE_BTRFS) return sorted( filter(devicefactory.is_supported_device_type, supported_types))
def is_device_editable(self, device_name): """Is the specified device editable? :param device_name: a name of the device :return: True or False """ device = self._get_device(device_name) return devicefactory.get_device_type(device) is not None
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)) # Generate the device data. 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) 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] if request.device_type not in CONTAINER_DEVICE_TYPES: return request # Generate the container data. factory = devicefactory.get_device_factory(storage, device_type=device_type, device=device.raw_device) container = factory.get_container() if container: set_container_data(request, container) return request
def generate_device_info(storage, device): """Generate a device info for the given device. :param storage: an instance of Blivet :param device: a device :return: a device info """ device_type = devicefactory.get_device_type(device) dev_info = dict() dev_info["device"] = device dev_info["name"] = getattr(device.raw_device, "lvname", device.raw_device.name) dev_info["size"] = device.size dev_info["device_type"] = device_type dev_info["fstype"] = device.format.type dev_info["encrypted"] = isinstance(device, LUKSDevice) dev_info["luks_version"] = get_device_luks_version(device) dev_info["label"] = getattr(device.format, "label", "") dev_info["mountpoint"] = getattr(device.format, "mountpoint", None) or None dev_info["raid_level"] = get_device_raid_level(device) if hasattr(device, "req_disks") and not device.exists: disks = device.req_disks else: disks = device.disks dev_info["disks"] = disks factory = devicefactory.get_device_factory(storage, device_type=device_type, device=device.raw_device) container = factory.get_container() if container: dev_info["container_name"] = container.name dev_info["container_encrypted"] = container.encrypted dev_info["container_raid_level"] = get_device_raid_level(container) dev_info["container_size"] = getattr(container, "size_policy", container.size) else: dev_info["container_name"] = None dev_info["container_encrypted"] = False dev_info["container_raid_level"] = None dev_info["container_size"] = devicefactory.SIZE_POLICY_AUTO return dev_info
def get_container(storage, device_type, device=None): """Get a container of the given type. :param storage: an instance of Blivet :param device_type: a device type :param device: a defined factory device or None :return: a container device """ if device_type not in CONTAINER_DEVICE_TYPES: raise StorageError("Invalid device type {}".format(device_type)) if device and devicefactory.get_device_type(device) != device_type: device = None factory = devicefactory.get_device_factory( storage, device_type=device_type, size=Size(0), ) return factory.get_container(device=device)
def _validate_factory_device(self, *args, **kwargs): """ Validate the factory device against the factory args. """ device = args[0] device_type = args[1] if kwargs.get("encrypted"): device_class = LUKSDevice else: device_class = self.device_class self.assertIsInstance(device, device_class) self.assertEqual(devicefactory.get_device_type(device), device_type) self.assertEqual(device.format.type, kwargs['fstype']) if hasattr(device.format, "mountpoint"): self.assertEqual(device.format.mountpoint, kwargs.get('mountpoint')) if hasattr(device.format, "label"): self.assertEqual(device.format.label, kwargs.get('label')) # sizes with VDO are special, we have a special check in LVMVDOFactoryTestCase._validate_factory_device if device_type != devicefactory.DEVICE_TYPE_LVM_VDO: self.assertLessEqual(device.size, kwargs.get("size")) self.assertGreaterEqual(device.size, device.format.min_size) if device.format.max_size: self.assertLessEqual(device.size, device.format.max_size) self.assertEqual( device.encrypted, kwargs.get("encrypted", False) or kwargs.get("container_encrypted", False)) if kwargs.get("encrypted", False): self.assertEqual( device.parents[0].format.luks_version, kwargs.get("luks_version", crypto.DEFAULT_LUKS_VERSION)) self.assertEqual(device.raw_device.format.luks_sector_size, kwargs.get("luks_sector_size", 0)) self.assertTrue(set(device.disks).issubset(kwargs["disks"]))
def _destroy_device(storage, device): """Destroy the given device in the storage model. :param storage: an instance of Blivet :param device: an instance of a device """ # Remove the device. if device.is_disk and device.partitioned and not device.format.supported: storage.recursive_remove(device) elif device.direct and not device.isleaf: # We shouldn't call this method for with non-leaf devices # except for those which are also directly accessible like # lvm snapshot origins and btrfs subvolumes that contain # other subvolumes. storage.recursive_remove(device) else: storage.destroy_device(device) # Initialize the disk. if device.is_disk: storage.initialize_disk(device) # Remove empty extended partitions. if getattr(device, "is_logical", False): storage.remove_empty_extended_partitions() # If we've just removed the last partition and the disk label # is preexisting, reinitialize the disk. if device.type == "partition" and device.exists and device.disk.format.exists: config = DiskInitializationConfig() if config.can_initialize(storage, device.disk): storage.initialize_disk(device.disk) # Get the device container. if hasattr(device, "vg"): container = device.vg device_type = devicefactory.get_device_type(device) elif hasattr(device, "volume"): container = device.volume device_type = devicefactory.DEVICE_TYPE_BTRFS else: container = None device_type = None # Adjust container to size of remaining devices, if auto-sized. if (container and not container.exists and container.children and container.size_policy == devicefactory.SIZE_POLICY_AUTO): # Create the device factory. factory = devicefactory.get_device_factory( storage, device_type=device_type, size=Size(0), disks=container.disks, container_name=container.name, container_encrypted=container.encrypted, container_raid_level=get_device_raid_level(container), container_size=container.size_policy, ) # Configure the factory's devices. factory.configure() # Finally, remove empty parents of the device. for parent in device.parents: if not parent.children and not parent.is_disk: destroy_device(storage, parent)