def test_get_related_disks(self): tree = DeviceTree() sda = DiskDevice("sda", size=Size('300g')) sdb = DiskDevice("sdb", size=Size('300g')) sdc = DiskDevice("sdc", size=Size('300G')) tree._add_device(sda) tree._add_device(sdb) tree._add_device(sdc) self.assertTrue(sda in tree.devices) self.assertTrue(sdb in tree.devices) self.assertTrue(sdc in tree.devices) sda.format = get_format("lvmpv", device=sda.path) sdb.format = get_format("lvmpv", device=sdb.path) vg = LVMVolumeGroupDevice("relvg", parents=[sda, sdb]) tree._add_device(vg) self.assertEqual(tree.get_related_disks(sda), set([sda, sdb])) self.assertEqual(tree.get_related_disks(sdb), set([sda, sdb])) self.assertEqual(tree.get_related_disks(sdc), set()) tree.hide(sda) self.assertEqual(tree.get_related_disks(sda), set([sda, sdb])) self.assertEqual(tree.get_related_disks(sdb), set([sda, sdb])) tree.hide(sdb) self.assertEqual(tree.get_related_disks(sda), set([sda, sdb])) self.assertEqual(tree.get_related_disks(sdb), set([sda, sdb])) tree.unhide(sda) self.assertEqual(tree.get_related_disks(sda), set([sda, sdb])) self.assertEqual(tree.get_related_disks(sdb), set([sda, sdb]))
def test_validate_container_name(self): """Test ValidateContainerName.""" dev1 = DiskDevice( "dev1" ) self._add_device(dev1) report = self.interface.ValidateContainerName("dev1") self._check_report(report, "Name is already in use.") report = self.interface.ValidateContainerName("_my/contain$er") self._check_report(report, "Invalid container name.") report = self.interface.ValidateContainerName("my_container") self._check_report(report, None)
def test_collect_unused_devices(self): """Test CollectUnusedDevices.""" dev1 = DiskDevice("dev1", fmt=get_format("disklabel")) dev2 = StorageDevice("dev2", parents=[dev1], fmt=get_format("ext4")) dev3 = StorageDevice("dev3", parents=[dev1], fmt=get_format("ext4")) dev4 = StorageDevice("dev4", parents=[dev1], fmt=get_format("ext4", mountpoint="/")) self._add_device(dev1) self._add_device(dev2) self._add_device(dev3) self._add_device(dev4) assert self.interface.CollectUnusedDevices() == ["dev2", "dev3"]
def test_resize(self): an_fs = self._fs_class() if not an_fs.formattable: self.skipTest("can not create filesystem %s" % an_fs.name) an_fs.device = self.loop_devices[0] self.assertIsNone(an_fs.create()) an_fs.update_size_info() self._test_sizes(an_fs) # CHECKME: target size is still 0 after updated_size_info is called. self.assertEqual(an_fs.size, Size(0) if an_fs.resizable else an_fs._size) if not self.can_resize(an_fs): self.assertFalse(an_fs.resizable) # Not resizable, so can not do resizing actions. with self.assertRaises(DeviceFormatError): an_fs.target_size = Size("64 MiB") with self.assertRaises(DeviceFormatError): an_fs.do_resize() else: disk = DiskDevice(os.path.basename(self.loop_devices[0])) part = self._create_partition(disk, Size("50 MiB")) an_fs = self._fs_class() an_fs.device = part.path self.assertIsNone(an_fs.create()) an_fs.update_size_info() self.assertTrue(an_fs.resizable) # grow the partition so we can grow the filesystem self._remove_partition(part, disk) part = self._create_partition(disk, size=part.size + Size("40 MiB")) # Try a reasonable target size TARGET_SIZE = Size("64 MiB") an_fs.target_size = TARGET_SIZE self.assertEqual(an_fs.target_size, TARGET_SIZE) self.assertNotEqual(an_fs._size, TARGET_SIZE) self.assertIsNone(an_fs.do_resize()) ACTUAL_SIZE = TARGET_SIZE.round_to_nearest(an_fs._resize.unit, rounding=ROUND_DOWN) self.assertEqual(an_fs.size, ACTUAL_SIZE) self.assertEqual(an_fs._size, ACTUAL_SIZE) self._test_sizes(an_fs) # and no errors should occur when checking self.assertIsNone(an_fs.do_check()) self._remove_partition(part, disk)
def get_device_data_test(self): """Test GetDeviceData.""" self._add_device( DiskDevice("dev1", fmt=get_format("ext4"), size=Size("10 MiB"), serial="SERIAL_ID", vendor="VENDOR_ID", model="MODEL_ID", bus="BUS_ID", wwn="0x0000000000000000", uuid="1234-56-7890")) self.assertEqual( self.interface.GetDeviceData("dev1"), { 'type': get_variant(Str, 'disk'), 'name': get_variant(Str, 'dev1'), 'path': get_variant(Str, '/dev/dev1'), 'size': get_variant(UInt64, Size("10 MiB").get_bytes()), 'is-disk': get_variant(Bool, True), 'protected': get_variant(Bool, False), 'removable': get_variant(Bool, False), 'parents': get_variant(List[Str], []), 'children': get_variant(List[Str], []), 'attrs': get_variant( Dict[Str, Str], { "serial": "SERIAL_ID", "vendor": "VENDOR_ID", "model": "MODEL_ID", "bus": "BUS_ID", "wwn": "0x0000000000000000", "uuid": "1234-56-7890" }), 'description': get_variant(Str, "VENDOR_ID MODEL_ID 0x0000000000000000") })
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 test_get_devices(self): """Test GetDevices.""" self.assertEqual(self.interface.GetDevices(), []) self._add_device(DiskDevice( "dev1", fmt=get_format("ext4"), size=Size("10 GiB") )) self._add_device(StorageDevice( "dev2", fmt=get_format("ext4"), size=Size("10 GiB") )) self.assertEqual(self.interface.GetDevices(), ["dev1", "dev2"])
def generate_device_factory_permissions_test(self): """Test GenerateDeviceFactoryPermissions.""" dev1 = DiskDevice("dev1", fmt=get_format("disklabel"), size=Size("10 GiB"), exists=True) dev2 = PartitionDevice("dev2", size=Size("5 GiB"), parents=[dev1], fmt=get_format("ext4", mountpoint="/", label="root")) self._add_device(dev1) self._add_device(dev2) request = self.interface.GenerateDeviceFactoryRequest("dev1") permissions = self.interface.GenerateDeviceFactoryPermissions(request) self.assertEqual( get_native(permissions), { 'mount-point': False, 'reformat': True, 'format-type': True, 'label': True, 'device-type': False, 'device-name': False, 'device-size': False, 'device-encrypted': True, 'device-raid-level': False, }) request = self.interface.GenerateDeviceFactoryRequest("dev2") permissions = self.interface.GenerateDeviceFactoryPermissions(request) self.assertEqual( get_native(permissions), { 'mount-point': True, 'reformat': False, 'format-type': True, 'label': True, 'device-type': True, 'device-name': False, 'device-size': True, 'device-encrypted': True, 'device-raid-level': True, })
def is_device_editable_test(self): """Test IsDeviceEditable.""" dev1 = StorageDevice( "dev1", fmt=get_format("ext4"), size=Size("10 GiB") ) dev2 = DiskDevice( "dev2", fmt=get_format("disklabel"), size=Size("10 GiB") ) self._add_device(dev1) self._add_device(dev2) self.assertEqual(self.interface.IsDeviceEditable("dev1"), False) self.assertEqual(self.interface.IsDeviceEditable("dev2"), True)
def fix_btrfs_test(self, configure, install, conf): """Test the final configuration of the boot loader.""" storage = create_storage() sysroot = "/tmp/sysroot" version = "4.17.7-200.fc28.x86_64" conf.target.is_directory = True FixBTRFSBootloaderTask(storage, BootloaderMode.ENABLED, [version], sysroot).run() configure.assert_not_called() install.assert_not_called() conf.target.is_directory = False FixBTRFSBootloaderTask(storage, BootloaderMode.DISABLED, [version], sysroot).run() configure.assert_not_called() install.assert_not_called() conf.target.is_directory = False FixBTRFSBootloaderTask(storage, BootloaderMode.ENABLED, [version], sysroot).run() configure.assert_not_called() install.assert_not_called() dev1 = DiskDevice("dev1", fmt=get_format("disklabel"), size=Size("10 GiB")) storage.devicetree._add_device(dev1) dev2 = BTRFSDevice("dev2", fmt=get_format("btrfs", mountpoint="/"), size=Size("5 GiB"), parents=[dev1]) storage.devicetree._add_device(dev2) # Make the btrfs format mountable. dev2.format._mount = Mock(available=True) conf.target.is_directory = False FixBTRFSBootloaderTask(storage, BootloaderMode.ENABLED, [version], sysroot).run() configure.assert_called_once_with(storage, BootloaderMode.ENABLED, [version], sysroot) install.assert_called_once_with(storage, BootloaderMode.ENABLED)
def get_actions_test(self): """Test GetActions.""" self.assertEqual(self.interface.GetActions(), []) self._add_device(DiskDevice( "dev1", fmt=get_format("ext4"), size=Size("10 MiB"), )) device = self.storage.devicetree.get_device_by_name("dev1") self.storage.destroy_device(device) self.assertEqual(self.interface.GetActions(), [{ 'action-type': get_variant(Str, 'destroy'), 'action-object': get_variant(Str, 'device'), 'device-name': get_variant(Str, 'dev1'), 'description': get_variant(Str, 'destroy device'), }])
def gather_unusable_requests_test(self): """Test GatherRequests with unusable devices.""" self.module.on_storage_changed(create_storage()) # Add device with no size. self._add_device(StorageDevice("dev1", size=Size(0))) self.assertEqual(self.interface.GatherRequests(), []) # Add protected device. device = StorageDevice("dev2", size=Size("1 GiB")) device.protected = True self._add_device(device) self.assertEqual(self.interface.GatherRequests(), []) # Add unselected disk. self._add_device(DiskDevice("dev3", size=Size("1 GiB"))) self.module.on_selected_disks_changed(["dev1", "dev2"]) self.assertEqual(self.interface.GatherRequests(), [])
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_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, ""), })
def setUp(self): """Create some device objects to test with. This sets up two disks (sda, sdb). The first partition of each is a biosboot partition. The second partitions comprise a RAID1 array formatted as /boot. sda additionally contains a third partition formatted as ext4. """ super(GRUBRaidSimpleTest, self).setUp() # Make some disks self.sda = DiskDevice(name="sda", size=Size("100 GiB")) self.sda.format = get_format("disklabel") self.sdb = DiskDevice(name="sdb", size=Size("100 GiB")) self.sdb.format = get_format("disklabel") # Set up biosboot partitions, an mdarray for /boot, and a btrfs array on sda + sdb. # Start with the partitions self.sda1 = PartitionDevice(name="sda1", parents=[self.sda], size=Size("1 MiB")) self.sda1.format = get_format("biosboot") self.sda2 = PartitionDevice(name="sda2", parents=[self.sda], size=Size("500 MiB")) self.sda2.format = get_format("mdmember") self.sda4 = PartitionDevice(name="sda4", parents=[self.sda], size=Size("500 MiB")) self.sda4.format = get_format("btrfs") self.sdb1 = PartitionDevice(name="sdb1", parents=[self.sdb], size=Size("1 MiB")) self.sdb1.format = get_format("biosboot") self.sdb2 = PartitionDevice(name="sdb2", parents=[self.sdb], size=Size("500 MiB")) self.sdb2.format = get_format("mdmember") self.sdb4 = PartitionDevice(name="sdb4", parents=[self.sdb], size=Size("4 GiB")) self.sdb4.format = get_format("btrfs") # Add an extra partition for /boot on not-RAID self.sda3 = PartitionDevice(name="sda3", parents=[self.sda], size=Size("500 MiB")) self.sda3.format = get_format("ext4", mountpoint="/boot") # Pretend that the partitions are real with real parent disks for part in (self.sda1, self.sda2, self.sda3, self.sda4, self.sdb1, self.sdb2, self.sdb4): part.parents = part.req_disks self.boot_md = MDRaidArrayDevice(name="md1", size=Size("500 MiB"), parents=[self.sda2, self.sdb2], level=1, member_devices=2, total_devices=2) self.boot_md.format = get_format("ext4", mountpoint="/boot") # Set up the btrfs raid1 volume with a subvolume for /boot self.btrfs_volume = BTRFSVolumeDevice(parents=[self.sda4, self.sdb4], data_level=RAID1) self.btrfs_volume.format = get_format("btrfs") self.boot_btrfs = BTRFSSubVolumeDevice(parents=[self.btrfs_volume]) self.boot_btrfs.format = get_format("btrfs", mountpoint="/boot") self.grub = GRUB2()
def setUp(self): self.md_chunk_size = mdraid.MD_CHUNK_SIZE mdraid.MD_CHUNK_SIZE = Size("1 MiB") self.get_superblock_size = MDRaidArrayDevice.get_superblock_size MDRaidArrayDevice.get_superblock_size = lambda a, s: Size(0) self.addCleanup(self._clean_up) parents = [DiskDevice("name1", fmt=get_format("mdmember"))] self.dev1 = MDContainerDevice("dev1", level="container", parents=parents, total_devices=1, member_devices=1) parents = [ DiskDevice("name1", fmt=get_format("mdmember"), size=Size("1 GiB")), DiskDevice("name2", fmt=get_format("mdmember"), size=Size("1 GiB")) ] self.dev2 = MDRaidArrayDevice("dev2", level="raid0", parents=parents, total_devices=2, member_devices=2) parents = [ DiskDevice("name1", fmt=get_format("mdmember")), DiskDevice("name2", fmt=get_format("mdmember")) ] self.dev3 = MDRaidArrayDevice("dev3", level="raid1", parents=parents) parents = [ DiskDevice("name1", fmt=get_format("mdmember")), DiskDevice("name2", fmt=get_format("mdmember")), DiskDevice("name3", fmt=get_format("mdmember")) ] self.dev4 = MDRaidArrayDevice("dev4", level="raid4", parents=parents) parents = [ DiskDevice("name1", fmt=get_format("mdmember")), DiskDevice("name2", fmt=get_format("mdmember")), DiskDevice("name3", fmt=get_format("mdmember")) ] self.dev5 = MDRaidArrayDevice("dev5", level="raid5", parents=parents) parents = [ DiskDevice("name1", fmt=get_format("mdmember")), DiskDevice("name2", fmt=get_format("mdmember")), DiskDevice("name3", fmt=get_format("mdmember")), DiskDevice("name4", fmt=get_format("mdmember")) ] self.dev6 = MDRaidArrayDevice("dev6", level="raid6", parents=parents) parents = [ DiskDevice("name1", fmt=get_format("mdmember")), DiskDevice("name2", fmt=get_format("mdmember")), DiskDevice("name3", fmt=get_format("mdmember")), DiskDevice("name4", fmt=get_format("mdmember")) ] self.dev7 = MDRaidArrayDevice("dev7", level="raid10", parents=parents) self.dev8 = MDRaidArrayDevice("dev8", level=1, exists=True) parents_1 = [ DiskDevice("name1", fmt=get_format("mdmember")), DiskDevice("name2", fmt=get_format("mdmember")) ] dev_1 = MDContainerDevice("parent", level="container", parents=parents_1, total_devices=2, member_devices=2, exists=True) self.dev9 = MDBiosRaidArrayDevice("dev9", level="raid0", member_devices=1, parents=[dev_1], total_devices=1, exists=True) parents = [ DiskDevice("name1", fmt=get_format("mdmember")), DiskDevice("name2", fmt=get_format("mdmember")) ] self.dev10 = MDRaidArrayDevice("dev10", level="raid0", parents=parents, size=Size("32 MiB")) parents_1 = [ DiskDevice("name1", fmt=get_format("mdmember")), DiskDevice("name2", fmt=get_format("mdmember")) ] dev_1 = MDContainerDevice("parent", level="container", parents=parents, total_devices=2, member_devices=2) self.dev11 = MDBiosRaidArrayDevice("dev11", level=1, exists=True, parents=[dev_1], size=Size("32 MiB")) self.dev13 = MDRaidArrayDevice( "dev13", level=0, member_devices=2, parents=[ Mock(**{ "size": Size("4 MiB"), "format": get_format("mdmember") }), Mock(**{ "size": Size("2 MiB"), "format": get_format("mdmember") }) ], size=Size("32 MiB"), total_devices=2) self.dev14 = MDRaidArrayDevice( "dev14", level=4, member_devices=3, parents=[ Mock(**{ "size": Size("4 MiB"), "format": get_format("mdmember") }), Mock(**{ "size": Size("2 MiB"), "format": get_format("mdmember") }), Mock(**{ "size": Size("2 MiB"), "format": get_format("mdmember") }) ], total_devices=3) self.dev15 = MDRaidArrayDevice( "dev15", level=5, member_devices=3, parents=[ Mock(**{ "size": Size("4 MiB"), "format": get_format("mdmember") }), Mock(**{ "size": Size("2 MiB"), "format": get_format("mdmember") }), Mock(**{ "size": Size("2 MiB"), "format": get_format("mdmember") }) ], total_devices=3) self.dev16 = MDRaidArrayDevice( "dev16", level=6, member_devices=4, parents=[ Mock(**{ "size": Size("4 MiB"), "format": get_format("mdmember") }), Mock(**{ "size": Size("4 MiB"), "format": get_format("mdmember") }), Mock(**{ "size": Size("2 MiB"), "format": get_format("mdmember") }), Mock(**{ "size": Size("2 MiB"), "format": get_format("mdmember") }) ], total_devices=4) self.dev17 = MDRaidArrayDevice( "dev17", level=10, member_devices=4, parents=[ Mock(**{ "size": Size("4 MiB"), "format": get_format("mdmember") }), Mock(**{ "size": Size("4 MiB"), "format": get_format("mdmember") }), Mock(**{ "size": Size("2 MiB"), "format": get_format("mdmember") }), Mock(**{ "size": Size("2 MiB"), "format": get_format("mdmember") }) ], total_devices=4) self.dev18 = MDRaidArrayDevice( "dev18", level=10, member_devices=4, parents=[ Mock(**{ "size": Size("4 MiB"), "format": get_format("mdmember") }), Mock(**{ "size": Size("4 MiB"), "format": get_format("mdmember") }), Mock(**{ "size": Size("2 MiB"), "format": get_format("mdmember") }), Mock(**{ "size": Size("2 MiB"), "format": get_format("mdmember") }) ], total_devices=5) parents = [ DiskDevice("name1", fmt=get_format("mdmember")), DiskDevice("name2", fmt=get_format("mdmember")) ] self.dev19 = MDRaidArrayDevice( "dev19", level="raid1", parents=parents, uuid='3386ff85-f501-2621-4a43-5f061eb47236') parents = [ DiskDevice("name1", fmt=get_format("mdmember")), DiskDevice("name2", fmt=get_format("mdmember")) ] self.dev20 = MDRaidArrayDevice("dev20", level="raid1", parents=parents, uuid='Just-pretending')
def test_expand_taglist(self): tree = DeviceTree() sda = DiskDevice("sda") sdb = DiskDevice("sdb") sdc = DiskDevice("sdc") sdd = DiskDevice("sdd") tree._add_device(sda) tree._add_device(sdb) tree._add_device(sdc) tree._add_device(sdd) sda.tags = {Tags.remote} sdb.tags = {Tags.ssd} sdc.tags = {Tags.local, Tags.ssd} sdd.tags = set() self.assertEqual(tree.expand_taglist(["sda", "sdb"]), {"sda", "sdb"}) self.assertEqual(tree.expand_taglist(["@local"]), {"sdc"}) self.assertEqual(tree.expand_taglist(["@ssd"]), {"sdb", "sdc"}) self.assertEqual(tree.expand_taglist(["@ssd", "sdd", "@local"]), {"sdb", "sdc", "sdd"}) with self.assertRaises(ValueError): tree.expand_taglist(["sdd", "@invalid_tag"])
def test_get_actions(self): """Test GetActions.""" self.assertEqual(self.interface.GetActions(), []) dev1 = DiskDevice( "dev1", fmt=get_format("disklabel"), size=Size("1 GiB"), vendor="VENDOR", model="MODEL" ) self._add_device(dev1) self.storage.initialize_disk(dev1) dev1.format._label_type = "msdos" action_1 = { 'action-type': 'create', 'action-description': 'create format', 'object-type': 'format', 'object-description': 'partition table (MSDOS)', 'device-name': 'dev1', 'device-description': 'VENDOR MODEL (dev1)', 'attrs': {}, } self.assertEqual(get_native(self.interface.GetActions()), [ action_1 ]) dev2 = StorageDevice( "dev2", fmt=get_format("ext4", mountpoint="/boot"), size=Size("500 MiB"), serial="SERIAL", exists=True ) self._add_device(dev2) self.storage.destroy_device(dev2) action_2 = { 'action-type': 'destroy', 'action-description': 'destroy device', 'object-type': 'device', 'object-description': 'blivet', 'device-name': 'dev2', 'device-description': 'dev2', 'attrs': { 'serial': 'SERIAL', 'mount-point': '/boot' }, } self.assertEqual(get_native(self.interface.GetActions()), [ action_2, action_1 ]) dev3 = PartitionDevice( "dev3", fmt=get_format("ext4", mountpoint="/home"), size=Size("500 MiB"), parents=[dev1] ) self.storage.create_device(dev3) dev3.disk = dev1 action_3 = { 'action-type': 'create', 'action-description': 'create device', 'object-type': 'device', 'object-description': 'partition', 'device-name': 'dev3', 'device-description': 'dev3 on VENDOR MODEL', 'attrs': {'mount-point': '/home'}, } action_4 = { 'action-type': 'create', 'action-description': 'create format', 'object-type': 'format', 'object-description': 'ext4', 'device-name': 'dev3', 'device-description': 'dev3 on VENDOR MODEL', 'attrs': {'mount-point': '/home'}, } self.assertEqual(get_native(self.interface.GetActions()), [ action_2, action_1, action_3, action_4, ])
def test_hide_ignored_disks(self): tree = DeviceTree() sda = DiskDevice("sda") sdb = DiskDevice("sdb") sdc = DiskDevice("sdc") tree._add_device(sda) tree._add_device(sdb) tree._add_device(sdc) self.assertTrue(sda in tree.devices) self.assertTrue(sdb in tree.devices) self.assertTrue(sdc in tree.devices) # test ignored_disks tree.ignored_disks = ["sdb"] # verify hide is called as expected with patch.object(tree, "hide") as hide: tree._hide_ignored_disks() hide.assert_called_with(sdb) # verify that hide works as expected tree._hide_ignored_disks() self.assertTrue(sda in tree.devices) self.assertFalse(sdb in tree.devices) self.assertTrue(sdc in tree.devices) # unhide sdb and make sure it works tree.unhide(sdb) self.assertTrue(sda in tree.devices) self.assertTrue(sdb in tree.devices) self.assertTrue(sdc in tree.devices) # test exclusive_disks tree.ignored_disks = [] tree.exclusive_disks = ["sdc"] with patch.object(tree, "hide") as hide: tree._hide_ignored_disks() hide.assert_any_call(sda) hide.assert_any_call(sdb) tree._hide_ignored_disks() self.assertFalse(sda in tree.devices) self.assertFalse(sdb in tree.devices) self.assertTrue(sdc in tree.devices) tree.unhide(sda) tree.unhide(sdb) self.assertTrue(sda in tree.devices) self.assertTrue(sdb in tree.devices) self.assertTrue(sdc in tree.devices) # now test exclusive_disks special cases for multipath sda.format = get_format("multipath_member", exists=True) sdb.format = get_format("multipath_member", exists=True) sdc.format = get_format("multipath_member", exists=True) mpatha = MultipathDevice("mpatha", parents=[sda, sdb, sdc]) tree._add_device(mpatha) tree.ignored_disks = [] tree.exclusive_disks = ["mpatha"] with patch.object(tree, "hide") as hide: tree._hide_ignored_disks() self.assertFalse(hide.called) tree._hide_ignored_disks() self.assertTrue(sda in tree.devices) self.assertTrue(sdb in tree.devices) self.assertTrue(sdc in tree.devices) self.assertTrue(mpatha in tree.devices) # all members in exclusive_disks implies the mpath in exclusive_disks tree.exclusive_disks = ["sda", "sdb", "sdc"] with patch.object(tree, "hide") as hide: tree._hide_ignored_disks() self.assertFalse(hide.called) tree._hide_ignored_disks() self.assertTrue(sda in tree.devices) self.assertTrue(sdb in tree.devices) self.assertTrue(sdc in tree.devices) self.assertTrue(mpatha in tree.devices) tree.exclusive_disks = ["sda", "sdb"] with patch.object(tree, "hide") as hide: tree._hide_ignored_disks() hide.assert_any_call(mpatha) hide.assert_any_call(sdc) # verify that hide works as expected tree._hide_ignored_disks() self.assertTrue(sda in tree.devices) self.assertTrue(sdb in tree.devices) self.assertFalse(sdc in tree.devices) self.assertFalse(mpatha in tree.devices)
def validate_selected_disks_test(self): """Test ValidateSelectedDisks.""" storage = create_storage() self.disk_selection_module.on_storage_reset(storage) dev1 = DiskDevice("dev1", exists=False, size=Size("15 GiB"), fmt=get_format("disklabel")) dev2 = DiskDevice("dev2", exists=False, parents=[dev1], size=Size("6 GiB"), fmt=get_format("disklabel")) dev3 = DiskDevice("dev3", exists=False, parents=[dev2], size=Size("6 GiB"), fmt=get_format("disklabel")) storage.devicetree._add_device(dev1) storage.devicetree._add_device(dev2) storage.devicetree._add_device(dev3) report = ValidationReport.from_structure( get_native(self.disk_selection_interface.ValidateSelectedDisks( []))) self.assertEqual(report.is_valid(), True) report = ValidationReport.from_structure( get_native( self.disk_selection_interface.ValidateSelectedDisks(["dev1"]))) self.assertEqual(report.is_valid(), False) self.assertEqual(report.error_messages, [ "You selected disk dev1, which contains devices that also use " "unselected disks dev2, dev3. You must select or de-select " "these disks as a set." ]) self.assertEqual(report.warning_messages, []) report = ValidationReport.from_structure( get_native( self.disk_selection_interface.ValidateSelectedDisks( ["dev1", "dev2"]))) self.assertEqual(report.is_valid(), False) self.assertEqual(report.error_messages, [ "You selected disk dev1, which contains devices that also " "use unselected disk dev3. You must select or de-select " "these disks as a set.", "You selected disk dev2, which contains devices that also " "use unselected disk dev3. You must select or de-select " "these disks as a set." ]) self.assertEqual(report.warning_messages, []) report = ValidationReport.from_structure( get_native( self.disk_selection_interface.ValidateSelectedDisks( ["dev1", "dev2", "dev3"]))) self.assertEqual(report.is_valid(), True)
def setUp(self): disk1 = DiskDevice("testdisk", size=Size("300 GiB"), exists=True, fmt=get_format("disklabel", exists=True)) disk1.format._supported = False if six.PY3: with self.assertLogs("blivet", level="INFO") as cm: partition1 = PartitionDevice("testpart1", size=Size("150 GiB"), exists=True, parents=[disk1], fmt=get_format("ext4", exists=True)) self.assertTrue("disklabel is unsupported" in "\n".join(cm.output)) else: partition1 = PartitionDevice("testpart1", size=Size("150 GiB"), exists=True, parents=[disk1], fmt=get_format("ext4", exists=True)) if six.PY3: with self.assertLogs("blivet", level="INFO") as cm: partition2 = PartitionDevice("testpart2", size=Size("100 GiB"), exists=True, parents=[disk1], fmt=get_format("lvmpv", exists=True)) self.assertTrue("disklabel is unsupported" in "\n".join(cm.output)) else: partition2 = PartitionDevice("testpart2", size=Size("100 GiB"), exists=True, parents=[disk1], fmt=get_format("lvmpv", exists=True)) # To be supported, all of a devices ancestors must be supported. disk2 = DiskDevice("testdisk2", size=Size("300 GiB"), exists=True, fmt=get_format("lvmpv", exists=True)) vg = LVMVolumeGroupDevice("testvg", exists=True, parents=[partition2, disk2]) lv = LVMLogicalVolumeDevice("testlv", exists=True, size=Size("64 GiB"), parents=[vg], fmt=get_format("ext4", exists=True)) with sparsetmpfile("addparttest", Size("50 MiB")) as disk_file: disk3 = DiskFile(disk_file) disk3.format = get_format("disklabel", device=disk3.path, exists=False) self.disk1 = disk1 self.disk2 = disk2 self.disk3 = disk3 self.partition1 = partition1 self.partition2 = partition2 self.vg = vg self.lv = lv
def _run(): device = DiskDevice(info.name, size=info.size, sysfs_path=info.sys_path) self._add_device(device) return device
def test_validate_selected_disks(self): """Test ValidateSelectedDisks.""" storage = create_storage() self.disk_selection_module.on_storage_changed(storage) dev1 = DiskDevice("dev1", exists=False, size=Size("15 GiB"), fmt=get_format("disklabel")) dev2 = DiskDevice("dev2", exists=False, parents=[dev1], size=Size("6 GiB"), fmt=get_format("disklabel")) dev3 = DiskDevice("dev3", exists=False, parents=[dev2], size=Size("6 GiB"), fmt=get_format("disklabel")) storage.devicetree._add_device(dev1) storage.devicetree._add_device(dev2) storage.devicetree._add_device(dev3) report = ValidationReport.from_structure( self.disk_selection_interface.ValidateSelectedDisks([])) assert report.is_valid() == True report = ValidationReport.from_structure( self.disk_selection_interface.ValidateSelectedDisks(["devX"])) assert report.is_valid() == False assert report.error_messages == [ "The selected disk devX is not recognized." ] assert report.warning_messages == [] report = ValidationReport.from_structure( self.disk_selection_interface.ValidateSelectedDisks(["dev1"])) assert report.is_valid() == False assert report.error_messages == [ "You selected disk dev1, which contains devices that also use " "unselected disks dev2, dev3. You must select or de-select " "these disks as a set." ] assert report.warning_messages == [] report = ValidationReport.from_structure( self.disk_selection_interface.ValidateSelectedDisks( ["dev1", "dev2"])) assert report.is_valid() == False assert report.error_messages == [ "You selected disk dev1, which contains devices that also " "use unselected disk dev3. You must select or de-select " "these disks as a set.", "You selected disk dev2, which contains devices that also " "use unselected disk dev3. You must select or de-select " "these disks as a set." ] assert report.warning_messages == [] report = ValidationReport.from_structure( self.disk_selection_interface.ValidateSelectedDisks( ["dev1", "dev2", "dev3"])) assert report.is_valid() == True
def setUp(self): parents = [ DiskDevice("name1", fmt=getFormat("mdmember")) ] self.dev1 = MDContainerDevice("dev1", level="container", parents=parents) parents = [ DiskDevice("name1", fmt=getFormat("mdmember")), DiskDevice("name2", fmt=getFormat("mdmember")) ] self.dev2 = MDRaidArrayDevice("dev2", level="raid0", parents=parents) parents = [ DiskDevice("name1", fmt=getFormat("mdmember")), DiskDevice("name2", fmt=getFormat("mdmember")) ] self.dev3 = MDRaidArrayDevice("dev3", level="raid1", parents=parents) parents = [ DiskDevice("name1", fmt=getFormat("mdmember")), DiskDevice("name2", fmt=getFormat("mdmember")), DiskDevice("name3", fmt=getFormat("mdmember")) ] self.dev4 = MDRaidArrayDevice("dev4", level="raid4", parents=parents) parents = [ DiskDevice("name1", fmt=getFormat("mdmember")), DiskDevice("name2", fmt=getFormat("mdmember")), DiskDevice("name3", fmt=getFormat("mdmember")) ] self.dev5 = MDRaidArrayDevice("dev5", level="raid5", parents=parents) parents = [ DiskDevice("name1", fmt=getFormat("mdmember")), DiskDevice("name2", fmt=getFormat("mdmember")), DiskDevice("name3", fmt=getFormat("mdmember")), DiskDevice("name4", fmt=getFormat("mdmember")) ] self.dev6 = MDRaidArrayDevice("dev6", level="raid6", parents=parents) parents = [ DiskDevice("name1", fmt=getFormat("mdmember")), DiskDevice("name2", fmt=getFormat("mdmember")), DiskDevice("name3", fmt=getFormat("mdmember")), DiskDevice("name4", fmt=getFormat("mdmember")) ] self.dev7 = MDRaidArrayDevice("dev7", level="raid10", parents=parents) self.dev8 = MDRaidArrayDevice("dev8", level=1, exists=True) parents_1 = [ DiskDevice("name1", fmt=getFormat("mdmember")) ] dev_1 = MDContainerDevice( "parent", level="container", parents=parents_1 ) parents_2 = [ DiskDevice("name1", fmt=getFormat("mdmember")), DiskDevice("name2", fmt=getFormat("mdmember")) ] dev_2 = MDRaidArrayDevice( "other", level=0, fmt=getFormat("mdmember"), parents=parents_2 ) self.dev9 = MDBiosRaidArrayDevice( "dev9", level="raid0", memberDevices=2, parents=[dev_1, dev_2], totalDevices=2 ) parents = [ DiskDevice("name1", fmt=getFormat("mdmember")), DiskDevice("name2", fmt=getFormat("mdmember")) ] self.dev10 = MDRaidArrayDevice( "dev10", level="raid0", parents=parents, size=Size("32 MiB")) parents_1 = [ DiskDevice("name1", fmt=getFormat("mdmember")) ] dev_1 = MDContainerDevice( "parent", level="container", parents=parents ) parents_2 = [ DiskDevice("name1", fmt=getFormat("mdmember")), DiskDevice("name2", fmt=getFormat("mdmember")) ] dev_2 = MDRaidArrayDevice( "other", level=0, fmt=getFormat("mdmember"), parents=parents_2 ) self.dev11 = MDBiosRaidArrayDevice( "dev11", level=1, memberDevices=2, parents=[dev_1, dev_2], size=Size("32 MiB"), totalDevices=2) self.dev12 = MDBiosRaidArrayDevice( "dev12", level=1, memberDevices=2, parents=[ Mock(**{"type": "mdcontainer", "size": Size("4 MiB"), "format": getFormat(None)}), Mock(**{"size": Size("2 MiB"), "format": getFormat("mdmember")})], size=Size("32 MiB"), totalDevices=2) self.dev13 = MDRaidArrayDevice( "dev13", level=0, memberDevices=3, parents=[ Mock(**{"size": Size("4 MiB"), "format": getFormat("mdmember")}), Mock(**{"size": Size("2 MiB"), "format": getFormat("mdmember")})], size=Size("32 MiB"), totalDevices=3) self.dev14 = MDRaidArrayDevice( "dev14", level=4, memberDevices=3, parents=[ Mock(**{"size": Size("4 MiB"), "format": getFormat("mdmember")}), Mock(**{"size": Size("2 MiB"), "format": getFormat("mdmember")}), Mock(**{"size": Size("2 MiB"), "format": getFormat("mdmember")})], totalDevices=3) self.dev15 = MDRaidArrayDevice( "dev15", level=5, memberDevices=3, parents=[ Mock(**{"size": Size("4 MiB"), "format": getFormat("mdmember")}), Mock(**{"size": Size("2 MiB"), "format": getFormat("mdmember")}), Mock(**{"size": Size("2 MiB"), "format": getFormat("mdmember")})], totalDevices=3) self.dev16 = MDRaidArrayDevice( "dev16", level=6, memberDevices=4, parents=[ Mock(**{"size": Size("4 MiB"), "format": getFormat("mdmember")}), Mock(**{"size": Size("4 MiB"), "format": getFormat("mdmember")}), Mock(**{"size": Size("2 MiB"), "format": getFormat("mdmember")}), Mock(**{"size": Size("2 MiB"), "format": getFormat("mdmember")})], totalDevices=4) self.dev17 = MDRaidArrayDevice( "dev17", level=10, memberDevices=4, parents=[ Mock(**{"size": Size("4 MiB"), "format": getFormat("mdmember")}), Mock(**{"size": Size("4 MiB"), "format": getFormat("mdmember")}), Mock(**{"size": Size("2 MiB"), "format": getFormat("mdmember")}), Mock(**{"size": Size("2 MiB"), "format": getFormat("mdmember")})], totalDevices=4) self.dev18 = MDRaidArrayDevice( "dev18", level=10, memberDevices=4, parents=[ Mock(**{"size": Size("4 MiB"), "format": getFormat("mdmember")}), Mock(**{"size": Size("4 MiB"), "format": getFormat("mdmember")}), Mock(**{"size": Size("2 MiB"), "format": getFormat("mdmember")}), Mock(**{"size": Size("2 MiB"), "format": getFormat("mdmember")})], totalDevices=5) parents = [ DiskDevice("name1", fmt=getFormat("mdmember")), DiskDevice("name2", fmt=getFormat("mdmember")) ] self.dev19 = MDRaidArrayDevice( "dev19", level="raid1", parents=parents, uuid='3386ff85-f501-2621-4a43-5f061eb47236' ) parents = [ DiskDevice("name1", fmt=getFormat("mdmember")), DiskDevice("name2", fmt=getFormat("mdmember")) ] self.dev20 = MDRaidArrayDevice( "dev20", level="raid1", parents=parents, uuid='Just-pretending' )