def get_format_data_test(self):
"""Test GetFormatData."""
fmt1 = get_format("ext4", uuid="1234-56-7890", label="LABEL")
dev1 = StorageDevice("dev1", fmt=fmt1, size=Size("10 GiB"))
self._add_device(dev1)
self.assertEqual(self.interface.GetFormatData("dev1"), {
'type': get_variant(Str, 'ext4'),
'attrs': get_variant(Dict[Str, Str], {
"uuid": "1234-56-7890",
"label": "LABEL",
}),
'description': get_variant(Str, 'ext4'),
})
fmt2 = get_format("luks")
dev2 = LUKSDevice("dev2", parents=[dev1], fmt=fmt2, size=Size("10 GiB"))
self._add_device(dev2)
self.assertEqual(self.interface.GetFormatData("dev2"), {
'type': get_variant(Str, 'luks'),
'attrs': get_variant(Dict[Str, Str], {}),
'description': get_variant(Str, 'LUKS'),
})
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_resolve_device(self):
dt = DeviceTree()
dev1_label = "dev1_label"
dev1_uuid = "1234-56-7890"
fmt1 = get_format("ext4", label=dev1_label, uuid=dev1_uuid)
dev1 = StorageDevice("dev1", exists=True, fmt=fmt1)
dt._add_device(dev1)
dev2_label = "dev2_label"
fmt2 = get_format("swap", label=dev2_label)
dev2 = StorageDevice("dev2", exists=True, fmt=fmt2)
dt._add_device(dev2)
dev3 = StorageDevice("sdp2", exists=True)
dt._add_device(dev3)
dt.edd_dict.update({"dev1": 0x81,
"dev2": 0x82})
self.assertEqual(dt.resolve_device(dev1.name), dev1)
self.assertEqual(dt.resolve_device("LABEL=%s" % dev1_label), dev1)
self.assertEqual(dt.resolve_device("UUID=%s" % dev1_label), None)
self.assertEqual(dt.resolve_device("UUID=%s" % dev1_uuid), dev1)
self.assertEqual(dt.resolve_device("/dev/dev1"), dev1)
self.assertEqual(dt.resolve_device("dev2"), dev2)
self.assertEqual(dt.resolve_device("0x82"), dev2)
self.assertEqual(dt.resolve_device(dev3.name), dev3)
def test_formats_methods(self):
##
# get_device_format_class
##
format_pairs = {
None: formats.DeviceFormat,
"bogus": None,
"biosboot": formats.biosboot.BIOSBoot,
"BIOS Boot": formats.biosboot.BIOSBoot,
"nodev": formats.fs.NoDevFS
}
format_names = format_pairs.keys()
format_values = [format_pairs[k] for k in format_names]
self.assertEqual(
[formats.get_device_format_class(x) for x in format_names],
format_values)
# A DeviceFormat object is returned if lookup by name fails
for name in format_names:
self.assertIs(formats.get_format(name).__class__,
formats.DeviceFormat if format_pairs[name] is None else format_pairs[name])
# Consecutively constructed DeviceFormat objects have consecutive ids
names = [key for key in format_pairs.keys() if format_pairs[key] is not None]
objs = [formats.get_format(name) for name in names]
ids = [obj.id for obj in objs]
self.assertEqual(ids, list(range(ids[0], ids[0] + len(ids))))
# Copy or deepcopy should preserve the id
self.assertEqual(ids, [copy.copy(obj).id for obj in objs])
self.assertEqual(ids, [copy.deepcopy(obj).id for obj in objs])
def get_root_device_test(self):
"""Test GetRootDevice."""
self.assertEqual(self.interface.GetRootDevice(), "")
self._add_device(StorageDevice("dev1", fmt=get_format("ext4", mountpoint="/")))
self._add_device(StorageDevice("dev2", fmt=get_format("ext4", mountpoint="/home")))
self.assertEqual(self.interface.GetRootDevice(), "dev1")
def get_devices_test(self):
"""Test GetDevices."""
self.assertEqual(self.interface.GetDevices(), [])
self._add_device(DiskDevice("dev1", fmt=get_format("ext4")))
self._add_device(StorageDevice("dev2", fmt=get_format("ext4")))
self.assertEqual(self.interface.GetDevices(), ["dev1", "dev2"])
def test_net_dev_setting(self):
""" Verify netdev mount option setting after format assignment. """
netdev = FakeNetDev("net1")
dev = StorageDevice("dev1", fmt=get_format("ext4"))
self.assertFalse("_netdev" in dev.format.options.split(","))
dev.parents.append(netdev)
dev.format = get_format("ext4")
self.assertTrue("_netdev" in dev.format.options.split(","))
def setUp(self):
dev1 = DiskDevice("name", fmt=get_format("mdmember"), size=Size("1 GiB"))
dev2 = DiskDevice("other")
self.part = PartitionDevice("part", fmt=get_format("mdmember"), parents=[dev2])
self.dev = MDRaidArrayDevice("dev", level="raid1", parents=[dev1, self.part], fmt=get_format("luks"), total_devices=2, member_devices=2)
self.luks = LUKSDevice("luks", parents=[self.dev], fmt=get_format("ext4"))
self.mdraid_method = availability.BLOCKDEV_MDRAID_PLUGIN._method
self.dm_method = availability.BLOCKDEV_DM_PLUGIN._method
self.cache_availability = availability.CACHE_AVAILABILITY
def get_mount_points_test(self):
"""Test GetMountPoints."""
self.assertEqual(self.interface.GetMountPoints(), {})
self._add_device(StorageDevice("dev1", fmt=get_format("ext4", mountpoint="/")))
self._add_device(StorageDevice("dev2", fmt=get_format("ext4", mountpoint="/home")))
self.assertEqual(self.interface.GetMountPoints(), {
"/": "dev1",
"/home": "dev2"
})
def find_mountable_partitions_test(self, update_size_info):
"""Test FindMountablePartitions."""
self._add_device(StorageDevice(
"dev1",
fmt=get_format("ext4"))
)
self._add_device(PartitionDevice(
"dev2",
fmt=get_format("ext4", exists=True)
))
self.assertEqual(self.interface.FindMountablePartitions(), ["dev2"])
def test_dependencies(self):
dev1 = DiskDevice("name", fmt=get_format("mdmember"))
dev2 = DiskDevice("other", fmt=get_format("mdmember"))
dev = MDRaidArrayDevice("dev", level="raid1", parents=[dev1, dev2])
luks = LUKSDevice("luks", parents=[dev])
# a parent's dependencies are a subset of its child's.
for d in dev.external_dependencies:
self.assertIn(d, luks.external_dependencies)
# make sure that there's at least something in these dependencies
self.assertGreater(len(luks.external_dependencies), 0)
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),
'parents': 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 test_bootloader_in_kickstart(self):
'''
test that a bootloader such as prepboot/biosboot shows up
in the kickstart data
'''
with patch('blivet.osinstall.InstallerStorage.bootloader_device', new_callable=PropertyMock) as mock_bootloader_device:
with patch('blivet.osinstall.InstallerStorage.mountpoints', new_callable=PropertyMock) as mock_mountpoints:
# set up prepboot partition
bootloader_device_obj = PartitionDevice("test_partition_device")
bootloader_device_obj.size = Size('5 MiB')
bootloader_device_obj.format = formats.get_format("prepboot")
blivet_obj = InstallerStorage()
# mountpoints must exist for update_ksdata to run
mock_bootloader_device.return_value = bootloader_device_obj
mock_mountpoints.values.return_value = []
# initialize ksdata
test_ksdata = returnClassForVersion()()
blivet_obj.ksdata = test_ksdata
blivet_obj.update_ksdata()
self.assertTrue("part prepboot" in str(blivet_obj.ksdata))
def test_dependencies_handling(self):
device = StorageDevice("testdev1")
self.assertTrue(device.controllable)
self.assertIsNotNone(ActionCreateDevice(device))
device.exists = True
self.assertIsNotNone(ActionDestroyDevice(device))
with patch.object(StorageDevice, "resizable", new_callable=PropertyMock(return_value=True)):
self.assertIsNotNone(ActionResizeDevice(device, Size("1 GiB")))
# if any external dependency is missing, it should be impossible to create, destroy, setup,
# teardown, or resize the device (controllable encompasses setup & teardown)
with patch.object(StorageDevice, "_external_dependencies",
new_callable=PropertyMock(return_value=[availability.unavailable_resource("testing")])):
device = StorageDevice("testdev1")
self.assertFalse(device.controllable)
self.assertRaises(DependencyError, ActionCreateDevice, device)
device.exists = True
self.assertRaises(DependencyError, ActionDestroyDevice, device)
self.assertRaises(ValueError, ActionResizeDevice, device, Size("1 GiB"))
# same goes for formats, except that the properties they affect vary by format class
fmt = get_format("lvmpv")
fmt._plugin = availability.available_resource("lvm-testing")
self.assertTrue(fmt.supported)
self.assertTrue(fmt.formattable)
self.assertTrue(fmt.destroyable)
fmt._plugin = availability.unavailable_resource("lvm-testing")
self.assertFalse(fmt.supported)
self.assertFalse(fmt.formattable)
self.assertFalse(fmt.destroyable)
def unmount_device_test(self, unmount):
"""Test UnmountDevice."""
self._add_device(StorageDevice("dev1", fmt=get_format("ext4")))
with tempfile.TemporaryDirectory() as d:
self.interface.UnmountDevice("dev1", d)
unmount.assert_called_once_with(mountpoint=d)
def dev(self):
if not self._dev:
self._dev = DirectoryDevice("/dev",
fmt=get_format("bind", device="/dev", mountpoint="/dev", exists=True),
exists=True)
return self._dev
def test_run(self, *args):
"""Test partition device populator."""
device_get_partition_disk = args[0]
device_get_name = args[1]
get_device_by_name = args[2]
devicetree = DeviceTree()
data = Mock()
# for every case:
# 1. device(s) in tree
# 2. lvm filter updated
# 3. exceptions raised
# base case: disk is already in the tree, normal disk
fmt = get_format("disklabel", exists=True, device="/dev/xyz")
disk = DiskDevice("xyz", fmt=fmt, exists=True)
devicetree._add_device(disk)
device_name = "xyz1"
device_get_name.return_value = device_name
device_get_partition_disk.return_value = "xyz"
get_device_by_name.return_value = disk
helper = self.helper_class(devicetree, data)
device = helper.run()
self.assertIsInstance(device, PartitionDevice)
self.assertTrue(device.exists)
self.assertEqual(device.name, device_name)
self.assertTrue(device in devicetree.devices)
def run(self):
if not self._run:
self._run = DirectoryDevice("/run",
fmt=get_format("bind", device="/run", mountpoint="/run", exists=True),
exists=True)
return self._run
def _set_up_storage(self):
# Don't rely on the default being an msdos disklabel since the test
# could be running on an EFI system.
for name in self.disks:
disk = self.blivet.devicetree.get_device_by_name(name)
fmt = get_format("disklabel", label_type="msdos", device=disk.path)
self.blivet.format_device(disk, fmt)
def new_format(self, *args, **kwargs):
""" Return a new DeviceFormat instance suitable for testing.
Keyword Arguments:
device_instance - StorageDevice instance this format will be
created on. This is needed for setup of
resizable formats.
All other arguments are passed directly to
blivet.formats.get_format.
"""
exists = kwargs.pop("exists", False)
device_instance = kwargs.pop("device_instance", None)
fmt = get_format(*args, **kwargs)
if isinstance(fmt, blivet.formats.disklabel.DiskLabel):
fmt._parted_device = Mock()
fmt._parted_disk = Mock()
attrs = {"partitions": []}
fmt._parted_disk.configure_mock(**attrs)
fmt.exists = exists
if exists:
fmt._resizable = fmt.__class__._resizable
if fmt.resizable and device_instance:
fmt._size = device_instance.current_size
return fmt
def test_availability_mdraidplugin(self):
availability.CACHE_AVAILABILITY = False
availability.BLOCKDEV_DM_PLUGIN._method = availability.AvailableMethod
# if the plugin is not in, there's nothing to test
self.assertIn(availability.BLOCKDEV_MDRAID_PLUGIN, self.luks.external_dependencies)
# dev is not among its unavailable dependencies
availability.BLOCKDEV_MDRAID_PLUGIN._method = availability.AvailableMethod
availability.MKFS_HFSPLUS_APP._method = availability.AvailableMethod # macefi
self.assertNotIn(availability.BLOCKDEV_MDRAID_PLUGIN, self.luks.unavailable_dependencies)
self.assertIsNotNone(ActionCreateDevice(self.luks))
self.assertIsNotNone(ActionDestroyDevice(self.luks))
self.assertIsNotNone(ActionCreateFormat(self.luks, fmt=get_format("macefi")))
self.assertIsNotNone(ActionDestroyFormat(self.luks))
# dev is among the unavailable dependencies
availability.BLOCKDEV_MDRAID_PLUGIN._method = availability.UnavailableMethod
self.assertIn(availability.BLOCKDEV_MDRAID_PLUGIN, self.luks.unavailable_dependencies)
with self.assertRaises(ValueError):
ActionCreateDevice(self.luks)
with self.assertRaises(ValueError):
ActionDestroyDevice(self.dev)
with self.assertRaises(ValueError):
ActionCreateFormat(self.dev)
with self.assertRaises(ValueError):
ActionDestroyFormat(self.dev)
def test_packages(self):
dev1 = DiskDevice("name", fmt=get_format("mdmember"))
dev2 = DiskDevice("other", fmt=get_format("mdmember"))
dev = MDRaidArrayDevice("dev", level="raid1", parents=[dev1, dev2])
luks = LUKSDevice("luks", parents=[dev])
packages = luks.packages
# no duplicates in list of packages
self.assertEqual(len(packages), len(set(packages)))
# several packages that ought to be included are
for package in dev1.packages + dev2.packages + dev.packages:
self.assertIn(package, packages)
for package in dev1.format.packages + dev2.format.packages + dev.format.packages:
self.assertIn(package, packages)
def test_vgchunk_with_cache_pvfree(self):
pv = StorageDevice("pv1", size=Size("40 GiB"),
fmt=get_format("lvmpv"))
# 1069 MiB so that the PV provides 1068 MiB of free space (see
# LVMVolumeGroupDevice.extents) which is 44 MiB more than the caches
# need and which should thus be split into the LVs
pv2 = StorageDevice("pv2", size=Size("1069 MiB"),
fmt=get_format("lvmpv"))
vg = LVMVolumeGroupDevice("vg", parents=[pv, pv2])
cache_req1 = LVMCacheRequest(Size("512 MiB"), [pv2], "writethrough")
lv1 = LVMLogicalVolumeDevice("lv1", parents=[vg],
size=Size("1 GiB"), grow=True,
cache_request=cache_req1)
cache_req2 = LVMCacheRequest(Size("512 MiB"), [pv2], "writethrough")
lv2 = LVMLogicalVolumeDevice("lv2", parents=[vg],
size=Size("10 GiB"), grow=True,
cache_request=cache_req2)
lv3 = LVMLogicalVolumeDevice("lv3", parents=[vg],
size=Size("10 GiB"), grow=True,
maxsize=Size("12 GiB"))
req1 = LVRequest(lv1)
req2 = LVRequest(lv2)
req3 = LVRequest(lv3)
chunk = VGChunk(vg, requests=[req1, req2, req3])
chunk.grow_requests()
# the chunk is done growing since its pool has been exhausted
self.assertEqual(chunk.done, True)
# there are still two requests remaining since lv1 and lv2 have no max
self.assertEqual(chunk.remaining, 2)
# All the sizes should be the same as without the caches (see the
# test_vgchunk test for their "rationales") because the space for the
# caches should just be reserved.
# The extra 11 extents available on the pv2 should go in the 1:10 ratio
# to req1 and req2.
self.assertEqual(req1.growth, 395 + 1)
self.assertEqual(req2.growth, 3956 + 10)
self.assertEqual(req3.growth, 512)
def get_supported_file_systems_test(self):
"""Test GetSupportedFileSystems."""
result = self.interface.GetSupportedFileSystems()
self.assertIsInstance(result, list)
self.assertNotEqual(len(result), 0)
for fs in result:
self.assertIsInstance(fs, str)
self.assertEqual(fs, get_format(fs).type)
def get_file_system_free_space_test(self):
"""Test GetFileSystemFreeSpace."""
self._add_device(
StorageDevice("dev1",
fmt=get_format("ext4", mountpoint="/"),
size=Size("5 GiB")))
self._add_device(
StorageDevice("dev2",
fmt=get_format("ext4", mountpoint="/usr"),
size=Size("5 GiB")))
total_size = self.interface.GetFileSystemFreeSpace([])
self.assertEqual(total_size, 0)
total_size = self.interface.GetFileSystemFreeSpace(["/", "/usr"])
self.assertLess(total_size, Size("10 GiB").get_bytes())
self.assertGreater(total_size, Size("8 GiB").get_bytes())
def test_get_device_mount_options(self):
"""Test GetDeviceMountOptions."""
dev1 = StorageDevice("dev1", size=Size("10 GiB"))
self._add_device(dev1)
assert self.interface.GetDeviceMountOptions("dev1") == ""
dev1.format = get_format("ext4")
dev1.format.options = "defaults,ro"
assert self.interface.GetDeviceMountOptions("dev1") == "defaults,ro"
def test_get_file_system_free_space(self):
"""Test GetFileSystemFreeSpace."""
self._add_device(
StorageDevice("dev1",
fmt=get_format("ext4", mountpoint="/"),
size=Size("5 GiB")))
self._add_device(
StorageDevice("dev2",
fmt=get_format("ext4", mountpoint="/usr"),
size=Size("5 GiB")))
total_size = self.interface.GetFileSystemFreeSpace([])
assert total_size == 0
total_size = self.interface.GetFileSystemFreeSpace(["/", "/usr"])
assert total_size < Size("10 GiB").get_bytes()
assert total_size > Size("8 GiB").get_bytes()
def test_find_unconfigured_luks(self):
"""Test FindUnconfiguredLUKS."""
assert self.interface.FindUnconfiguredLUKS() == []
dev1 = StorageDevice("dev1",
fmt=get_format("ext4"),
size=Size("10 GiB"))
self._add_device(dev1)
assert self.interface.FindUnconfiguredLUKS() == []
dev2 = LUKSDevice("dev2",
parents=[dev1],
fmt=get_format("luks"),
size=Size("10 GiB"))
self._add_device(dev2)
assert self.interface.FindUnconfiguredLUKS() == ["dev2"]
def find_unconfigured_luks_test(self):
"""Test FindUnconfiguredLUKS."""
self.assertEqual(self.interface.FindUnconfiguredLUKS(), [])
dev1 = StorageDevice("dev1",
fmt=get_format("ext4"),
size=Size("10 GiB"))
self._add_device(dev1)
self.assertEqual(self.interface.FindUnconfiguredLUKS(), [])
dev2 = LUKSDevice("dev2",
parents=[dev1],
fmt=get_format("luks"),
size=Size("10 GiB"))
self._add_device(dev2)
self.assertEqual(self.interface.FindUnconfiguredLUKS(), ["dev2"])
def test_get_supported_file_systems(self):
"""Test GetSupportedFileSystems."""
result = self.interface.GetSupportedFileSystems()
assert isinstance(result, list)
assert len(result) != 0
for fs in result:
assert isinstance(fs, str)
assert fs == get_format(fs).type
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 opal_verification_old_firmware_test(self, mocked_arch, version_getter, xfs_mountable):
"""Check verify_opal_compatibility with an older firmware."""
reporter = Mock()
storage = create_storage()
mocked_arch.get_arch.return_value = "ppc64le"
mocked_arch.is_powernv.return_value = True
version_getter.return_value = "5.9.50-openpower1-p59fd803"
xfs_mountable.return_value = True
# No devices.
verify_opal_compatibility(storage, {}, None, reporter)
reporter.assert_not_called()
# No mount points.
dev1 = StorageDevice("dev1", size=Size("10 GiB"))
storage.devicetree._add_device(dev1)
verify_opal_compatibility(storage, {}, None, reporter)
reporter.assert_not_called()
# Different filesystem.
dev1.format = get_format("ext2", mountpoint="/boot")
verify_opal_compatibility(storage, {}, None, reporter)
reporter.assert_not_called()
# XFS on /
dev1.format = get_format("xfs", mountpoint="/")
verify_opal_compatibility(storage, {}, None, reporter)
reporter.assert_called_once_with(
"Your firmware doesn't support XFS file system features "
"on the /boot file system. The system will not be bootable. "
"Please, upgrade the firmware or change the file system type."
)
reporter.reset_mock()
# XFS on /boot
dev1.format = get_format("xfs", mountpoint="/boot")
verify_opal_compatibility(storage, {}, None, reporter)
reporter.assert_called_once_with(
"Your firmware doesn't support XFS file system features "
"on the /boot file system. The system will not be bootable. "
"Please, upgrade the firmware or change the file system type."
)
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 reset_device_test(self):
"""Test ResetDevice."""
dev1 = StorageDevice("dev1",
exists=False,
size=Size("15 GiB"),
fmt=get_format("disklabel"))
dev2 = StorageDevice("dev2",
exists=False,
parents=[dev1],
size=Size("6 GiB"),
fmt=get_format("ext4"))
dev3 = StorageDevice("dev3", exists=True, size=Size("6 GiB"))
dev3.original_format = get_format("ext4")
dev3.format = get_format("xfs")
self.module.on_storage_changed(create_storage())
self.module.storage.devicetree._add_device(dev1)
self.module.storage.devicetree._add_device(dev2)
self.module.storage.devicetree._add_device(dev3)
with self.assertRaises(StorageConfigurationError):
self.interface.ResetDevice("dev1")
self.assertIn(dev1, self.module.storage.devices)
self.assertIn(dev2, self.module.storage.devices)
self.assertIn(dev3, self.module.storage.devices)
self.assertEqual(dev3.format.type, "xfs")
self.interface.ResetDevice("dev2")
self.assertNotIn(dev1, self.module.storage.devices)
self.assertNotIn(dev2, self.module.storage.devices)
self.assertIn(dev3, self.module.storage.devices)
self.assertEqual(dev3.format.type, "xfs")
self.interface.ResetDevice("dev3")
self.assertNotIn(dev1, self.module.storage.devices)
self.assertNotIn(dev2, self.module.storage.devices)
self.assertIn(dev3, self.module.storage.devices)
self.assertEqual(dev3.format.type, "ext4")
def test_reset_device(self):
"""Test ResetDevice."""
dev1 = StorageDevice("dev1",
exists=False,
size=Size("15 GiB"),
fmt=get_format("disklabel"))
dev2 = StorageDevice("dev2",
exists=False,
parents=[dev1],
size=Size("6 GiB"),
fmt=get_format("ext4"))
dev3 = StorageDevice("dev3", exists=True, size=Size("6 GiB"))
dev3.original_format = get_format("ext4")
dev3.format = get_format("xfs")
self.module.on_storage_changed(create_storage())
self.module.storage.devicetree._add_device(dev1)
self.module.storage.devicetree._add_device(dev2)
self.module.storage.devicetree._add_device(dev3)
with pytest.raises(StorageConfigurationError):
self.interface.ResetDevice("dev1")
assert dev1 in self.module.storage.devices
assert dev2 in self.module.storage.devices
assert dev3 in self.module.storage.devices
assert dev3.format.type == "xfs"
self.interface.ResetDevice("dev2")
assert dev1 not in self.module.storage.devices
assert dev2 not in self.module.storage.devices
assert dev3 in self.module.storage.devices
assert dev3.format.type == "xfs"
self.interface.ResetDevice("dev3")
assert dev1 not in self.module.storage.devices
assert dev2 not in self.module.storage.devices
assert dev3 in self.module.storage.devices
assert dev3.format.type == "ext4"
def test_msdos_disk_chunk1(self):
disk_size = Size("100 MiB")
with sparsetmpfile("chunktest", disk_size) as disk_file:
disk = DiskFile(disk_file)
disk.format = get_format("disklabel",
device=disk.path,
exists=False,
label_type="msdos")
p1 = PartitionDevice("p1", size=Size("10 MiB"), grow=True)
p2 = PartitionDevice("p2", size=Size("30 MiB"), grow=True)
disks = [disk]
partitions = [p1, p2]
free = get_free_regions([disk])
self.assertEqual(len(free), 1,
"free region count %d not expected" % len(free))
b = Mock(spec=Blivet)
allocate_partitions(b, disks, partitions, free)
requests = [PartitionRequest(p) for p in partitions]
chunk = DiskChunk(free[0], requests=requests)
# parted reports a first free sector of 32 for msdos on disk files. whatever.
# XXX on gpt, the start is increased to 34 and the end is reduced from 204799 to 204766,
# yielding an expected length of 204733
length_expected = 204768
self.assertEqual(chunk.length, length_expected)
base_expected = sum(p.parted_partition.geometry.length
for p in partitions)
self.assertEqual(chunk.base, base_expected)
pool_expected = chunk.length - base_expected
self.assertEqual(chunk.pool, pool_expected)
self.assertEqual(chunk.done, False)
self.assertEqual(chunk.remaining, 2)
chunk.grow_requests()
self.assertEqual(chunk.done, True)
self.assertEqual(chunk.pool, 0)
self.assertEqual(chunk.remaining, 2)
#
# validate the growth (everything in sectors)
#
# The chunk length is 204768. The base of p1 is 20480. The base of
# p2 is 61440. The chunk has a base of 81920 and a pool of 122848.
#
# p1 should grow by 30712 while p2 grows by 92136 since p2's base
# size is exactly three times that of p1.
self.assertEqual(requests[0].growth, 30712)
self.assertEqual(requests[1].growth, 92136)
def test_size_setter(self):
initial_size = Size('10 GiB')
new_size = Size('2 GiB')
##
# setter sets the size
##
dev = self._get_device('sizetest', size=initial_size)
self.assertEqual(dev.size, initial_size)
dev.size = new_size
self.assertEqual(dev.size, new_size)
##
# setter raises exn if size outside of format limits
##
dev.format._max_size = Size("5 GiB")
with self.assertRaises(errors.DeviceError):
dev.size = Size("6 GiB")
##
# new formats' min size is checked against device size
##
fmt = get_format(None)
fmt._min_size = Size("10 GiB")
with self.assertRaises(errors.DeviceError):
dev.format = fmt
# the format assignment should succeed without the min size conflict
fmt._min_size = Size(0)
dev.format = fmt
##
# new formats' max size is checked against device size
##
fmt = get_format(None)
fmt._max_size = Size("10 MiB")
with self.assertRaises(errors.DeviceError):
dev.format = fmt
# the format assignment should succeed without the min size conflict
fmt._max_size = Size(0)
dev.format = fmt
def run(self):
if not self._run:
self._run = DirectoryDevice("/run",
fmt=get_format("bind",
device="/run",
mountpoint="/run",
exists=True),
exists=True)
return self._run
def parse(self, args):
retval = super().parse(args)
if self.fstype:
fmt = get_format(self.fstype)
if not fmt or fmt.type is None:
raise KickstartParseError(_("File system type \"{}\" given in autopart command is "
"invalid.").format(self.fstype), lineno=self.lineno)
return retval
def get_device_mount_options_test(self):
"""Test GetDeviceMountOptions."""
dev1 = StorageDevice("dev1", size=Size("10 GiB"))
self._add_device(dev1)
self.assertEqual(self.interface.GetDeviceMountOptions("dev1"), "")
dev1.format = get_format("ext4")
dev1.format.options = "defaults,ro"
self.assertEqual(self.interface.GetDeviceMountOptions("dev1"),
"defaults,ro")
def _setup_mount_point(self, storage, mount_data):
"""Set up a mount point.
:param storage: an instance of the Blivet's storage object
:param mount_data: an instance of MountData
"""
device = mount_data[MOUNT_POINT_DEVICE]
device_reformat = mount_data[MOUNT_POINT_REFORMAT]
device_format = mount_data[MOUNT_POINT_FORMAT]
dev = storage.devicetree.resolve_device(device)
if dev is None:
raise KickstartParseError(_("Unknown or invalid device '%s' specified") % device)
if device_reformat:
if device_format:
fmt = get_format(device_format)
if not fmt:
raise KickstartParseError(
_("Unknown or invalid format '%(format)s' specified for device "
"'%(device)s'") % {"format": device_format, "device": device}
)
else:
old_fmt = dev.format
if not old_fmt or old_fmt.type is None:
raise KickstartParseError(_("No format on device '%s'") % device)
fmt = get_format(old_fmt.type)
storage.format_device(dev, fmt)
# make sure swaps end up in /etc/fstab
if fmt.type == "swap":
storage.add_fstab_swap(dev)
# only set mount points for mountable formats
mount_point = mount_data[MOUNT_POINT_PATH]
if dev.format.mountable and mount_point and mount_point != "none":
dev.format.mountpoint = mount_point
dev.format.create_options = mount_data[MOUNT_POINT_FORMAT_OPTIONS]
dev.format.options = mount_data[MOUNT_POINT_MOUNT_OPTIONS]
def test_get_format_data(self):
"""Test GetFormatData."""
fmt1 = get_format(
"ext4",
uuid="1234-56-7890",
label="LABEL",
mountpoint="/home"
)
dev1 = StorageDevice(
"dev1",
fmt=fmt1,
size=Size("10 GiB")
)
self._add_device(dev1)
self.assertEqual(self.interface.GetFormatData("dev1"), {
'type': get_variant(Str, 'ext4'),
'mountable': get_variant(Bool, True),
'attrs': get_variant(Dict[Str, Str], {
"uuid": "1234-56-7890",
"label": "LABEL",
"mount-point": "/home"
}),
'description': get_variant(Str, 'ext4'),
})
fmt2 = get_format(
"luks"
)
dev2 = LUKSDevice(
"dev2",
parents=[dev1],
fmt=fmt2,
size=Size("10 GiB")
)
self._add_device(dev2)
self.assertEqual(self.interface.GetFormatData("dev2"), {
'type': get_variant(Str, 'luks'),
'mountable': get_variant(Bool, False),
'attrs': get_variant(Dict[Str, Str], {}),
'description': get_variant(Str, 'LUKS'),
})
def parse(self, args):
retval = super().parse(args)
if self.fstype:
fmt = get_format(self.fstype)
if not fmt or fmt.type is None:
raise KickstartParseError(_("File system type \"{}\" given in autopart command is "
"invalid.").format(self.fstype), lineno=self.lineno)
return retval
def dev(self):
if not self._dev:
self._dev = DirectoryDevice("/dev",
fmt=get_format("bind",
device="/dev",
mountpoint="/dev",
exists=True),
exists=True)
return self._dev
def test_size_setter(self):
initial_size = Size('10 GiB')
new_size = Size('2 GiB')
##
# setter sets the size
##
dev = self._get_device('sizetest', size=initial_size)
self.assertEqual(dev.size, initial_size)
dev.size = new_size
self.assertEqual(dev.size, new_size)
##
# setter raises exn if size outside of format limits
##
dev.format._max_size = Size("5 GiB")
with self.assertRaises(errors.DeviceError):
dev.size = Size("6 GiB")
##
# new formats' min size is checked against device size
##
fmt = get_format(None)
fmt._min_size = Size("10 GiB")
with self.assertRaises(errors.DeviceError):
dev.format = fmt
# the format assignment should succeed without the min size conflict
fmt._min_size = Size(0)
dev.format = fmt
##
# new formats' max size is checked against device size
##
fmt = get_format(None)
fmt._max_size = Size("10 MiB")
with self.assertRaises(errors.DeviceError):
dev.format = fmt
# the format assignment should succeed without the min size conflict
fmt._max_size = Size(0)
dev.format = fmt
def get_format_type_data(self, format_name):
"""Get the format type data.
For example: ext4
:param format_name: a name of the format type
:return: an instance of DeviceFormatData
"""
fmt = get_format(format_name)
return self._get_format_data(fmt)
def test_vgchunk_with_cache(self):
pv = StorageDevice("pv1", size=Size("40 GiB"),
fmt=get_format("lvmpv"))
# 1025 MiB so that the PV provides 1024 MiB of free space (see
# LVMVolumeGroupDevice.extents)
pv2 = StorageDevice("pv2", size=Size("1025 MiB"),
fmt=get_format("lvmpv"))
vg = LVMVolumeGroupDevice("vg", parents=[pv, pv2])
cache_req1 = LVMCacheRequest(Size("512 MiB"), [pv2], "writethrough")
lv1 = LVMLogicalVolumeDevice("lv1", parents=[vg],
size=Size("1 GiB"), grow=True,
cache_request=cache_req1)
cache_req2 = LVMCacheRequest(Size("512 MiB"), [pv2], "writethrough")
lv2 = LVMLogicalVolumeDevice("lv2", parents=[vg],
size=Size("10 GiB"), grow=True,
cache_request=cache_req2)
lv3 = LVMLogicalVolumeDevice("lv3", parents=[vg],
size=Size("10 GiB"), grow=True,
maxsize=Size("12 GiB"))
req1 = LVRequest(lv1)
req2 = LVRequest(lv2)
req3 = LVRequest(lv3)
chunk = VGChunk(vg, requests=[req1, req2, req3])
chunk.grow_requests()
# the chunk is done growing since its pool has been exhausted
self.assertEqual(chunk.done, True)
# there are still two requests remaining since lv1 and lv2 have no max
self.assertEqual(chunk.remaining, 2)
# All the sizes should be the same as without the caches (see the
# test_vgchunk test for their "rationales") because the space for the
# caches should just be reserved.
self.assertEqual(req1.growth, 395)
self.assertEqual(req2.growth, 3956)
self.assertEqual(req3.growth, 512)
def get_disks_test(self):
"""Test GetDisks."""
self.assertEqual(self.interface.GetDisks(), [])
self._add_device(
DiskDevice("dev1",
fmt=get_format("ext4"),
exists=True,
size=Size("10 GiB")))
self.assertEqual(self.interface.GetDisks(), ["dev1"])
def test_resizable(self):
""" Test resizable property of unformatted devices. """
# Devices with no (or unrecognized) formatting should not be resizable.
device = StorageDevice("testdev1", exists=True, size=Size("100 G"), fmt=get_format("ext4", exists=True))
device._resizable = True
with patch.object(device, "_format", exists=True, resizable=True):
self.assertTrue(device.resizable)
device = StorageDevice("testdev1", exists=True, size=Size("100 G"))
device._resizable = True
self.assertFalse(device.resizable)
def test_get_disks(self):
"""Test GetDisks."""
assert self.interface.GetDisks() == []
self._add_device(
DiskDevice("dev1",
fmt=get_format("ext4"),
exists=True,
size=Size("10 GiB")))
assert self.interface.GetDisks() == ["dev1"]
def mount_existing_system_test(self, mount):
storage = create_storage()
device = StorageDevice("dev1", fmt=get_format("ext4"))
storage.devicetree._add_device(device)
task = MountExistingSystemTask(storage, device, True)
task.run()
mount.assert_called_once_with(storage=storage,
root_device=device,
read_only=True)
def test_mount_existing_system_with_task(self, publisher):
"""Test MountExistingSystemWithTask."""
self._add_device(StorageDevice("dev1", fmt=get_format("ext4")))
task_path = self.interface.MountExistingSystemWithTask("dev1", True)
obj = check_task_creation(self, task_path, publisher, MountExistingSystemTask)
self.assertEqual(obj.implementation._storage, self.module.storage)
self.assertEqual(obj.implementation._device.name, "dev1")
self.assertEqual(obj.implementation._read_only, True)
def test_resizable(self):
""" Test resizable property of unformatted devices. """
# Devices with no (or unrecognized) formatting should not be resizable.
device = StorageDevice("testdev1", exists=True, size=Size("100 G"), fmt=get_format("ext4", exists=True))
device._resizable = True
with patch.object(device, "_format", exists=True, resizable=True):
self.assertTrue(device.resizable)
device = StorageDevice("testdev1", exists=True, size=Size("100 G"))
device._resizable = True
self.assertFalse(device.resizable)
def get_existing_systems_test(self):
"""Test GetExistingSystems."""
self.assertEqual(self.interface.GetExistingSystems(), [])
root_device = StorageDevice("dev1", fmt=get_format("ext4"))
swap_device = StorageDevice("dev2", fmt=get_format("swap"))
self.storage.roots = [
Root(name="My Linux",
mounts={"/": root_device},
swaps=[swap_device])
]
self.assertEqual(
self.interface.GetExistingSystems(),
[{
'os-name': get_variant(Str, 'My Linux'),
'mount-points': get_variant(Dict[Str, Str], {'/': 'dev1'}),
'swap-devices': get_variant(List[Str], ['dev2'])
}])
def get_file_system_free_space_test(self):
"""Test GetFileSystemFreeSpace."""
self._add_device(StorageDevice(
"dev1",
fmt=get_format("ext4", mountpoint="/"),
size=Size("5 GiB"))
)
self._add_device(StorageDevice(
"dev2",
fmt=get_format("ext4", mountpoint="/usr"),
size=Size("5 GiB"))
)
total_size = self.interface.GetFileSystemFreeSpace([])
self.assertEqual(total_size, 0)
total_size = self.interface.GetFileSystemFreeSpace(["/", "/usr"])
self.assertLess(total_size, Size("10 GiB").get_bytes())
self.assertGreater(total_size, Size("8 GiB").get_bytes())
def test_mdfactory(self):
factory1 = devicefactory.get_device_factory(
self.b,
devicefactory.DEVICE_TYPE_MD,
size=Size("1 GiB"),
raid_level=raid.RAID1)
factory2 = devicefactory.get_device_factory(
self.b,
devicefactory.DEVICE_TYPE_MD,
size=Size("1 GiB"),
raid_level=0)
with six.assertRaisesRegex(self, devicefactory.DeviceFactoryError,
"must have some RAID level"):
devicefactory.get_device_factory(self.b,
devicefactory.DEVICE_TYPE_MD,
size=Size("1 GiB"))
with six.assertRaisesRegex(self, RaidError, "requires at least"):
factory1._get_device_space()
with six.assertRaisesRegex(self, RaidError, "requires at least"):
factory1._configure()
self.assertEqual(factory1.container_list, [])
self.assertIsNone(factory1.get_container())
parents = [
DiskDevice("name1", fmt=get_format("mdmember")),
DiskDevice("name2", fmt=get_format("mdmember"))
]
self.assertIsNotNone(factory1._get_new_device(parents=parents))
with six.assertRaisesRegex(self, RaidError, "requires at least"):
factory2._get_device_space()
self.assertEqual(factory2.container_list, [])
self.assertIsNone(factory2.get_container())
def get_disks_test(self):
"""Test GetDisks."""
self.assertEqual(self.interface.GetDisks(), [])
self._add_device(DiskDevice(
"dev1",
fmt=get_format("ext4"),
exists=True,
size=Size("10 GiB"))
)
self.assertEqual(self.interface.GetDisks(), ["dev1"])
def unlock_device_test(self, device_setup, device_teardown, format_setup, populate):
"""Test UnlockDevice."""
dev1 = StorageDevice("dev1", fmt=get_format("ext4"), size=Size("10 GiB"))
self._add_device(dev1)
dev2 = LUKSDevice("dev2", parents=[dev1], fmt=get_format("luks"), size=Size("10 GiB"))
self._add_device(dev2)
self.assertEqual(self.interface.UnlockDevice("dev2", "passphrase"), True)
device_setup.assert_called_once()
format_setup.assert_called_once()
populate.assert_called_once()
device_teardown.assert_not_called()
self.assertTrue(dev2.format.has_key)
device_setup.side_effect = StorageError("Fake error")
self.assertEqual(self.interface.UnlockDevice("dev2", "passphrase"), False)
device_teardown.assert_called_once()
self.assertFalse(dev2.format.has_key)
def setUp(self):
dev1 = DiskDevice("name",
fmt=get_format("mdmember"),
size=Size("1 GiB"))
dev2 = DiskDevice("other")
self.part = PartitionDevice("part",
fmt=get_format("mdmember"),
parents=[dev2])
self.dev = MDRaidArrayDevice("dev",
level="raid1",
parents=[dev1, self.part],
fmt=get_format("luks"),
total_devices=2,
member_devices=2)
self.luks = LUKSDevice("luks",
parents=[self.dev],
fmt=get_format("ext4"))
self.mdraid_method = availability.BLOCKDEV_MDRAID_PLUGIN._method
self.dm_method = availability.BLOCKDEV_DM_PLUGIN._method
self.cache_availability = availability.CACHE_AVAILABILITY
