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_get_device_size_limits(self):
"""Test GetDeviceSizeLimits."""
self.module.on_storage_changed(create_storage())
self._add_device(
StorageDevice("dev1", fmt=get_format("ext4"), size=Size("10 MiB")))
min_size, max_size = self.interface.GetDeviceSizeLimits("dev1")
assert min_size == 0
assert max_size == 0
def test_lvm_logical_volume_with_pvs_init(self):
pv = StorageDevice("pv1",
fmt=blivet.formats.get_format("lvmpv"),
size=Size("1025 MiB"))
pv2 = StorageDevice("pv2",
fmt=blivet.formats.get_format("lvmpv"),
size=Size("512 MiB"))
vg = LVMVolumeGroupDevice("testvg", parents=[pv, pv2])
pv_spec = LVPVSpec(pv, Size("1 GiB"))
lv = LVMLogicalVolumeDevice("testlv",
parents=[vg],
size=Size("1 GiB"),
fmt=blivet.formats.get_format("xfs"),
exists=False,
pvs=[pv_spec])
self.assertEqual([spec.pv for spec in lv._pv_specs], [pv])
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 test_net_device_manual(self):
""" Verify netdev mount option is not removed if explicitly set by the user. """
dev = StorageDevice("dev1", fmt=get_format("ext4", mountopts="_netdev"))
self.assertTrue("_netdev" in dev.format.options.split(","))
# these create methods shouldn't write anything to disk
dev.create()
self.assertTrue("_netdev" in dev.format.options.split(","))
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 generate_system_data_test(self):
"""Test GenerateSystemData."""
self._add_device(
StorageDevice("dev1", fmt=get_format("ext4", mountpoint="/boot")))
self._add_device(
StorageDevice("dev2", fmt=get_format("ext4", mountpoint="/")))
self._add_device(StorageDevice("dev3", fmt=get_format("swap")))
os_data = self.interface.GenerateSystemData("dev1")
self.assertEqual(
get_native(os_data), {
'mount-points': {
'/boot': 'dev1',
'/': 'dev2'
},
'os-name': 'New anaconda bluesky Installation',
'swap-devices': ['dev3']
})
def testNetDevSetting(self):
""" Verify netdev mount option setting after format assignment. """
netdev = FakeNetDev("net1")
dev = StorageDevice("dev1", fmt=getFormat("ext4"))
self.assertFalse("_netdev" in dev.format.options.split(","))
dev.parents.append(netdev)
dev.format = getFormat("ext4")
self.assertTrue("_netdev" in dev.format.options.split(","))
def setUp(self):
self.dev1 = BTRFSVolumeDevice(
"dev1",
parents=[
StorageDevice("deva",
fmt=blivet.formats.get_format("btrfs"),
size=BTRFS_MIN_MEMBER_SIZE)
])
self.dev2 = BTRFSSubVolumeDevice(
"dev2",
parents=[self.dev1],
fmt=blivet.formats.get_format("btrfs"))
dev = StorageDevice("deva",
fmt=blivet.formats.get_format("btrfs"),
size=Size("500 MiB"))
self.dev3 = BTRFSVolumeDevice("dev3", parents=[dev])
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 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_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 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_lvm_logical_volume_metadata_size(self):
pv = StorageDevice("pv1",
fmt=blivet.formats.get_format("lvmpv"),
size=Size("1025 MiB"))
pv2 = StorageDevice("pv2",
fmt=blivet.formats.get_format("lvmpv"),
size=Size("513 MiB"))
vg = LVMVolumeGroupDevice("testvg", parents=[pv, pv2])
lv = LVMLogicalVolumeDevice("testlv",
parents=[vg],
size=Size("512 MiB"),
fmt=blivet.formats.get_format("xfs"),
exists=False,
seg_type="raid1",
pvs=[pv, pv2])
self.assertEqual(lv.metadata_size, Size("4 MiB"))
# two copies of metadata
self.assertEqual(lv.metadata_vg_space_used, Size("8 MiB"))
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 test_lvm_logical_volume_insuf_seg_type(self):
# pylint: disable=unused-variable
pv = StorageDevice("pv1",
fmt=blivet.formats.get_format("lvmpv"),
size=Size("1025 MiB"))
pv2 = StorageDevice("pv2",
fmt=blivet.formats.get_format("lvmpv"),
size=Size("513 MiB"))
vg = LVMVolumeGroupDevice("testvg", parents=[pv, pv2])
# pvs have to be specified for non-linear LVs
with self.assertRaises(ValueError):
lv = LVMLogicalVolumeDevice("testlv",
parents=[vg],
size=Size("512 MiB"),
fmt=blivet.formats.get_format("xfs"),
exists=False,
seg_type="raid1")
with self.assertRaises(ValueError):
lv = LVMLogicalVolumeDevice("testlv",
parents=[vg],
size=Size("512 MiB"),
fmt=blivet.formats.get_format("xfs"),
exists=False,
seg_type="striped")
# no or complete specification has to be given for linear LVs
with self.assertRaises(ValueError):
lv = LVMLogicalVolumeDevice("testlv",
parents=[vg],
size=Size("512 MiB"),
fmt=blivet.formats.get_format("xfs"),
exists=False,
pvs=[pv])
with self.assertRaises(ValueError):
pv_spec = LVPVSpec(pv, Size("256 MiB"))
pv_spec2 = LVPVSpec(pv2, Size("250 MiB"))
lv = LVMLogicalVolumeDevice("testlv",
parents=[vg],
size=Size("512 MiB"),
fmt=blivet.formats.get_format("xfs"),
exists=False,
pvs=[pv_spec, pv_spec2])
def test_lvmcached_logical_volume_init(self):
pv = StorageDevice("pv1",
fmt=blivet.formats.get_format("lvmpv"),
size=Size("1 GiB"))
pv2 = StorageDevice("pv2",
fmt=blivet.formats.get_format("lvmpv"),
size=Size("512 MiB"))
vg = LVMVolumeGroupDevice("testvg", parents=[pv, pv2])
cache_req = LVMCacheRequest(Size("512 MiB"), [pv2], "writethrough")
xfs_fmt = blivet.formats.get_format("xfs")
lv = LVMLogicalVolumeDevice("testlv",
parents=[vg],
fmt=xfs_fmt,
size=Size(xfs_fmt.min_size),
exists=False,
cache_request=cache_req)
self.assertEqual(lv.size, xfs_fmt.min_size)
# check that the LV behaves like a cached LV
self.assertTrue(lv.cached)
cache = lv.cache
self.assertIsNotNone(cache)
# the cache reserves space for its metadata from the requested size, but
# it may require (and does in this case) a pmspare LV to be allocated
self.assertEqual(lv.vg_space_used,
lv.cache.size + lv.cache.md_size + lv.size)
# check parameters reported by the (non-existing) cache
# 512 MiB - 8 MiB (metadata) - 8 MiB (pmspare)
self.assertEqual(cache.size, Size("496 MiB"))
self.assertEqual(cache.md_size, Size("8 MiB"))
self.assertEqual(cache.vg_space_used, Size("504 MiB"))
self.assertIsInstance(cache.size, Size)
self.assertIsInstance(cache.md_size, Size)
self.assertIsInstance(cache.vg_space_used, Size)
self.assertFalse(cache.exists)
self.assertIsNone(cache.stats)
self.assertEqual(cache.mode, "writethrough")
self.assertIsNone(cache.backing_device_name)
self.assertIsNone(cache.cache_device_name)
self.assertEqual(set(cache.fast_pvs), set([pv2]))
def test_lvm_logical_volume_pv_free_linear(self):
pv = StorageDevice("pv1",
fmt=blivet.formats.get_format("lvmpv"),
size=Size("1025 MiB"))
pv2 = StorageDevice("pv2",
fmt=blivet.formats.get_format("lvmpv"),
size=Size("513 MiB"))
vg = LVMVolumeGroupDevice("testvg", parents=[pv, pv2])
pv_spec = LVPVSpec(pv, Size("256 MiB"))
pv_spec2 = LVPVSpec(pv2, Size("256 MiB"))
lv = LVMLogicalVolumeDevice("testlv",
parents=[vg],
size=Size("512 MiB"),
fmt=blivet.formats.get_format("xfs"),
exists=False,
pvs=[pv_spec, pv_spec2])
self.assertEqual(lv.seg_type, "linear")
self.assertEqual(pv.format.free, Size("768 MiB"))
self.assertEqual(pv2.format.free, Size("256 MiB"))
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 test_get_devices(self):
"""Test GetDevices."""
assert 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")))
assert self.interface.GetDevices() == ["dev1", "dev2"]
def test_lvm_logical_volume_segtype_pv_free(self):
pv = StorageDevice("pv1",
fmt=blivet.formats.get_format("lvmpv"),
size=Size("1025 MiB"))
pv2 = StorageDevice("pv2",
fmt=blivet.formats.get_format("lvmpv"),
size=Size("513 MiB"))
vg = LVMVolumeGroupDevice("testvg", parents=[pv, pv2])
lv = LVMLogicalVolumeDevice("testlv",
parents=[vg],
size=Size("1 GiB"),
fmt=blivet.formats.get_format("xfs"),
exists=False,
seg_type="striped",
pvs=[pv, pv2])
self.assertEqual(lv.seg_type, "striped")
self.assertEqual(pv.format.free, Size("512 MiB"))
self.assertEqual(pv2.format.free, 0)
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_set_device_passphrase(self):
"""Test SetDevicePassphrase."""
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.FindUnconfiguredLUKS(), ["dev2"])
self.interface.SetDevicePassphrase("dev2", "123456")
self.assertEqual(self.interface.FindUnconfiguredLUKS(), [])
def get_devices_test(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 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 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 test_get_device_by_name(self):
dt = DeviceTree()
dev1 = StorageDevice("dev1", exists=False, parents=[])
dev2 = StorageDevice("dev2", exists=False, parents=[dev1])
dt._add_device(dev1)
dt._add_device(dev2)
self.assertIsNone(dt.get_device_by_name("dev3"))
self.assertEqual(dt.get_device_by_name("dev2"), dev2)
self.assertEqual(dt.get_device_by_name("dev1"), dev1)
dev2.complete = False
self.assertEqual(dt.get_device_by_name("dev2"), None)
self.assertEqual(dt.get_device_by_name("dev2", incomplete=True), dev2)
dev3 = StorageDevice("dev3", exists=True, parents=[])
dt._add_device(dev3)
dt.hide(dev3)
self.assertIsNone(dt.get_device_by_name("dev3"))
self.assertEqual(dt.get_device_by_name("dev3", hidden=True), dev3)
def test_find_mountable_partitions(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_find_install_media(self, check_module):
"""Test FindInstallMedia."""
dev1 = OpticalDevice("dev1")
dev1.size = Size("2 GiB")
dev1.format = get_format("iso9660")
dev1.controllable = True
self._add_device(dev1)
dev2 = StorageDevice("dev2")
dev2.size = Size("2 GiB")
dev2.format = get_format("iso9660")
dev2.controllable = True
self._add_device(dev2)
dev3 = StorageDevice("dev3")
dev3.size = Size("2 GiB")
dev3.format = get_format("ext4")
dev3.controllable = True
self._add_device(dev3)
self.assertEqual(self.interface.FindOpticalMedia(), ["dev1", "dev2"])
def get_file_systems_for_device_test(self):
"""Test GetFileSystemsForDevice."""
self._add_device(StorageDevice("dev1", fmt=get_format("ext4")))
result = self.interface.GetFileSystemsForDevice("dev1")
self.assertIsInstance(result, list)
self.assertNotEqual(len(result), 0)
self.assertIn("ext4", result)
for fs in result:
self.assertIsInstance(fs, str)
self.assertEqual(fs, get_format(fs).type)
