From 7551682755e6b554f38f9fd37c924f62b5caed8e Mon Sep 17 00:00:00 2001 From: CentOS Sources Date: Jul 14 2021 04:17:07 +0000 Subject: import python-blivet-3.4.0-2.el8 --- diff --git a/.gitignore b/.gitignore index 7dee816..22c65de 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,2 @@ -SOURCES/blivet-3.2.2-tests.tar.gz -SOURCES/blivet-3.2.2.tar.gz +SOURCES/blivet-3.4.0-tests.tar.gz +SOURCES/blivet-3.4.0.tar.gz diff --git a/.python-blivet.metadata b/.python-blivet.metadata index 5c5f71a..f6bdfc3 100644 --- a/.python-blivet.metadata +++ b/.python-blivet.metadata @@ -1,2 +1,2 @@ -84988ad63a9a9ddd9f2075b82b36bd98261df9e9 SOURCES/blivet-3.2.2-tests.tar.gz -a89000bc2e9cfc8a1cfe09a58bf5e4e609f9b517 SOURCES/blivet-3.2.2.tar.gz +d0a86df7bbaeda7be9990b7f7b15ec36b325ec7a SOURCES/blivet-3.4.0-tests.tar.gz +aafc429e224dfd204cb1c284bb70de52920f7b20 SOURCES/blivet-3.4.0.tar.gz diff --git a/SOURCES/0003-Revert-More-consistent-lvm-errors.patch b/SOURCES/0003-Revert-More-consistent-lvm-errors.patch new file mode 100644 index 0000000..69306a8 --- /dev/null +++ b/SOURCES/0003-Revert-More-consistent-lvm-errors.patch @@ -0,0 +1,330 @@ +From 3a42d9e2afdf04dbbfd2c507f5b2392193fda25b Mon Sep 17 00:00:00 2001 +From: Vojtech Trefny +Date: Wed, 26 May 2021 12:15:54 +0200 +Subject: [PATCH] Revert "More consistent lvm errors (API break)" + +This reverts commit 49ec071c6d0673224a0774d613904387c52c7381. +--- + blivet/devices/lvm.py | 72 +++++++++++++++++----------------- + tests/devices_test/lvm_test.py | 14 +++---- + 2 files changed, 43 insertions(+), 43 deletions(-) + +diff --git a/blivet/devices/lvm.py b/blivet/devices/lvm.py +index a55515fc..6d23bfba 100644 +--- a/blivet/devices/lvm.py ++++ b/blivet/devices/lvm.py +@@ -307,7 +307,7 @@ class LVMVolumeGroupDevice(ContainerDevice): + def _add_log_vol(self, lv): + """ Add an LV to this VG. """ + if lv in self._lvs: +- raise errors.DeviceError("lv is already part of this vg") ++ raise ValueError("lv is already part of this vg") + + # verify we have the space, then add it + # do not verify for growing vg (because of ks) +@@ -340,7 +340,7 @@ class LVMVolumeGroupDevice(ContainerDevice): + def _remove_log_vol(self, lv): + """ Remove an LV from this VG. """ + if lv not in self.lvs: +- raise errors.DeviceError("specified lv is not part of this vg") ++ raise ValueError("specified lv is not part of this vg") + + self._lvs.remove(lv) + +@@ -415,7 +415,7 @@ class LVMVolumeGroupDevice(ContainerDevice): + @thpool_reserve.setter + def thpool_reserve(self, value): + if value is not None and not isinstance(value, ThPoolReserveSpec): +- raise AttributeError("Invalid thpool_reserve given, must be of type ThPoolReserveSpec") ++ raise ValueError("Invalid thpool_reserve given, must be of type ThPoolReserveSpec") + self._thpool_reserve = value + + @property +@@ -646,14 +646,14 @@ class LVMLogicalVolumeBase(DMDevice, RaidDevice): + if seg_type not in [None, "linear", "thin", "thin-pool", "cache", "vdo-pool", "vdo"] + lvm.raid_seg_types: + raise ValueError("Invalid or unsupported segment type: %s" % seg_type) + if seg_type and seg_type in lvm.raid_seg_types and not pvs: +- raise errors.DeviceError("List of PVs has to be given for every non-linear LV") ++ raise ValueError("List of PVs has to be given for every non-linear LV") + elif (not seg_type or seg_type == "linear") and pvs: + if not all(isinstance(pv, LVPVSpec) for pv in pvs): +- raise errors.DeviceError("Invalid specification of PVs for a linear LV: either no or complete " +- "specification (with all space split into PVs has to be given") ++ raise ValueError("Invalid specification of PVs for a linear LV: either no or complete " ++ "specification (with all space split into PVs has to be given") + elif sum(spec.size for spec in pvs) != size: +- raise errors.DeviceError("Invalid specification of PVs for a linear LV: the sum of space " +- "assigned to PVs is not equal to the size of the LV") ++ raise ValueError("Invalid specification of PVs for a linear LV: the sum of space " ++ "assigned to PVs is not equal to the size of the LV") + + # When this device's format is set in the superclass constructor it will + # try to access self.snapshots. +@@ -702,13 +702,13 @@ class LVMLogicalVolumeBase(DMDevice, RaidDevice): + self._from_lvs = from_lvs + if self._from_lvs: + if exists: +- raise errors.DeviceError("Only new LVs can be created from other LVs") ++ raise ValueError("Only new LVs can be created from other LVs") + if size or maxsize or percent: +- raise errors.DeviceError("Cannot specify size for a converted LV") ++ raise ValueError("Cannot specify size for a converted LV") + if fmt: +- raise errors.DeviceError("Cannot specify format for a converted LV") ++ raise ValueError("Cannot specify format for a converted LV") + if any(lv.vg != self.vg for lv in self._from_lvs): +- raise errors.DeviceError("Conversion of LVs only possible inside a VG") ++ raise ValueError("Conversion of LVs only possible inside a VG") + + self._cache = None + if cache_request and not self.exists: +@@ -723,13 +723,13 @@ class LVMLogicalVolumeBase(DMDevice, RaidDevice): + elif isinstance(pv_spec, StorageDevice): + self._pv_specs.append(LVPVSpec(pv_spec, Size(0))) + else: +- raise AttributeError("Invalid PV spec '%s' for the '%s' LV" % (pv_spec, self.name)) ++ raise ValueError("Invalid PV spec '%s' for the '%s' LV" % (pv_spec, self.name)) + # Make sure any destination PVs are actually PVs in this VG + if not set(spec.pv for spec in self._pv_specs).issubset(set(self.vg.parents)): + missing = [r.name for r in + set(spec.pv for spec in self._pv_specs).difference(set(self.vg.parents))] + msg = "invalid destination PV(s) %s for LV %s" % (missing, self.name) +- raise errors.DeviceError(msg) ++ raise ValueError(msg) + if self._pv_specs: + self._assign_pv_space() + +@@ -1072,7 +1072,7 @@ class LVMLogicalVolumeBase(DMDevice, RaidDevice): + else: + msg = "the specified internal LV '%s' doesn't belong to this LV ('%s')" % (int_lv.lv_name, + self.name) +- raise errors.DeviceError(msg) ++ raise ValueError(msg) + + def populate_ksdata(self, data): + super(LVMLogicalVolumeBase, self).populate_ksdata(data) +@@ -1171,7 +1171,7 @@ class LVMInternalLogicalVolumeMixin(object): + def _init_check(self): + # an internal LV should have no parents + if self._parent_lv and self._parents: +- raise errors.DeviceError("an internal LV should have no parents") ++ raise ValueError("an internal LV should have no parents") + + @property + def is_internal_lv(self): +@@ -1231,7 +1231,7 @@ class LVMInternalLogicalVolumeMixin(object): + + @readonly.setter + def readonly(self, value): # pylint: disable=unused-argument +- raise errors.DeviceError("Cannot make an internal LV read-write") ++ raise ValueError("Cannot make an internal LV read-write") + + @property + def type(self): +@@ -1267,7 +1267,7 @@ class LVMInternalLogicalVolumeMixin(object): + def _check_parents(self): + # an internal LV should have no parents + if self._parents: +- raise errors.DeviceError("an internal LV should have no parents") ++ raise ValueError("an internal LV should have no parents") + + def _add_to_parents(self): + # nothing to do here, an internal LV has no parents (in the DeviceTree's +@@ -1277,13 +1277,13 @@ class LVMInternalLogicalVolumeMixin(object): + # internal LVs follow different rules limitting size + def _set_size(self, newsize): + if not isinstance(newsize, Size): +- raise AttributeError("new size must of type Size") ++ raise ValueError("new size must of type Size") + + if not self.takes_extra_space: + if newsize <= self.parent_lv.size: # pylint: disable=no-member + self._size = newsize # pylint: disable=attribute-defined-outside-init + else: +- raise errors.DeviceError("Internal LV cannot be bigger than its parent LV") ++ raise ValueError("Internal LV cannot be bigger than its parent LV") + else: + # same rules apply as for any other LV + raise NotTypeSpecific() +@@ -1361,18 +1361,18 @@ class LVMSnapshotMixin(object): + return + + if self.origin and not isinstance(self.origin, LVMLogicalVolumeDevice): +- raise errors.DeviceError("lvm snapshot origin must be a logical volume") ++ raise ValueError("lvm snapshot origin must be a logical volume") + if self.vorigin and not self.exists: +- raise errors.DeviceError("only existing vorigin snapshots are supported") ++ raise ValueError("only existing vorigin snapshots are supported") + + if isinstance(self.origin, LVMLogicalVolumeDevice) and \ + isinstance(self.parents[0], LVMVolumeGroupDevice) and \ + self.origin.vg != self.parents[0]: +- raise errors.DeviceError("lvm snapshot and origin must be in the same vg") ++ raise ValueError("lvm snapshot and origin must be in the same vg") + + if self.is_thin_lv: + if self.origin and self.size and not self.exists: +- raise errors.DeviceError("thin snapshot size is determined automatically") ++ raise ValueError("thin snapshot size is determined automatically") + + @property + def is_snapshot_lv(self): +@@ -1544,7 +1544,7 @@ class LVMThinPoolMixin(object): + def _check_from_lvs(self): + if self._from_lvs: + if len(self._from_lvs) != 2: +- raise errors.DeviceError("two LVs required to create a thin pool") ++ raise ValueError("two LVs required to create a thin pool") + + def _convert_from_lvs(self): + data_lv, metadata_lv = self._from_lvs +@@ -1590,7 +1590,7 @@ class LVMThinPoolMixin(object): + def _add_log_vol(self, lv): + """ Add an LV to this pool. """ + if lv in self._lvs: +- raise errors.DeviceError("lv is already part of this vg") ++ raise ValueError("lv is already part of this vg") + + # TODO: add some checking to prevent overcommit for preexisting + self.vg._add_log_vol(lv) +@@ -1601,7 +1601,7 @@ class LVMThinPoolMixin(object): + def _remove_log_vol(self, lv): + """ Remove an LV from this pool. """ + if lv not in self._lvs: +- raise errors.DeviceError("specified lv is not part of this vg") ++ raise ValueError("specified lv is not part of this vg") + + self._lvs.remove(lv) + self.vg._remove_log_vol(lv) +@@ -1711,14 +1711,14 @@ class LVMThinLogicalVolumeMixin(object): + """Check that this device has parents as expected""" + if isinstance(self.parents, (list, ParentList)): + if len(self.parents) != 1: +- raise errors.DeviceError("constructor requires a single thin-pool LV") ++ raise ValueError("constructor requires a single thin-pool LV") + + container = self.parents[0] + else: + container = self.parents + + if not container or not isinstance(container, LVMLogicalVolumeDevice) or not container.is_thin_pool: +- raise errors.DeviceError("constructor requires a thin-pool LV") ++ raise ValueError("constructor requires a thin-pool LV") + + @property + def is_thin_lv(self): +@@ -1755,7 +1755,7 @@ class LVMThinLogicalVolumeMixin(object): + + def _set_size(self, newsize): + if not isinstance(newsize, Size): +- raise AttributeError("new size must of type Size") ++ raise ValueError("new size must of type Size") + + newsize = self.vg.align(newsize) + newsize = self.vg.align(util.numeric_type(newsize)) +@@ -2229,7 +2229,7 @@ class LVMLogicalVolumeDevice(LVMLogicalVolumeBase, LVMInternalLogicalVolumeMixin + container = self.parents + + if not isinstance(container, LVMVolumeGroupDevice): +- raise AttributeError("constructor requires a LVMVolumeGroupDevice") ++ raise ValueError("constructor requires a LVMVolumeGroupDevice") + + @type_specific + def _add_to_parents(self): +@@ -2240,12 +2240,12 @@ class LVMLogicalVolumeDevice(LVMLogicalVolumeBase, LVMInternalLogicalVolumeMixin + @type_specific + def _check_from_lvs(self): + """Check the LVs to create this LV from""" +- raise errors.DeviceError("Cannot create a new LV of type '%s' from other LVs" % self.seg_type) ++ raise ValueError("Cannot create a new LV of type '%s' from other LVs" % self.seg_type) + + @type_specific + def _convert_from_lvs(self): + """Convert the LVs to create this LV from into its internal LVs""" +- raise errors.DeviceError("Cannot create a new LV of type '%s' from other LVs" % self.seg_type) ++ raise ValueError("Cannot create a new LV of type '%s' from other LVs" % self.seg_type) + + @property + def external_dependencies(self): +@@ -2265,7 +2265,7 @@ class LVMLogicalVolumeDevice(LVMLogicalVolumeBase, LVMInternalLogicalVolumeMixin + @type_specific + def _set_size(self, newsize): + if not isinstance(newsize, Size): +- raise AttributeError("new size must be of type Size") ++ raise ValueError("new size must be of type Size") + + newsize = self.vg.align(newsize) + log.debug("trying to set lv %s size to %s", self.name, newsize) +@@ -2274,7 +2274,7 @@ class LVMLogicalVolumeDevice(LVMLogicalVolumeBase, LVMInternalLogicalVolumeMixin + # space for it. A similar reasoning applies to shrinking the LV. + if not self.exists and newsize > self.size and newsize > self.vg.free_space + self.vg_space_used: + log.error("failed to set size: %s short", newsize - (self.vg.free_space + self.vg_space_used)) +- raise errors.DeviceError("not enough free space in volume group") ++ raise ValueError("not enough free space in volume group") + + LVMLogicalVolumeBase._set_size(self, newsize) + +@@ -2622,7 +2622,7 @@ class LVMCache(Cache): + spec.size = spec.pv.format.free + space_to_assign -= spec.pv.format.free + if space_to_assign > 0: +- raise errors.DeviceError("Not enough free space in the PVs for this cache: %s short" % space_to_assign) ++ raise ValueError("Not enough free space in the PVs for this cache: %s short" % space_to_assign) + + @property + def size(self): +diff --git a/tests/devices_test/lvm_test.py b/tests/devices_test/lvm_test.py +index 670c91c9..4156d0bf 100644 +--- a/tests/devices_test/lvm_test.py ++++ b/tests/devices_test/lvm_test.py +@@ -36,10 +36,10 @@ class LVMDeviceTest(unittest.TestCase): + lv = LVMLogicalVolumeDevice("testlv", parents=[vg], + fmt=blivet.formats.get_format("xfs")) + +- with six.assertRaisesRegex(self, errors.DeviceError, "lvm snapshot origin must be a logical volume"): ++ with six.assertRaisesRegex(self, ValueError, "lvm snapshot origin must be a logical volume"): + LVMLogicalVolumeDevice("snap1", parents=[vg], origin=pv) + +- with six.assertRaisesRegex(self, errors.DeviceError, "only existing vorigin snapshots are supported"): ++ with six.assertRaisesRegex(self, ValueError, "only existing vorigin snapshots are supported"): + LVMLogicalVolumeDevice("snap1", parents=[vg], vorigin=True) + + lv.exists = True +@@ -64,7 +64,7 @@ class LVMDeviceTest(unittest.TestCase): + pool = LVMLogicalVolumeDevice("pool1", parents=[vg], size=Size("500 MiB"), seg_type="thin-pool") + thinlv = LVMLogicalVolumeDevice("thinlv", parents=[pool], size=Size("200 MiB"), seg_type="thin") + +- with six.assertRaisesRegex(self, errors.DeviceError, "lvm snapshot origin must be a logical volume"): ++ with six.assertRaisesRegex(self, ValueError, "lvm snapshot origin must be a logical volume"): + LVMLogicalVolumeDevice("snap1", parents=[pool], origin=pv, seg_type="thin") + + # now make the constructor succeed so we can test some properties +@@ -258,21 +258,21 @@ class LVMDeviceTest(unittest.TestCase): + vg = LVMVolumeGroupDevice("testvg", parents=[pv, pv2]) + + # pvs have to be specified for non-linear LVs +- with self.assertRaises(errors.DeviceError): ++ 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(errors.DeviceError): ++ 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(errors.DeviceError): ++ 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(errors.DeviceError): ++ 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"), +-- +2.31.1 + diff --git a/SOURCES/0003-Skip-test_mounting-for-filesystems-that-are-not-moun.patch b/SOURCES/0003-Skip-test_mounting-for-filesystems-that-are-not-moun.patch deleted file mode 100644 index 0f7efc0..0000000 --- a/SOURCES/0003-Skip-test_mounting-for-filesystems-that-are-not-moun.patch +++ /dev/null @@ -1,29 +0,0 @@ -From 760f08bbf7b801acd393a6d2b7447ca6ff28d590 Mon Sep 17 00:00:00 2001 -From: Vojtech Trefny -Date: Fri, 22 May 2020 12:35:11 +0200 -Subject: [PATCH] Skip test_mounting for filesystems that are not mountable - -We can have tools to create the filesystem without having kernel -module for mounting it. ---- - tests/formats_test/fstesting.py | 4 ++-- - 1 file changed, 2 insertions(+), 2 deletions(-) - -diff --git a/tests/formats_test/fstesting.py b/tests/formats_test/fstesting.py -index aa1b42e5..62f806f9 100644 ---- a/tests/formats_test/fstesting.py -+++ b/tests/formats_test/fstesting.py -@@ -156,8 +156,8 @@ class FSAsRoot(loopbackedtestcase.LoopBackedTestCase): - # FIXME: BTRFS fails to mount - if isinstance(an_fs, fs.BTRFS): - self.skipTest("no mounting filesystem %s" % an_fs.name) -- if not an_fs.formattable: -- self.skipTest("can not create filesystem %s" % an_fs.name) -+ if not an_fs.formattable or not an_fs.mountable: -+ self.skipTest("can not create or mount filesystem %s" % an_fs.name) - an_fs.device = self.loop_devices[0] - self.assertIsNone(an_fs.create()) - self.assertTrue(an_fs.test_mount()) --- -2.25.4 - diff --git a/SOURCES/0004-Add-extra-sleep-after-pvremove-call.patch b/SOURCES/0004-Add-extra-sleep-after-pvremove-call.patch deleted file mode 100644 index 96969d0..0000000 --- a/SOURCES/0004-Add-extra-sleep-after-pvremove-call.patch +++ /dev/null @@ -1,38 +0,0 @@ -From 6a62a81d326a1121a2768735e52a8e1c5e5d6f0d Mon Sep 17 00:00:00 2001 -From: Vojtech Trefny -Date: Wed, 24 Jun 2020 14:43:47 +0200 -Subject: [PATCH] Add extra sleep after pvremove call - -To give enough time for the async pvscan to finish scanning the -partition before removing it. - -Resolves: rhbz#1640601 ---- - blivet/formats/lvmpv.py | 4 ++++ - 1 file changed, 4 insertions(+) - -diff --git a/blivet/formats/lvmpv.py b/blivet/formats/lvmpv.py -index e4182adb..9f53ec6b 100644 ---- a/blivet/formats/lvmpv.py -+++ b/blivet/formats/lvmpv.py -@@ -26,6 +26,7 @@ gi.require_version("BlockDev", "2.0") - from gi.repository import BlockDev as blockdev - - import os -+import time - - from ..storage_log import log_method_call - from parted import PARTITION_LVM -@@ -137,6 +138,9 @@ class LVMPhysicalVolume(DeviceFormat): - DeviceFormat._destroy(self, **kwargs) - finally: - udev.settle() -+ # LVM now has async pvscan jobs so udev.settle doesn't help and if we try to remove -+ # the partition immediately after the pvremove we get an error -+ time.sleep(5) - - @property - def destroyable(self): --- -2.25.4 - diff --git a/SOURCES/0004-Revert-Terminology-cleanups.patch b/SOURCES/0004-Revert-Terminology-cleanups.patch new file mode 100644 index 0000000..0db4494 --- /dev/null +++ b/SOURCES/0004-Revert-Terminology-cleanups.patch @@ -0,0 +1,908 @@ +From 42042e7fb6177d3cfe5568e358a38278925a2624 Mon Sep 17 00:00:00 2001 +From: Vojtech Trefny +Date: Wed, 26 May 2021 12:27:34 +0200 +Subject: [PATCH] Revert "Terminology cleanups" + +This reverts following commits: +- 3d46339fe9cf12e9082fcbe4dc5acc9f92617e8d +- 63c9c7165e5cdfa4a47dcf0ed9d717b71e7921f2 +- 8956b9af8a785ae25e0e7153d2ef0702ce2f567c +--- + blivet/devicefactory.py | 24 +++++----- + blivet/devices/dm.py | 9 +++- + blivet/devices/loop.py | 20 ++++---- + blivet/devices/luks.py | 26 +++++----- + blivet/errors.py | 2 +- + blivet/partitioning.py | 22 +++++++-- + blivet/populator/helpers/dm.py | 4 +- + blivet/populator/helpers/luks.py | 4 +- + blivet/populator/helpers/lvm.py | 2 +- + blivet/populator/helpers/mdraid.py | 14 +++--- + blivet/populator/helpers/multipath.py | 8 ++-- + blivet/populator/populator.py | 69 ++++++++++++++------------- + blivet/threads.py | 3 +- + blivet/udev.py | 34 ++++++------- + tests/devicefactory_test.py | 10 ++-- + tests/devices_test/size_test.py | 6 +-- + tests/populator_test.py | 34 ++++++------- + tests/udev_test.py | 12 ++--- + tests/vmtests/vmbackedtestcase.py | 2 +- + 19 files changed, 168 insertions(+), 137 deletions(-) + +diff --git a/blivet/devicefactory.py b/blivet/devicefactory.py +index 0f7fdfa1..f56bd9a3 100644 +--- a/blivet/devicefactory.py ++++ b/blivet/devicefactory.py +@@ -849,12 +849,12 @@ class DeviceFactory(object): + parent_container.parents.remove(orig_device) + + if self.encrypted and isinstance(self.device, LUKSDevice) and \ +- self.raw_device.format.luks_version != self.luks_version: +- self.raw_device.format.luks_version = self.luks_version ++ self.device.slave.format.luks_version != self.luks_version: ++ self.device.slave.format.luks_version = self.luks_version + + if self.encrypted and isinstance(self.device, LUKSDevice) and \ +- self.raw_device.format.luks_sector_size != self.luks_sector_size: +- self.raw_device.format.luks_sector_size = self.luks_sector_size ++ self.device.slave.format.luks_sector_size != self.luks_sector_size: ++ self.device.slave.format.luks_sector_size = self.luks_sector_size + + def _set_name(self): + if not self.device_name: +@@ -1173,11 +1173,11 @@ class PartitionSetFactory(PartitionFactory): + container.parents.remove(member) + self.storage.destroy_device(member) + members.remove(member) +- self.storage.format_device(member.raw_device, ++ self.storage.format_device(member.slave, + get_format(self.fstype)) +- members.append(member.raw_device) ++ members.append(member.slave) + if container: +- container.parents.append(member.raw_device) ++ container.parents.append(member.slave) + + continue + +@@ -1199,10 +1199,10 @@ class PartitionSetFactory(PartitionFactory): + + continue + +- if member_encrypted and self.encrypted and self.luks_version != member.raw_device.format.luks_version: +- member.raw_device.format.luks_version = self.luks_version +- if member_encrypted and self.encrypted and self.luks_sector_size != member.raw_device.format.luks_sector_size: +- member.raw_device.format.luks_sector_size = self.luks_sector_size ++ if member_encrypted and self.encrypted and self.luks_version != member.slave.format.luks_version: ++ member.slave.format.luks_version = self.luks_version ++ if member_encrypted and self.encrypted and self.luks_sector_size != member.slave.format.luks_sector_size: ++ member.slave.format.luks_sector_size = self.luks_sector_size + + ## + # Prepare previously allocated member partitions for reallocation. +@@ -1262,7 +1262,7 @@ class PartitionSetFactory(PartitionFactory): + + if isinstance(member, LUKSDevice): + self.storage.destroy_device(member) +- member = member.raw_device ++ member = member.slave + + self.storage.destroy_device(member) + +diff --git a/blivet/devices/dm.py b/blivet/devices/dm.py +index 3529f61c..508a6f89 100644 +--- a/blivet/devices/dm.py ++++ b/blivet/devices/dm.py +@@ -154,6 +154,11 @@ class DMDevice(StorageDevice): + log_method_call(self, self.name, status=self.status) + super(DMDevice, self)._set_name(value) + ++ @property ++ def slave(self): ++ """ This device's backing device. """ ++ return self.parents[0] ++ + + class DMLinearDevice(DMDevice): + _type = "dm-linear" +@@ -189,8 +194,8 @@ class DMLinearDevice(DMDevice): + """ Open, or set up, a device. """ + log_method_call(self, self.name, orig=orig, status=self.status, + controllable=self.controllable) +- parent_length = self.parents[0].current_size / LINUX_SECTOR_SIZE +- blockdev.dm.create_linear(self.name, self.parents[0].path, parent_length, ++ slave_length = self.slave.current_size / LINUX_SECTOR_SIZE ++ blockdev.dm.create_linear(self.name, self.slave.path, slave_length, + self.dm_uuid) + + def _post_setup(self): +diff --git a/blivet/devices/loop.py b/blivet/devices/loop.py +index 0f4d7775..78f88d7d 100644 +--- a/blivet/devices/loop.py ++++ b/blivet/devices/loop.py +@@ -73,7 +73,7 @@ class LoopDevice(StorageDevice): + + def update_name(self): + """ Update this device's name. """ +- if not self.parents[0].status: ++ if not self.slave.status: + # if the backing device is inactive, so are we + return self.name + +@@ -81,7 +81,7 @@ class LoopDevice(StorageDevice): + # if our name is loopN we must already be active + return self.name + +- name = blockdev.loop.get_loop_name(self.parents[0].path) ++ name = blockdev.loop.get_loop_name(self.slave.path) + if name.startswith("loop"): + self.name = name + +@@ -89,24 +89,24 @@ class LoopDevice(StorageDevice): + + @property + def status(self): +- return (self.parents[0].status and ++ return (self.slave.status and + self.name.startswith("loop") and +- blockdev.loop.get_loop_name(self.parents[0].path) == self.name) ++ blockdev.loop.get_loop_name(self.slave.path) == self.name) + + @property + def size(self): +- return self.parents[0].size ++ return self.slave.size + + def _pre_setup(self, orig=False): +- if not os.path.exists(self.parents[0].path): +- raise errors.DeviceError("specified file (%s) does not exist" % self.parents[0].path) ++ if not os.path.exists(self.slave.path): ++ raise errors.DeviceError("specified file (%s) does not exist" % self.slave.path) + return StorageDevice._pre_setup(self, orig=orig) + + def _setup(self, orig=False): + """ Open, or set up, a device. """ + log_method_call(self, self.name, orig=orig, status=self.status, + controllable=self.controllable) +- blockdev.loop.setup(self.parents[0].path) ++ blockdev.loop.setup(self.slave.path) + + def _post_setup(self): + StorageDevice._post_setup(self) +@@ -123,3 +123,7 @@ class LoopDevice(StorageDevice): + StorageDevice._post_teardown(self, recursive=recursive) + self.name = "tmploop%d" % self.id + self.sysfs_path = '' ++ ++ @property ++ def slave(self): ++ return self.parents[0] +diff --git a/blivet/devices/luks.py b/blivet/devices/luks.py +index 5d6d6c65..555f1acd 100644 +--- a/blivet/devices/luks.py ++++ b/blivet/devices/luks.py +@@ -66,13 +66,17 @@ class LUKSDevice(DMCryptDevice): + + @property + def raw_device(self): ++ return self.slave ++ ++ @property ++ def slave(self): + if self._has_integrity: + return self.parents[0].parents[0] + return self.parents[0] + + def _get_size(self): + if not self.exists: +- size = self.raw_device.size - crypto.LUKS_METADATA_SIZE ++ size = self.slave.size - crypto.LUKS_METADATA_SIZE + elif self.resizable and self.target_size != Size(0): + size = self.target_size + else: +@@ -80,8 +84,8 @@ class LUKSDevice(DMCryptDevice): + return size + + def _set_size(self, newsize): +- if not self.exists and not self.raw_device.exists: +- self.raw_device.size = newsize + crypto.LUKS_METADATA_SIZE ++ if not self.exists and not self.slave.exists: ++ self.slave.size = newsize + crypto.LUKS_METADATA_SIZE + + # just run the StorageDevice._set_size to make sure we are in the format limits + super(LUKSDevice, self)._set_size(newsize - crypto.LUKS_METADATA_SIZE) +@@ -108,22 +112,22 @@ class LUKSDevice(DMCryptDevice): + raise ValueError("size is smaller than the minimum for this device") + + # don't allow larger luks than size (or target size) of backing device +- if newsize > (self.raw_device.size - crypto.LUKS_METADATA_SIZE): ++ if newsize > (self.slave.size - crypto.LUKS_METADATA_SIZE): + log.error("requested size %s is larger than size of the backing device %s", +- newsize, self.raw_device.size) ++ newsize, self.slave.size) + raise ValueError("size is larger than the size of the backing device") + + if self.align_target_size(newsize) != newsize: + raise ValueError("new size would violate alignment requirements") + + def _get_target_size(self): +- return self.raw_device.format.target_size ++ return self.slave.format.target_size + + @property + def max_size(self): + """ The maximum size this luks device can be. Maximum is based on the + maximum size of the backing device. """ +- max_luks = self.raw_device.max_size - crypto.LUKS_METADATA_SIZE ++ max_luks = self.slave.max_size - crypto.LUKS_METADATA_SIZE + max_format = self.format.max_size + return min(max_luks, max_format) if max_format else max_luks + +@@ -131,7 +135,7 @@ class LUKSDevice(DMCryptDevice): + def resizable(self): + """ Can this device be resized? """ + return (self._resizable and self.exists and self.format.resizable and +- self.raw_device.resizable and not self._has_integrity) ++ self.slave.resizable and not self._has_integrity) + + def resize(self): + # size of LUKSDevice depends on size of the LUKS format on backing +@@ -139,7 +143,7 @@ class LUKSDevice(DMCryptDevice): + log_method_call(self, self.name, status=self.status) + + def _post_create(self): +- self.name = self.raw_device.format.map_name ++ self.name = self.slave.format.map_name + StorageDevice._post_create(self) + + def _post_teardown(self, recursive=False): +@@ -162,10 +166,10 @@ class LUKSDevice(DMCryptDevice): + self.name = new_name + + def dracut_setup_args(self): +- return set(["rd.luks.uuid=luks-%s" % self.raw_device.format.uuid]) ++ return set(["rd.luks.uuid=luks-%s" % self.slave.format.uuid]) + + def populate_ksdata(self, data): +- self.raw_device.populate_ksdata(data) ++ self.slave.populate_ksdata(data) + data.encrypted = True + super(LUKSDevice, self).populate_ksdata(data) + +diff --git a/blivet/errors.py b/blivet/errors.py +index fd51283f..f6bf853a 100644 +--- a/blivet/errors.py ++++ b/blivet/errors.py +@@ -192,7 +192,7 @@ class DeviceTreeError(StorageError): + pass + + +-class NoParentsError(DeviceTreeError): ++class NoSlavesError(DeviceTreeError): + pass + + +diff --git a/blivet/partitioning.py b/blivet/partitioning.py +index 53f9cc3f..ca0a55d1 100644 +--- a/blivet/partitioning.py ++++ b/blivet/partitioning.py +@@ -32,7 +32,7 @@ import _ped + + from .errors import DeviceError, PartitioningError, AlignmentError + from .flags import flags +-from .devices import Device, PartitionDevice, device_path_to_name ++from .devices import Device, PartitionDevice, LUKSDevice, device_path_to_name + from .size import Size + from .i18n import _ + from .util import stringize, unicodeize, compare +@@ -1632,7 +1632,15 @@ class TotalSizeSet(object): + :param size: the target combined size + :type size: :class:`~.size.Size` + """ +- self.devices = [d.raw_device for d in devices] ++ self.devices = [] ++ for device in devices: ++ if isinstance(device, LUKSDevice): ++ partition = device.slave ++ else: ++ partition = device ++ ++ self.devices.append(partition) ++ + self.size = size + + self.requests = [] +@@ -1670,7 +1678,15 @@ class SameSizeSet(object): + :keyword max_size: the maximum size for growable devices + :type max_size: :class:`~.size.Size` + """ +- self.devices = [d.raw_device for d in devices] ++ self.devices = [] ++ for device in devices: ++ if isinstance(device, LUKSDevice): ++ partition = device.slave ++ else: ++ partition = device ++ ++ self.devices.append(partition) ++ + self.size = size / len(devices) + self.grow = grow + self.max_size = max_size +diff --git a/blivet/populator/helpers/dm.py b/blivet/populator/helpers/dm.py +index 30e99aa1..770736b0 100644 +--- a/blivet/populator/helpers/dm.py ++++ b/blivet/populator/helpers/dm.py +@@ -46,13 +46,13 @@ class DMDevicePopulator(DevicePopulator): + name = udev.device_get_name(self.data) + log_method_call(self, name=name) + sysfs_path = udev.device_get_sysfs_path(self.data) +- parent_devices = self._devicetree._add_parent_devices(self.data) ++ slave_devices = self._devicetree._add_slave_devices(self.data) + device = self._devicetree.get_device_by_name(name) + + if device is None: + device = DMDevice(name, dm_uuid=self.data.get('DM_UUID'), + sysfs_path=sysfs_path, exists=True, +- parents=[parent_devices[0]]) ++ parents=[slave_devices[0]]) + device.protected = True + device.controllable = False + self._devicetree._add_device(device) +diff --git a/blivet/populator/helpers/luks.py b/blivet/populator/helpers/luks.py +index 52795a98..51488691 100644 +--- a/blivet/populator/helpers/luks.py ++++ b/blivet/populator/helpers/luks.py +@@ -43,7 +43,7 @@ class LUKSDevicePopulator(DevicePopulator): + return udev.device_is_dm_luks(data) + + def run(self): +- parents = self._devicetree._add_parent_devices(self.data) ++ parents = self._devicetree._add_slave_devices(self.data) + device = LUKSDevice(udev.device_get_name(self.data), + sysfs_path=udev.device_get_sysfs_path(self.data), + parents=parents, +@@ -58,7 +58,7 @@ class IntegrityDevicePopulator(DevicePopulator): + return udev.device_is_dm_integrity(data) + + def run(self): +- parents = self._devicetree._add_parent_devices(self.data) ++ parents = self._devicetree._add_slave_devices(self.data) + device = IntegrityDevice(udev.device_get_name(self.data), + sysfs_path=udev.device_get_sysfs_path(self.data), + parents=parents, +diff --git a/blivet/populator/helpers/lvm.py b/blivet/populator/helpers/lvm.py +index c7adfa4e..b1626306 100644 +--- a/blivet/populator/helpers/lvm.py ++++ b/blivet/populator/helpers/lvm.py +@@ -57,7 +57,7 @@ class LVMDevicePopulator(DevicePopulator): + log.warning("found non-vg device with name %s", vg_name) + device = None + +- self._devicetree._add_parent_devices(self.data) ++ self._devicetree._add_slave_devices(self.data) + + # LVM provides no means to resolve conflicts caused by duplicated VG + # names, so we're just being optimistic here. Woo! +diff --git a/blivet/populator/helpers/mdraid.py b/blivet/populator/helpers/mdraid.py +index 3479e3f7..76aebf25 100644 +--- a/blivet/populator/helpers/mdraid.py ++++ b/blivet/populator/helpers/mdraid.py +@@ -31,7 +31,7 @@ from ... import udev + from ...devicelibs import raid + from ...devices import MDRaidArrayDevice, MDContainerDevice + from ...devices import device_path_to_name +-from ...errors import DeviceError, NoParentsError ++from ...errors import DeviceError, NoSlavesError + from ...flags import flags + from ...storage_log import log_method_call + from .devicepopulator import DevicePopulator +@@ -52,12 +52,12 @@ class MDDevicePopulator(DevicePopulator): + log_method_call(self, name=name) + + try: +- self._devicetree._add_parent_devices(self.data) +- except NoParentsError: +- log.error("no parents found for mdarray %s, skipping", name) ++ self._devicetree._add_slave_devices(self.data) ++ except NoSlavesError: ++ log.error("no slaves found for mdarray %s, skipping", name) + return None + +- # try to get the device again now that we've got all the parents ++ # try to get the device again now that we've got all the slaves + device = self._devicetree.get_device_by_name(name, incomplete=flags.allow_imperfect_devices) + + if device is None: +@@ -74,8 +74,8 @@ class MDDevicePopulator(DevicePopulator): + device.name = name + + if device is None: +- # if we get here, we found all of the parent devices and +- # something must be wrong -- if all of the parents are in ++ # if we get here, we found all of the slave devices and ++ # something must be wrong -- if all of the slaves are in + # the tree, this device should be as well + if name is None: + name = udev.device_get_name(self.data) +diff --git a/blivet/populator/helpers/multipath.py b/blivet/populator/helpers/multipath.py +index 96c0a9ad..10c745bf 100644 +--- a/blivet/populator/helpers/multipath.py ++++ b/blivet/populator/helpers/multipath.py +@@ -40,13 +40,13 @@ class MultipathDevicePopulator(DevicePopulator): + name = udev.device_get_name(self.data) + log_method_call(self, name=name) + +- parent_devices = self._devicetree._add_parent_devices(self.data) ++ slave_devices = self._devicetree._add_slave_devices(self.data) + + device = None +- if parent_devices: +- device = MultipathDevice(name, parents=parent_devices, ++ if slave_devices: ++ device = MultipathDevice(name, parents=slave_devices, + sysfs_path=udev.device_get_sysfs_path(self.data), +- wwn=parent_devices[0].wwn) ++ wwn=slave_devices[0].wwn) + self._devicetree._add_device(device) + + return device +diff --git a/blivet/populator/populator.py b/blivet/populator/populator.py +index 75bb1741..d252281d 100644 +--- a/blivet/populator/populator.py ++++ b/blivet/populator/populator.py +@@ -31,7 +31,7 @@ gi.require_version("BlockDev", "2.0") + + from gi.repository import BlockDev as blockdev + +-from ..errors import DeviceError, DeviceTreeError, NoParentsError ++from ..errors import DeviceError, DeviceTreeError, NoSlavesError + from ..devices import DMLinearDevice, DMRaidArrayDevice + from ..devices import FileDevice, LoopDevice + from ..devices import MDRaidArrayDevice +@@ -92,55 +92,56 @@ class PopulatorMixin(object): + + self._cleanup = False + +- def _add_parent_devices(self, info): +- """ Add all parents of a device, raising DeviceTreeError on failure. ++ def _add_slave_devices(self, info): ++ """ Add all slaves of a device, raising DeviceTreeError on failure. + + :param :class:`pyudev.Device` info: the device's udev info +- :raises: :class:`~.errors.DeviceTreeError if no parents are found or +- if we fail to add any parent +- :returns: a list of parent devices ++ :raises: :class:`~.errors.DeviceTreeError if no slaves are found or ++ if we fail to add any slave ++ :returns: a list of slave devices + :rtype: list of :class:`~.StorageDevice` + """ + name = udev.device_get_name(info) + sysfs_path = udev.device_get_sysfs_path(info) +- parent_dir = os.path.normpath("%s/slaves" % sysfs_path) +- parent_names = os.listdir(parent_dir) +- parent_devices = [] +- if not parent_names: +- log.error("no parents found for %s", name) +- raise NoParentsError("no parents found for device %s" % name) +- +- for parent_name in parent_names: +- path = os.path.normpath("%s/%s" % (parent_dir, parent_name)) +- parent_info = udev.get_device(os.path.realpath(path)) +- +- if not parent_info: +- msg = "unable to get udev info for %s" % parent_name ++ slave_dir = os.path.normpath("%s/slaves" % sysfs_path) ++ slave_names = os.listdir(slave_dir) ++ slave_devices = [] ++ if not slave_names: ++ log.error("no slaves found for %s", name) ++ raise NoSlavesError("no slaves found for device %s" % name) ++ ++ for slave_name in slave_names: ++ path = os.path.normpath("%s/%s" % (slave_dir, slave_name)) ++ slave_info = udev.get_device(os.path.realpath(path)) ++ ++ if not slave_info: ++ msg = "unable to get udev info for %s" % slave_name + raise DeviceTreeError(msg) + + # cciss in sysfs is "cciss!cXdYpZ" but we need "cciss/cXdYpZ" +- parent_name = udev.device_get_name(parent_info).replace("!", "/") +- +- parent_dev = self.get_device_by_name(parent_name) +- if not parent_dev and parent_info: +- # we haven't scanned the parent yet, so do it now +- self.handle_device(parent_info) +- parent_dev = self.get_device_by_name(parent_name) +- if parent_dev is None: ++ slave_name = udev.device_get_name(slave_info).replace("!", "/") ++ ++ slave_dev = self.get_device_by_name(slave_name) ++ if not slave_dev and slave_info: ++ # we haven't scanned the slave yet, so do it now ++ self.handle_device(slave_info) ++ slave_dev = self.get_device_by_name(slave_name) ++ if slave_dev is None: + if udev.device_is_dm_lvm(info): +- if parent_name not in lvs_info.cache: ++ if slave_name not in lvs_info.cache: + # we do not expect hidden lvs to be in the tree + continue + +- # if the current parent is still not in ++ # if the current slave is still not in + # the tree, something has gone wrong +- log.error("failure scanning device %s: could not add parent %s", name, parent_name) +- msg = "failed to add parent %s of device %s" % (parent_name, name) ++ log.error("failure scanning device %s: could not add slave %s", name, slave_name) ++ msg = "failed to add slave %s of device %s" % (slave_name, ++ name) + raise DeviceTreeError(msg) + +- parent_devices.append(parent_dev) ++ slave_devices.append(slave_dev) + +- return parent_devices ++ return slave_devices + + def _add_name(self, name): + if name not in self.names: +@@ -317,7 +318,7 @@ class PopulatorMixin(object): + continue + + # Make sure lvm doesn't get confused by PVs that belong to +- # incomplete VGs. We will remove the PVs from the reject list when/if ++ # incomplete VGs. We will remove the PVs from the blacklist when/if + # the time comes to remove the incomplete VG and its PVs. + for pv in vg.pvs: + lvm.lvm_cc_addFilterRejectRegexp(pv.name) +diff --git a/blivet/threads.py b/blivet/threads.py +index 7e6d3105..a70deb69 100644 +--- a/blivet/threads.py ++++ b/blivet/threads.py +@@ -63,11 +63,12 @@ class SynchronizedMeta(type): + """ + def __new__(cls, name, bases, dct): + new_dct = {} ++ blacklist = dct.get('_unsynchronized_methods', []) + + for n in dct: + obj = dct[n] + # Do not decorate class or static methods. +- if n in dct.get('_unsynchronized_methods', []): ++ if n in blacklist: + pass + elif isinstance(obj, FunctionType): + obj = exclusive(obj) +diff --git a/blivet/udev.py b/blivet/udev.py +index a8297f3f..e1b67845 100644 +--- a/blivet/udev.py ++++ b/blivet/udev.py +@@ -39,7 +39,7 @@ from gi.repository import BlockDev as blockdev + global_udev = pyudev.Context() + log = logging.getLogger("blivet") + +-ignored_device_names = [] ++device_name_blacklist = [] + """ device name regexes to ignore; this should be empty by default """ + + +@@ -77,7 +77,7 @@ def get_devices(subsystem="block"): + + result = [] + for device in global_udev.list_devices(subsystem=subsystem): +- if not __is_ignored_blockdev(device.sys_name): ++ if not __is_blacklisted_blockdev(device.sys_name): + dev = device_to_dict(device) + result.append(dev) + +@@ -176,13 +176,13 @@ def resolve_glob(glob): + return ret + + +-def __is_ignored_blockdev(dev_name): ++def __is_blacklisted_blockdev(dev_name): + """Is this a blockdev we never want for an install?""" + if dev_name.startswith("ram") or dev_name.startswith("fd"): + return True + +- if ignored_device_names: +- if any(re.search(expr, dev_name) for expr in ignored_device_names): ++ if device_name_blacklist: ++ if any(re.search(expr, dev_name) for expr in device_name_blacklist): + return True + + dev_path = "/sys/class/block/%s" % dev_name +@@ -374,7 +374,7 @@ def device_is_disk(info): + device_is_dm_lvm(info) or + device_is_dm_crypt(info) or + (device_is_md(info) and +- (not device_get_md_container(info) and not all(device_is_disk(d) for d in device_get_parents(info)))))) ++ (not device_get_md_container(info) and not all(device_is_disk(d) for d in device_get_slaves(info)))))) + + + def device_is_partition(info): +@@ -453,18 +453,18 @@ def device_get_devname(info): + return info.get('DEVNAME') + + +-def device_get_parents(info): +- """ Return a list of udev device objects representing this device's parents. """ +- parents_dir = device_get_sysfs_path(info) + "/slaves/" ++def device_get_slaves(info): ++ """ Return a list of udev device objects representing this device's slaves. """ ++ slaves_dir = device_get_sysfs_path(info) + "/slaves/" + names = list() +- if os.path.isdir(parents_dir): +- names = os.listdir(parents_dir) ++ if os.path.isdir(slaves_dir): ++ names = os.listdir(slaves_dir) + +- parents = list() ++ slaves = list() + for name in names: +- parents.append(get_device(device_node="/dev/" + name)) ++ slaves.append(get_device(device_node="/dev/" + name)) + +- return parents ++ return slaves + + + def device_get_holders(info): +@@ -736,7 +736,7 @@ def device_get_partition_disk(info): + disk = None + majorminor = info.get("ID_PART_ENTRY_DISK") + sysfs_path = device_get_sysfs_path(info) +- parents_dir = "%s/slaves" % sysfs_path ++ slaves_dir = "%s/slaves" % sysfs_path + if majorminor: + major, minor = majorminor.split(":") + for device in get_devices(): +@@ -744,8 +744,8 @@ def device_get_partition_disk(info): + disk = device_get_name(device) + break + elif device_is_dm_partition(info): +- if os.path.isdir(parents_dir): +- parents = os.listdir(parents_dir) ++ if os.path.isdir(slaves_dir): ++ parents = os.listdir(slaves_dir) + if len(parents) == 1: + disk = resolve_devspec(parents[0].replace('!', '/')) + else: +diff --git a/tests/devicefactory_test.py b/tests/devicefactory_test.py +index dc0d6408..dfd78a7a 100644 +--- a/tests/devicefactory_test.py ++++ b/tests/devicefactory_test.py +@@ -112,9 +112,9 @@ class DeviceFactoryTestCase(unittest.TestCase): + kwargs.get("encrypted", False) or + kwargs.get("container_encrypted", False)) + if kwargs.get("encrypted", False): +- self.assertEqual(device.parents[0].format.luks_version, ++ self.assertEqual(device.slave.format.luks_version, + kwargs.get("luks_version", crypto.DEFAULT_LUKS_VERSION)) +- self.assertEqual(device.raw_device.format.luks_sector_size, ++ self.assertEqual(device.slave.format.luks_sector_size, + kwargs.get("luks_sector_size", 0)) + + self.assertTrue(set(device.disks).issubset(kwargs["disks"])) +@@ -354,7 +354,7 @@ class LVMFactoryTestCase(DeviceFactoryTestCase): + device = args[0] + + if kwargs.get("encrypted"): +- container = device.parents[0].container ++ container = device.slave.container + else: + container = device.container + +@@ -373,7 +373,7 @@ class LVMFactoryTestCase(DeviceFactoryTestCase): + self.assertIsInstance(pv, member_class) + + if pv.encrypted: +- self.assertEqual(pv.parents[0].format.luks_version, ++ self.assertEqual(pv.slave.format.luks_version, + kwargs.get("luks_version", crypto.DEFAULT_LUKS_VERSION)) + + @patch("blivet.formats.lvmpv.LVMPhysicalVolume.formattable", return_value=True) +@@ -589,7 +589,7 @@ class LVMThinPFactoryTestCase(LVMFactoryTestCase): + device = args[0] + + if kwargs.get("encrypted", False): +- thinlv = device.parents[0] ++ thinlv = device.slave + else: + thinlv = device + +diff --git a/tests/devices_test/size_test.py b/tests/devices_test/size_test.py +index d0c0a3f4..a1efa86d 100644 +--- a/tests/devices_test/size_test.py ++++ b/tests/devices_test/size_test.py +@@ -107,8 +107,8 @@ class LUKSDeviceSizeTest(StorageDeviceSizeTest): + + def _get_device(self, *args, **kwargs): + exists = kwargs.get("exists", False) +- parent = StorageDevice(*args, size=kwargs["size"] + crypto.LUKS_METADATA_SIZE, exists=exists) +- return LUKSDevice(*args, **kwargs, parents=[parent]) ++ slave = StorageDevice(*args, size=kwargs["size"] + crypto.LUKS_METADATA_SIZE, exists=exists) ++ return LUKSDevice(*args, **kwargs, parents=[slave]) + + def test_size_getter(self): + initial_size = Size("10 GiB") +@@ -116,4 +116,4 @@ class LUKSDeviceSizeTest(StorageDeviceSizeTest): + + # for LUKS size depends on the backing device size + self.assertEqual(dev.size, initial_size) +- self.assertEqual(dev.raw_device.size, initial_size + crypto.LUKS_METADATA_SIZE) ++ self.assertEqual(dev.slave.size, initial_size + crypto.LUKS_METADATA_SIZE) +diff --git a/tests/populator_test.py b/tests/populator_test.py +index a7748a9d..531ec74b 100644 +--- a/tests/populator_test.py ++++ b/tests/populator_test.py +@@ -81,7 +81,7 @@ class DMDevicePopulatorTestCase(PopulatorHelperTestCase): + @patch.object(DeviceTree, "get_device_by_name") + @patch.object(DMDevice, "status", return_value=True) + @patch.object(DMDevice, "update_sysfs_path") +- @patch.object(DeviceTree, "_add_parent_devices") ++ @patch.object(DeviceTree, "_add_slave_devices") + @patch("blivet.udev.device_get_name") + @patch("blivet.udev.device_get_sysfs_path", return_value=sentinel.sysfs_path) + def test_run(self, *args): +@@ -90,7 +90,7 @@ class DMDevicePopulatorTestCase(PopulatorHelperTestCase): + + devicetree = DeviceTree() + +- # The general case for dm devices is that adding the parent devices ++ # The general case for dm devices is that adding the slave/parent devices + # will result in the dm device itself being in the tree. + device = Mock() + devicetree.get_device_by_name.return_value = device +@@ -99,7 +99,7 @@ class DMDevicePopulatorTestCase(PopulatorHelperTestCase): + + parent = Mock() + parent.parents = [] +- devicetree._add_parent_devices.return_value = [parent] ++ devicetree._add_slave_devices.return_value = [parent] + devicetree._add_device(parent) + devicetree.get_device_by_name.return_value = None + device_name = "dmdevice" +@@ -228,7 +228,7 @@ class LVMDevicePopulatorTestCase(PopulatorHelperTestCase): + # could be the first helper class checked. + + @patch.object(DeviceTree, "get_device_by_name") +- @patch.object(DeviceTree, "_add_parent_devices") ++ @patch.object(DeviceTree, "_add_slave_devices") + @patch("blivet.udev.device_get_name") + @patch("blivet.udev.device_get_lv_vg_name") + def test_run(self, *args): +@@ -240,7 +240,7 @@ class LVMDevicePopulatorTestCase(PopulatorHelperTestCase): + devicetree = DeviceTree() + data = Mock() + +- # Add parent devices and then look up the device. ++ # Add slave/parent devices and then look up the device. + device_get_name.return_value = sentinel.lv_name + devicetree.get_device_by_name.return_value = None + +@@ -260,7 +260,7 @@ class LVMDevicePopulatorTestCase(PopulatorHelperTestCase): + call(sentinel.vg_name), + call(sentinel.lv_name)]) + +- # Add parent devices, but the device is still not in the tree ++ # Add slave/parent devices, but the device is still not in the tree + get_device_by_name.side_effect = None + get_device_by_name.return_value = None + self.assertEqual(helper.run(), None) +@@ -625,7 +625,7 @@ class MDDevicePopulatorTestCase(PopulatorHelperTestCase): + # could be the first helper class checked. + + @patch.object(DeviceTree, "get_device_by_name") +- @patch.object(DeviceTree, "_add_parent_devices") ++ @patch.object(DeviceTree, "_add_slave_devices") + @patch("blivet.udev.device_get_name") + @patch("blivet.udev.device_get_md_uuid") + @patch("blivet.udev.device_get_md_name") +@@ -636,7 +636,7 @@ class MDDevicePopulatorTestCase(PopulatorHelperTestCase): + + devicetree = DeviceTree() + +- # base case: _add_parent_devices gets the array into the tree ++ # base case: _add_slave_devices gets the array into the tree + data = Mock() + device = Mock() + device.parents = [] +@@ -699,12 +699,12 @@ class MultipathDevicePopulatorTestCase(PopulatorHelperTestCase): + # could be the first helper class checked. + + @patch("blivet.udev.device_get_sysfs_path") +- @patch.object(DeviceTree, "_add_parent_devices") ++ @patch.object(DeviceTree, "_add_slave_devices") + @patch("blivet.udev.device_get_name") + def test_run(self, *args): + """Test multipath device populator.""" + device_get_name = args[0] +- add_parent_devices = args[1] ++ add_slave_devices = args[1] + + devicetree = DeviceTree() + # set up some fake udev data to verify handling of specific entries +@@ -719,13 +719,13 @@ class MultipathDevicePopulatorTestCase(PopulatorHelperTestCase): + + device_name = "mpathtest" + device_get_name.return_value = device_name +- parent_1 = Mock(tags=set(), wwn=wwn[2:]) +- parent_1.parents = [] +- parent_2 = Mock(tags=set(), wwn=wwn[2:]) +- parent_2.parents = [] +- devicetree._add_device(parent_1) +- devicetree._add_device(parent_2) +- add_parent_devices.return_value = [parent_1, parent_2] ++ slave_1 = Mock(tags=set(), wwn=wwn[2:]) ++ slave_1.parents = [] ++ slave_2 = Mock(tags=set(), wwn=wwn[2:]) ++ slave_2.parents = [] ++ devicetree._add_device(slave_1) ++ devicetree._add_device(slave_2) ++ add_slave_devices.return_value = [slave_1, slave_2] + + helper = self.helper_class(devicetree, data) + +diff --git a/tests/udev_test.py b/tests/udev_test.py +index f9b10620..d30a647b 100644 +--- a/tests/udev_test.py ++++ b/tests/udev_test.py +@@ -45,11 +45,11 @@ class UdevTest(unittest.TestCase): + @mock.patch('blivet.udev.device_is_dm_crypt', return_value=False) + @mock.patch('blivet.udev.device_is_md') + @mock.patch('blivet.udev.device_get_md_container') +- @mock.patch('blivet.udev.device_get_parents') ++ @mock.patch('blivet.udev.device_get_slaves') + def test_udev_device_is_disk_md(self, *args): + import blivet.udev + info = dict(DEVTYPE='disk', SYS_PATH=mock.sentinel.md_path) +- (device_get_parents, device_get_md_container, device_is_md) = args[:3] # pylint: disable=unbalanced-tuple-unpacking ++ (device_get_slaves, device_get_md_container, device_is_md) = args[:3] # pylint: disable=unbalanced-tuple-unpacking + + disk_parents = [dict(DEVTYPE="disk", SYS_PATH='/fake/path/2'), + dict(DEVTYPE="disk", SYS_PATH='/fake/path/3')] +@@ -64,20 +64,20 @@ class UdevTest(unittest.TestCase): + # Intel FW RAID (MD RAID w/ container layer) + # device_get_container will return some mock value which will evaluate to True + device_get_md_container.return_value = mock.sentinel.md_container +- device_get_parents.side_effect = lambda info: list() ++ device_get_slaves.side_effect = lambda info: list() + self.assertTrue(blivet.udev.device_is_disk(info)) + + # Normal MD RAID +- device_get_parents.side_effect = lambda info: partition_parents if info['SYS_PATH'] == mock.sentinel.md_path else list() ++ device_get_slaves.side_effect = lambda info: partition_parents if info['SYS_PATH'] == mock.sentinel.md_path else list() + device_get_md_container.return_value = None + self.assertFalse(blivet.udev.device_is_disk(info)) + + # Dell FW RAID (MD RAID whose members are all whole disks) +- device_get_parents.side_effect = lambda info: disk_parents if info['SYS_PATH'] == mock.sentinel.md_path else list() ++ device_get_slaves.side_effect = lambda info: disk_parents if info['SYS_PATH'] == mock.sentinel.md_path else list() + self.assertTrue(blivet.udev.device_is_disk(info)) + + # Normal MD RAID (w/ at least one non-disk member) +- device_get_parents.side_effect = lambda info: mixed_parents if info['SYS_PATH'] == mock.sentinel.md_path else list() ++ device_get_slaves.side_effect = lambda info: mixed_parents if info['SYS_PATH'] == mock.sentinel.md_path else list() + self.assertFalse(blivet.udev.device_is_disk(info)) + + +diff --git a/tests/vmtests/vmbackedtestcase.py b/tests/vmtests/vmbackedtestcase.py +index 797bac85..6255104f 100644 +--- a/tests/vmtests/vmbackedtestcase.py ++++ b/tests/vmtests/vmbackedtestcase.py +@@ -50,7 +50,7 @@ class VMBackedTestCase(unittest.TestCase): + defined in set_up_disks. + """ + +- udev.ignored_device_names = [r'^zram'] ++ udev.device_name_blacklist = [r'^zram'] + + # + # create disk images +-- +2.31.1 + diff --git a/SOURCES/0005-Fix-activating-old-style-LVM-snapshots.patch b/SOURCES/0005-Fix-activating-old-style-LVM-snapshots.patch new file mode 100644 index 0000000..e07ea1e --- /dev/null +++ b/SOURCES/0005-Fix-activating-old-style-LVM-snapshots.patch @@ -0,0 +1,35 @@ +From 8ece3da18b1abb89320d02f4475002e6a3ed7875 Mon Sep 17 00:00:00 2001 +From: Vojtech Trefny +Date: Thu, 20 May 2021 13:40:26 +0200 +Subject: [PATCH] Fix activating old style LVM snapshots + +The old style snapshots are activated together with the origin LV +so we need to make sure it is activated to be able to remove the +snapshot or its format. + +Resolves: rhbz#1961739 +--- + blivet/devices/lvm.py | 10 +++++++--- + 1 file changed, 7 insertions(+), 3 deletions(-) + +diff --git a/blivet/devices/lvm.py b/blivet/devices/lvm.py +index a55515fcb..fb57804d9 100644 +--- a/blivet/devices/lvm.py ++++ b/blivet/devices/lvm.py +@@ -1461,9 +1461,13 @@ def _set_format(self, fmt): # pylint: disable=unused-argument + self._update_format_from_origin() + + @old_snapshot_specific +- def setup(self, orig=False): +- # the old snapshot cannot be setup and torn down +- pass ++ def setup(self, orig=False): # pylint: disable=unused-argument ++ # the old snapshot is activated together with the origin ++ if self.origin and not self.origin.status: ++ try: ++ self.origin.setup() ++ except blockdev.LVMError as lvmerr: ++ log.error("failed to activate origin LV: %s", lvmerr) + + @old_snapshot_specific + def teardown(self, recursive=False): diff --git a/SOURCES/0005-Round-down-to-nearest-MiB-value-when-writing-ks-parittion-info.ks b/SOURCES/0005-Round-down-to-nearest-MiB-value-when-writing-ks-parittion-info.ks deleted file mode 100644 index 5ea1723..0000000 --- a/SOURCES/0005-Round-down-to-nearest-MiB-value-when-writing-ks-parittion-info.ks +++ /dev/null @@ -1,48 +0,0 @@ -From dc964f10d24499ea7fc90fd896a8b50c9c5e2d74 Mon Sep 17 00:00:00 2001 -From: "Samantha N. Bueno" -Date: Wed, 8 Jun 2016 13:47:40 -0400 -Subject: [PATCH] Round down to nearest MiB value when writing ks parittion - info. - -On s390x in particular, some partition alignment issue is causing fractional -sizes to be reported. Pykickstart doesn't take anything except int values for -partition info, hence the call to roundToNearest. - -This change only affects the data that is written to ks.cfg. - -Resolves: rhbz#1850670 ---- - blivet/devices/partition.py | 9 ++++++--- - 1 file changed, 6 insertions(+), 3 deletions(-) - -diff --git a/blivet/devices/partition.py b/blivet/devices/partition.py -index 0c56a6e7..76048aed 100644 ---- a/blivet/devices/partition.py -+++ b/blivet/devices/partition.py -@@ -35,7 +35,7 @@ - from ..storage_log import log_method_call - from .. import udev - from ..formats import DeviceFormat, get_format --from ..size import Size, MiB -+from ..size import Size, MiB, ROUND_DOWN - - import logging - log = logging.getLogger("blivet") -@@ -967,7 +967,8 @@ def populate_ksdata(self, data): - data.resize = (self.exists and self.target_size and - self.target_size != self.current_size) - if not self.exists: -- data.size = self.req_base_size.convert_to(MiB) -+ # round this to nearest MiB before doing anything else -+ data.size = self.req_base_size.round_to_nearest(MiB, rounding=ROUND_DOWN).convert_to(spec=MiB) - data.grow = self.req_grow - if self.req_grow: - data.max_size_mb = self.req_max_size.convert_to(MiB) -@@ -980,4 +981,6 @@ def populate_ksdata(self, data): - data.on_part = self.name # by-id - - if data.resize: -- data.size = self.size.convert_to(MiB) -+ # on s390x in particular, fractional sizes are reported, which -+ # cause issues when writing to ks.cfg -+ data.size = self.size.round_to_nearest(MiB, rounding=ROUND_DOWN).convert_to(spec=MiB) diff --git a/SOURCES/0006-Blivet-RHEL-8.3-localization-update.patch b/SOURCES/0006-Blivet-RHEL-8.3-localization-update.patch deleted file mode 100644 index ad1368b..0000000 --- a/SOURCES/0006-Blivet-RHEL-8.3-localization-update.patch +++ /dev/null @@ -1,438 +0,0 @@ -From 44d7e9669fe55fd4b2b3a6c96f23e2d0669f8dbb Mon Sep 17 00:00:00 2001 -From: Vojtech Trefny -Date: Thu, 9 Jul 2020 13:42:31 +0200 -Subject: [PATCH] Blivet RHEL 8.3 localization update - -Resolves: rhbz#1820565 ---- - po/ja.po | 33 ++++++++++----------- - po/ko.po | 83 ++++++++++++++++++++++++----------------------------- - po/zh_CN.po | 28 +++++++++--------- - 3 files changed, 68 insertions(+), 76 deletions(-) - -diff --git a/po/ja.po b/po/ja.po -index 733e63a0..b4c864c2 100644 ---- a/po/ja.po -+++ b/po/ja.po -@@ -29,17 +29,17 @@ msgid "" - msgstr "" - "Project-Id-Version: PACKAGE VERSION\n" - "Report-Msgid-Bugs-To: \n" --"POT-Creation-Date: 2020-05-21 12:42+0200\n" --"PO-Revision-Date: 2018-09-21 01:08+0000\n" --"Last-Translator: Copied by Zanata \n" --"Language-Team: Japanese (http://www.transifex.com/projects/p/blivet/language/" --"ja/)\n" -+"POT-Creation-Date: 2020-01-29 14:04+0100\n" -+"PO-Revision-Date: 2020-07-03 07:42+0000\n" -+"Last-Translator: Ludek Janda \n" -+"Language-Team: Japanese \n" - "Language: ja\n" - "MIME-Version: 1.0\n" - "Content-Type: text/plain; charset=UTF-8\n" - "Content-Transfer-Encoding: 8bit\n" - "Plural-Forms: nplurals=1; plural=0;\n" --"X-Generator: Zanata 4.6.2\n" -+"X-Generator: Weblate 4.1.1\n" - - #: ../blivet/errors.py:210 - msgid "" -@@ -47,6 +47,8 @@ msgid "" - "of the UUID value which should be unique. In that case you can either " - "disconnect one of the devices or reformat it." - msgstr "" -+"これは通常、デバイスイメージを複製したことで、一意であるはずのUUID値が重複することが原因です。その場合は、いずれかのデバイスを切断するか、再フォーマッ" -+"トしてください。" - - #: ../blivet/errors.py:217 - msgid "" -@@ -54,9 +56,8 @@ msgid "" - "kernel is reporting partitions on. It is unclear what the exact problem is. " - "Please file a bug at http://bugzilla.redhat.com" - msgstr "" --"なんらかの理由により、kernel がパーティションを報告しているディスク上でディス" --"クラベルを見つけられませんでした。何が問題となっているかは不明です。バグを " --"http://bugzilla.redhat.com に提出してください。" -+"なんらかの理由により、kernel がパーティションを報告しているディスク上でディスクラベルを見つけられませんでした。何が問題となっているかは不明です。" -+"バグを http://bugzilla.redhat.com に提出してください" - - #: ../blivet/errors.py:224 - msgid "" -@@ -84,7 +85,7 @@ msgstr "FCoE は使用できません" - - #: ../blivet/zfcp.py:62 - msgid "You have not specified a device number or the number is invalid" --msgstr "デバイス番号を指定していないか番号が無効です。" -+msgstr "デバイス番号を指定していないか番号が無効です" - - #: ../blivet/zfcp.py:64 - msgid "You have not specified a worldwide port name or the name is invalid." -@@ -202,7 +203,7 @@ msgstr "iSCSI ノードが何も探索できませんでした" - - #: ../blivet/iscsi.py:550 - msgid "No new iSCSI nodes discovered" --msgstr "新しい iSCSI ノードは見つかりませんでした。" -+msgstr "新しい iSCSI ノードは見つかりませんでした" - - #: ../blivet/iscsi.py:553 - msgid "Could not log in to any of the discovered nodes" -@@ -257,7 +258,7 @@ msgstr "要求を超えたサイズを再利用することができません" - - #: ../blivet/partitioning.py:1419 - msgid "DiskChunk requests must be of type PartitionRequest" --msgstr "DiskChunk 要求には PartitionResquest タイプが必要です。" -+msgstr "DiskChunk 要求には PartitionResquest タイプが必要です" - - #: ../blivet/partitioning.py:1432 - msgid "partitions allocated outside disklabel limits" -@@ -265,7 +266,7 @@ msgstr "ディスクラベルの範囲外に割り当てられたパーティシ - - #: ../blivet/partitioning.py:1517 - msgid "VGChunk requests must be of type LVRequest" --msgstr "VGChunk 要求には LVResquest タイプが必要です。" -+msgstr "VGChunk 要求には LVResquest タイプが必要です" - - #. by now we have allocated the PVs so if there isn't enough - #. space in the VG we have a real problem -@@ -368,15 +369,15 @@ msgstr "" - msgid "Cannot remove a member from existing %s array" - msgstr "既存の %s 配列からメンバーを削除できません" - --#: ../blivet/formats/fs.py:934 -+#: ../blivet/formats/fs.py:932 - msgid "EFI System Partition" - msgstr "EFI システムパーティション" - --#: ../blivet/formats/fs.py:1139 -+#: ../blivet/formats/fs.py:1137 - msgid "Apple Bootstrap" - msgstr "Apple ブートストラップ" - --#: ../blivet/formats/fs.py:1175 -+#: ../blivet/formats/fs.py:1173 - msgid "Linux HFS+ ESP" - msgstr "Linux HFS+ ESP" - -diff --git a/po/ko.po b/po/ko.po -index 66789af0..747b00c5 100644 ---- a/po/ko.po -+++ b/po/ko.po -@@ -20,17 +20,17 @@ msgid "" - msgstr "" - "Project-Id-Version: PACKAGE VERSION\n" - "Report-Msgid-Bugs-To: \n" --"POT-Creation-Date: 2020-05-21 12:42+0200\n" --"PO-Revision-Date: 2018-09-21 01:08+0000\n" --"Last-Translator: Copied by Zanata \n" --"Language-Team: Korean (http://www.transifex.com/projects/p/blivet/language/" --"ko/)\n" -+"POT-Creation-Date: 2020-01-29 14:04+0100\n" -+"PO-Revision-Date: 2020-07-03 07:42+0000\n" -+"Last-Translator: Ludek Janda \n" -+"Language-Team: Korean \n" - "Language: ko\n" - "MIME-Version: 1.0\n" - "Content-Type: text/plain; charset=UTF-8\n" - "Content-Transfer-Encoding: 8bit\n" - "Plural-Forms: nplurals=1; plural=0;\n" --"X-Generator: Zanata 4.6.2\n" -+"X-Generator: Weblate 4.1.1\n" - - #: ../blivet/errors.py:210 - msgid "" -@@ -38,6 +38,8 @@ msgid "" - "of the UUID value which should be unique. In that case you can either " - "disconnect one of the devices or reformat it." - msgstr "" -+"이는 일반적으로 장치 이미지 복제로 인해 고유한 UUID 값이 복제되기 때문에 발생합니다. 이 경우 장치 중 하나를 분리하거나 다시 " -+"포맷할 수 있습니다." - - #: ../blivet/errors.py:217 - msgid "" -@@ -45,9 +47,8 @@ msgid "" - "kernel is reporting partitions on. It is unclear what the exact problem is. " - "Please file a bug at http://bugzilla.redhat.com" - msgstr "" --"일부 이유로 커널이 파티션 설정을 보고하는 디스크에 디스크 레이블을 배치할 수 " --"없습니다. 정확한 문제가 무엇인지 알 수 없습니다. http://bugzilla.redhat.com" --"에 버그 리포트를 제출해 주십시오." -+"일부 이유로 커널이 파티션 설정을 보고하는 디스크에 디스크 레이블을 배치할 수 없습니다. 정확한 문제가 무엇인지 알 수 없습니다. " -+"http://bugzilla.redhat.com에 버그 리포트를 제출해 주십시오" - - #: ../blivet/errors.py:224 - msgid "" -@@ -78,11 +79,11 @@ msgstr "장치 번호를 지정하지 않았거나, 번호가 맞지 않습니 - - #: ../blivet/zfcp.py:64 - msgid "You have not specified a worldwide port name or the name is invalid." --msgstr "세계 포트 이름(WWPN)을 지정하지 않았거나, 포트 번호가 맞지 않습니다" -+msgstr "세계 포트 이름(WWPN)을 지정하지 않았거나, 포트 번호가 맞지 않습니다." - - #: ../blivet/zfcp.py:66 - msgid "You have not specified a FCP LUN or the number is invalid." --msgstr "FCP LUN을 지정하지 않았거나, 번호가 맞지 않습니다" -+msgstr "FCP LUN을 지정하지 않았거나, 번호가 맞지 않습니다." - - #: ../blivet/zfcp.py:91 - #, python-format -@@ -103,7 +104,7 @@ msgstr "WWPN %(wwpn)s을(를) zFCP 장치 %(devnum)s (%(e)s)에 추가할 수 - #: ../blivet/zfcp.py:119 - #, python-format - msgid "WWPN %(wwpn)s not found at zFCP device %(devnum)s." --msgstr "WWPN %(wwpn)s을(를) zFCP 장치 %(devnum)s에서 찾을 수 없습니다. " -+msgstr "WWPN %(wwpn)s을(를) zFCP 장치 %(devnum)s에서 찾을 수 없습니다." - - #: ../blivet/zfcp.py:134 - #, python-format -@@ -111,8 +112,7 @@ msgid "" - "Could not add LUN %(fcplun)s to WWPN %(wwpn)s on zFCP device %(devnum)s " - "(%(e)s)." - msgstr "" --"zFCP 장치 %(devnum)s (%(e)s)에서 LUN %(fcplun)s을(를) WWPN %(wwpn)s에 추가할 " --"수 없습니다. " -+"zFCP 장치 %(devnum)s (%(e)s)에서 LUN %(fcplun)s을(를) WWPN %(wwpn)s에 추가할 수 없습니다." - - #: ../blivet/zfcp.py:140 - #, python-format -@@ -136,18 +136,14 @@ msgstr "" - msgid "" - "Failed LUN %(fcplun)s at WWPN %(wwpn)s on zFCP device %(devnum)s removed " - "again." --msgstr "" --"zFCP 장치 %(devnum)s에 있는 WWPN %(wwpn)s에서 실패한 LUN %(fcplun)s이 다시 삭" --"제되었습니다. " -+msgstr "zFCP 장치 %(devnum)s에 있는 WWPN %(wwpn)s에서 실패한 LUN %(fcplun)s이 다시 삭제되었습니다." - - #: ../blivet/zfcp.py:218 - #, python-format - msgid "" - "Could not correctly delete SCSI device of zFCP %(devnum)s %(wwpn)s " - "%(fcplun)s (%(e)s)." --msgstr "" --"zFCP %(devnum)s %(wwpn)s %(fcplun)s (%(e)s)의 SCSI 장치를 올바르게 삭제할 수 " --"없습니다. " -+msgstr "zFCP %(devnum)s %(wwpn)s %(fcplun)s (%(e)s)의 SCSI 장치를 올바르게 삭제할 수 없습니다." - - #: ../blivet/zfcp.py:227 - #, python-format -@@ -161,41 +157,40 @@ msgstr "" - #: ../blivet/zfcp.py:245 - #, python-format - msgid "Could not remove WWPN %(wwpn)s on zFCP device %(devnum)s (%(e)s)." --msgstr "" --"zFCP 장치 %(devnum)s (%(e)s)에서 WWPN %(wwpn)s을(를) 제거할 수 없습니다. " -+msgstr "zFCP 장치 %(devnum)s (%(e)s)에서 WWPN %(wwpn)s을(를) 제거할 수 없습니다." - - #: ../blivet/zfcp.py:271 - #, python-format - msgid "Could not set zFCP device %(devnum)s offline (%(e)s)." --msgstr "zFCP 장치 %(devnum)s를 오프라인 (%(e)s)으로 설정할 수 없습니다. " -+msgstr "zFCP 장치 %(devnum)s를 오프라인 (%(e)s)으로 설정할 수 없습니다." - - #: ../blivet/iscsi.py:217 - msgid "Unable to change iSCSI initiator name once set" --msgstr "iSCSI 개시자 이름이 설정되면 이를 변경할 수 없음 " -+msgstr "iSCSI 개시자 이름이 설정되면 이를 변경할 수 없음" - - #: ../blivet/iscsi.py:219 - msgid "Must provide an iSCSI initiator name" --msgstr "iSCSI 개시자 이름을 지정하십시오 " -+msgstr "iSCSI 개시자 이름을 지정하십시오" - - #: ../blivet/iscsi.py:410 - msgid "iSCSI not available" --msgstr "iSCSI 사용 불가능 " -+msgstr "iSCSI 사용 불가능" - - #: ../blivet/iscsi.py:412 - msgid "No initiator name set" --msgstr "이니셰이터 이름이 설정되지 않음 " -+msgstr "이니셰이터 이름이 설정되지 않음" - - #: ../blivet/iscsi.py:530 - msgid "No iSCSI nodes discovered" --msgstr "iSCSI 노드를 찾을 수 없음 " -+msgstr "iSCSI 노드를 찾을 수 없음" - - #: ../blivet/iscsi.py:550 - msgid "No new iSCSI nodes discovered" --msgstr "새 iSCSI 노드를 찾을 수 없음 " -+msgstr "새 iSCSI 노드를 찾을 수 없음" - - #: ../blivet/iscsi.py:553 - msgid "Could not log in to any of the discovered nodes" --msgstr "검색된 노드로 로그인할 수 없음 " -+msgstr "검색된 노드로 로그인할 수 없음" - - #: ../blivet/partitioning.py:454 - msgid "unable to allocate aligned partition" -@@ -265,7 +260,7 @@ msgstr "LVM 요청에 필요한 공간이 충분하지 않습니다" - #: ../blivet/deviceaction.py:194 - #, python-format - msgid "Executing %(action)s" --msgstr "%(action)s 실행 " -+msgstr "%(action)s 실행" - - #: ../blivet/deviceaction.py:322 - msgid "create device" -@@ -286,7 +281,7 @@ msgstr "포맷 생성" - #: ../blivet/deviceaction.py:613 - #, python-format - msgid "Creating %(type)s on %(device)s" --msgstr "%(device)s에 %(type)s 생성 " -+msgstr "%(device)s에 %(type)s 생성" - - #: ../blivet/deviceaction.py:640 - #, python-format -@@ -327,11 +322,11 @@ msgstr "컨테이너 멤버 삭제" - - #: ../blivet/deviceaction.py:1058 - msgid "configure format" --msgstr "포맷 설정 " -+msgstr "포맷 설정" - - #: ../blivet/deviceaction.py:1114 - msgid "configure device" --msgstr "장치 설정 " -+msgstr "장치 설정" - - #: ../blivet/devices/raid.py:58 - #, python-format -@@ -341,32 +336,28 @@ msgid "" - msgid_plural "" - "RAID level %(raid_level)s requires that device have at least %(min_members)d " - "members." --msgstr[0] "" --"RAID 레벨 %(raid_level)s에는 최소 %(min_members)d개의 장치 구성원이 필요합니" --"다. " -+msgstr[0] "RAID 레벨 %(raid_level)s에는 최소 %(min_members)d개의 장치 구성원이 필요합니다." - - #: ../blivet/devices/raid.py:79 - #, python-format - msgid "" - "RAID level %(raid_level)s is an invalid value. Must be one of (%(levels)s)." --msgstr "" --"RAID 레벨 %(raid_level)s이/가 유효한 값이 아닙니다. (%(levels)s) 중 하나여야 " --"합니다. " -+msgstr "RAID 레벨 %(raid_level)s이/가 유효한 값이 아닙니다. (%(levels)s) 중 하나여야 합니다." - - #: ../blivet/devices/raid.py:104 - #, python-format - msgid "Cannot remove a member from existing %s array" --msgstr "기존 %s 어레이에서 장치 구성원을 제거할 수 없습니다 " -+msgstr "기존 %s 어레이에서 장치 구성원을 제거할 수 없습니다" - --#: ../blivet/formats/fs.py:934 -+#: ../blivet/formats/fs.py:932 - msgid "EFI System Partition" --msgstr "EFI 시스템 파티션 " -+msgstr "EFI 시스템 파티션" - --#: ../blivet/formats/fs.py:1139 -+#: ../blivet/formats/fs.py:1137 - msgid "Apple Bootstrap" - msgstr "Apple 부트스트랩" - --#: ../blivet/formats/fs.py:1175 -+#: ../blivet/formats/fs.py:1173 - msgid "Linux HFS+ ESP" - msgstr "Linux HFS+ ESP" - -@@ -384,7 +375,7 @@ msgstr "암호화됨" - - #: ../blivet/formats/luks.py:388 - msgid "DM Integrity" --msgstr "DM 무결성 " -+msgstr "DM 무결성" - - #: ../blivet/formats/__init__.py:148 - msgid "Unknown" -diff --git a/po/zh_CN.po b/po/zh_CN.po -index 480801de..2be6d492 100644 ---- a/po/zh_CN.po -+++ b/po/zh_CN.po -@@ -20,24 +20,24 @@ msgid "" - msgstr "" - "Project-Id-Version: PACKAGE VERSION\n" - "Report-Msgid-Bugs-To: \n" --"POT-Creation-Date: 2020-05-21 12:42+0200\n" --"PO-Revision-Date: 2018-09-13 02:13+0000\n" --"Last-Translator: Copied by Zanata \n" --"Language-Team: Chinese (China) (http://www.transifex.com/projects/p/blivet/" --"language/zh_CN/)\n" -+"POT-Creation-Date: 2020-01-29 14:04+0100\n" -+"PO-Revision-Date: 2020-07-03 07:42+0000\n" -+"Last-Translator: Ludek Janda \n" -+"Language-Team: Chinese (Simplified) \n" - "Language: zh_CN\n" - "MIME-Version: 1.0\n" - "Content-Type: text/plain; charset=UTF-8\n" - "Content-Transfer-Encoding: 8bit\n" - "Plural-Forms: nplurals=1; plural=0;\n" --"X-Generator: Zanata 4.6.2\n" -+"X-Generator: Weblate 4.1.1\n" - - #: ../blivet/errors.py:210 - msgid "" - "This is usually caused by cloning the device image resulting in duplication " - "of the UUID value which should be unique. In that case you can either " - "disconnect one of the devices or reformat it." --msgstr "" -+msgstr "这通常是由于克隆设备镜像导致 UUID 值重复造成的，而 UUID 值应该是唯一的。如果是这种情况，可以断开其中一个设备或重新格式化它。" - - #: ../blivet/errors.py:217 - msgid "" -@@ -45,8 +45,8 @@ msgid "" - "kernel is reporting partitions on. It is unclear what the exact problem is. " - "Please file a bug at http://bugzilla.redhat.com" - msgstr "" --"由于某些原因无法定位内核报告中显示在其中进行分区的磁盘的磁盘标签。尚不了解具" --"体问题所在。请在 http://bugzilla.redhat.com 提交 bug。" -+"由于某些原因无法定位内核报告中显示在其中进行分区的磁盘的磁盘标签。尚不了解具体问题所在。请在 http://bugzilla.redhat.com 提交 " -+"bug" - - #: ../blivet/errors.py:224 - msgid "" -@@ -170,7 +170,7 @@ msgstr "设定后就无法更改 iSCSI 启动程序名称" - - #: ../blivet/iscsi.py:219 - msgid "Must provide an iSCSI initiator name" --msgstr "您必须提供一个 iSCSI 启动程序名称。" -+msgstr "您必须提供一个 iSCSI 启动程序名称" - - #: ../blivet/iscsi.py:410 - msgid "iSCSI not available" -@@ -223,7 +223,7 @@ msgstr "" - - #: ../blivet/partitioning.py:962 - msgid "Unable to allocate requested partition scheme." --msgstr "无法分配所需分区方案" -+msgstr "无法分配所需分区方案。" - - #: ../blivet/partitioning.py:997 - msgid "not enough free space after creating extended partition" -@@ -347,15 +347,15 @@ msgstr "" - msgid "Cannot remove a member from existing %s array" - msgstr "无法从存在的 %s 阵列中删除一个成员" - --#: ../blivet/formats/fs.py:934 -+#: ../blivet/formats/fs.py:932 - msgid "EFI System Partition" - msgstr "EFI 系统分区" - --#: ../blivet/formats/fs.py:1139 -+#: ../blivet/formats/fs.py:1137 - msgid "Apple Bootstrap" - msgstr "Apple Bootstrap" - --#: ../blivet/formats/fs.py:1175 -+#: ../blivet/formats/fs.py:1173 - msgid "Linux HFS+ ESP" - msgstr "Linux HFS+ ESP" - --- -2.25.4 - diff --git a/SOURCES/0007-Do-not-use-FSAVAIL-and-FSUSE-options-when-running-lsblk.patch b/SOURCES/0007-Do-not-use-FSAVAIL-and-FSUSE-options-when-running-lsblk.patch deleted file mode 100644 index c8e1447..0000000 --- a/SOURCES/0007-Do-not-use-FSAVAIL-and-FSUSE-options-when-running-lsblk.patch +++ /dev/null @@ -1,24 +0,0 @@ -From 7bc4e324580656585adad0cbe51d60ed3540b766 Mon Sep 17 00:00:00 2001 -From: Vojtech Trefny -Date: Fri, 3 Jul 2020 13:04:23 +0200 -Subject: [PATCH] Do not use FSAVAIL and FSUSE% options when running lsblk - -These options were added in util-linux 2.33 which is not available -on older systems so we should not use these. ---- - blivet/blivet.py | 2 +- - 1 file changed, 1 insertion(+), 1 deletion(-) - -diff --git a/blivet/blivet.py b/blivet/blivet.py -index fcc2080b..e7dbd37b 100644 ---- a/blivet/blivet.py -+++ b/blivet/blivet.py -@@ -77,7 +77,7 @@ def __init__(self): - self._dump_file = "%s/storage.state" % tempfile.gettempdir() - - try: -- options = "NAME,SIZE,OWNER,GROUP,MODE,FSTYPE,LABEL,UUID,PARTUUID,FSAVAIL,FSUSE%,MOUNTPOINT" -+ options = "NAME,SIZE,OWNER,GROUP,MODE,FSTYPE,LABEL,UUID,PARTUUID,MOUNTPOINT" - out = capture_output(["lsblk", "--bytes", "-a", "-o", options]) - except Exception: # pylint: disable=broad-except - pass diff --git a/SOURCES/0008-set-allowed-disk-labels-for-s390x-as-standard-ones-plus-dasd.patch b/SOURCES/0008-set-allowed-disk-labels-for-s390x-as-standard-ones-plus-dasd.patch deleted file mode 100644 index 931fca0..0000000 --- a/SOURCES/0008-set-allowed-disk-labels-for-s390x-as-standard-ones-plus-dasd.patch +++ /dev/null @@ -1,39 +0,0 @@ -From 462099a9137fb7997140360c07665a21615a0fea Mon Sep 17 00:00:00 2001 -From: =?UTF-8?q?Dan=20Hor=C3=A1k?= -Date: Tue, 7 Jul 2020 13:19:02 +0200 -Subject: [PATCH] set allowed disk labels for s390x as standard ones (msdos + - gpt) plus dasd - -This will solve issues when a SCSI or NVMe disk with GPT partition table -is used with a s390x machine (rhbz#1827066, rhbz#1854110). ---- - blivet/formats/disklabel.py | 2 +- - tests/formats_test/disklabel_test.py | 2 +- - 2 files changed, 2 insertions(+), 2 deletions(-) - -diff --git a/blivet/formats/disklabel.py b/blivet/formats/disklabel.py -index 3dcac12b..53e2c010 100644 ---- a/blivet/formats/disklabel.py -+++ b/blivet/formats/disklabel.py -@@ -230,7 +230,7 @@ def get_platform_label_types(cls): - elif arch.is_efi() and not arch.is_aarch64(): - label_types = ["gpt", "msdos"] - elif arch.is_s390(): -- label_types = ["msdos", "dasd"] -+ label_types += ["dasd"] - - return label_types - -diff --git a/tests/formats_test/disklabel_test.py b/tests/formats_test/disklabel_test.py -index 94f3775f..3068dc07 100644 ---- a/tests/formats_test/disklabel_test.py -+++ b/tests/formats_test/disklabel_test.py -@@ -95,7 +95,7 @@ def test_platform_label_types(self, arch): - arch.is_arm.return_value = False - - arch.is_s390.return_value = True -- self.assertEqual(disklabel_class.get_platform_label_types(), ["msdos", "dasd"]) -+ self.assertEqual(disklabel_class.get_platform_label_types(), ["msdos", "gpt", "dasd"]) - arch.is_s390.return_value = False - - def test_label_type_size_check(self): diff --git a/SOURCES/0009-Do-not-use-BlockDev-utils_have_kernel_module-to-check-for-modules.patch b/SOURCES/0009-Do-not-use-BlockDev-utils_have_kernel_module-to-check-for-modules.patch deleted file mode 100644 index 8736460..0000000 --- a/SOURCES/0009-Do-not-use-BlockDev-utils_have_kernel_module-to-check-for-modules.patch +++ /dev/null @@ -1,47 +0,0 @@ -From 7303f4a3f2fe3280339f6303dcff31b6ade12176 Mon Sep 17 00:00:00 2001 -From: Vojtech Trefny -Date: Thu, 9 Jul 2020 16:30:55 +0200 -Subject: [PATCH] Do not use BlockDev.utils_have_kernel_module to check for - modules - -The function unfortunately uses only the name when searching for -the module and we need to use aliases for modules like ext2 and -ext3. So we need to use "modprobe --dry-run" instead. ---- - blivet/formats/fs.py | 12 +++--------- - 1 file changed, 3 insertions(+), 9 deletions(-) - -diff --git a/blivet/formats/fs.py b/blivet/formats/fs.py -index eee15aaa..bcfbc08e 100644 ---- a/blivet/formats/fs.py -+++ b/blivet/formats/fs.py -@@ -60,12 +60,6 @@ - import logging - log = logging.getLogger("blivet") - --import gi --gi.require_version("GLib", "2.0") --gi.require_version("BlockDev", "2.0") -- --from gi.repository import GLib --from gi.repository import BlockDev - - AVAILABLE_FILESYSTEMS = kernel_filesystems - -@@ -462,13 +456,13 @@ def check_module(self): - - for module in self._modules: - try: -- succ = BlockDev.utils_have_kernel_module(module) -- except GLib.GError as e: -+ rc = util.run_program(["modprobe", "--dry-run", module]) -+ except OSError as e: - log.error("Could not check kernel module availability %s: %s", module, e) - self._supported = False - return - -- if not succ: -+ if rc: - log.debug("Kernel module %s not available", module) - self._supported = False - return diff --git a/SOURCES/0010-Fix-name-resolution-for-MD-devices-and-partitions-on.patch b/SOURCES/0010-Fix-name-resolution-for-MD-devices-and-partitions-on.patch deleted file mode 100644 index e94ba8e..0000000 --- a/SOURCES/0010-Fix-name-resolution-for-MD-devices-and-partitions-on.patch +++ /dev/null @@ -1,844 +0,0 @@ -From 18ce766bc90abdf0d8ca54bdf578463392a52ee9 Mon Sep 17 00:00:00 2001 -From: Vojtech Trefny -Date: Wed, 12 Aug 2020 10:57:19 +0200 -Subject: [PATCH 1/2] Fix name resolution for MD devices and partitions on them - -UDev data for both member disks/partitions and partitions on arrays -contain the MD_* properties we must be extra careful when deciding -what name we'll use for the device. - -Resolves: rhbz#1862904 ---- - blivet/udev.py | 12 ++++++++++-- - 1 file changed, 10 insertions(+), 2 deletions(-) - -diff --git a/blivet/udev.py b/blivet/udev.py -index 41c99496..c85eb3dc 100644 ---- a/blivet/udev.py -+++ b/blivet/udev.py -@@ -202,9 +202,16 @@ def device_get_name(udev_info): - """ Return the best name for a device based on the udev db data. """ - if "DM_NAME" in udev_info: - name = udev_info["DM_NAME"] -- elif "MD_DEVNAME" in udev_info and os.path.exists(device_get_sysfs_path(udev_info) + "/md"): -+ elif "MD_DEVNAME" in udev_info: - mdname = udev_info["MD_DEVNAME"] -- if device_is_partition(udev_info): -+ if device_is_md(udev_info): -+ # MD RAID array -> use MD_DEVNAME -+ name = mdname -+ elif device_get_format(udev_info) == "linux_raid_member": -+ # MD RAID member -> use SYS_NAME -+ name = udev_info["SYS_NAME"] -+ elif device_is_partition(udev_info): -+ # partition on RAID -> construct name from MD_DEVNAME + partition number - # for partitions on named RAID we want to use the raid name, not - # the node, e.g. "raid1" instead of "md127p1" - partnum = udev_info["ID_PART_ENTRY_NUMBER"] -@@ -213,6 +220,7 @@ def device_get_name(udev_info): - else: - name = mdname + partnum - else: -+ # something else -> default to MD_DEVNAME - name = mdname - else: - name = udev_info["SYS_NAME"] --- -2.25.4 - - -From dc96961adcb9dd6ef6d09e4daaa0a5eaae1ffe60 Mon Sep 17 00:00:00 2001 -From: Vojtech Trefny -Date: Wed, 12 Aug 2020 11:10:03 +0200 -Subject: [PATCH 2/2] Add tests for udev.device_get_name for RAID devices - -This includes sample UDev data for various combinations of RAID -devices configuration. - -Related: rhbz#1862904 ---- - tests/udev_data/__init__.py | 0 - tests/udev_data/raid_data.py | 705 +++++++++++++++++++++++++++++++++++ - tests/udev_test.py | 46 +++ - 3 files changed, 751 insertions(+) - create mode 100644 tests/udev_data/__init__.py - create mode 100644 tests/udev_data/raid_data.py - -diff --git a/tests/udev_data/__init__.py b/tests/udev_data/__init__.py -new file mode 100644 -index 00000000..e69de29b -diff --git a/tests/udev_data/raid_data.py b/tests/udev_data/raid_data.py -new file mode 100644 -index 00000000..509cbfbd ---- /dev/null -+++ b/tests/udev_data/raid_data.py -@@ -0,0 +1,705 @@ -+# Sample UDev data for various MD RAID devices: -+# - member_boot: data for the member disk or partition after booting the system -+# - member_assemble: data for the member disk or partition after re-assembling stopped array using -+# 'mdadm --assemble --scan' (yes, this is different from member_boot) -+# - raid_device: data for the RAID array device -+# - raid_partition: data for partition on the array -+# -+# We have data for different combinations of member "types", MD metadata versions and named v unnamed -+# RAID devices. -+# The data were gathered on Fedora 32. -+ -+ -+class RaidOnDisk1(): -+ member_name = "sda" -+ raid_name = "127" -+ raid_node = "md127" -+ metadata_version = "1.2" -+ -+ member_boot = {'DEVLINKS': '/dev/disk/by-path/pci-0000:00:11.0-scsi-0:0:0:0 /dev/disk/by-id/scsi-0QEMU_QEMU_HARDDISK_drive-scsi0-0-0-0', -+ 'DEVNAME': '/dev/sda', -+ 'DEVPATH': '/devices/pci0000:00/0000:00:11.0/virtio5/host8/target8:0:0/8:0:0:0/block/sda', -+ 'DEVTYPE': 'disk', -+ 'ID_BUS': 'scsi', -+ 'ID_FS_LABEL': 'localhost.localdomain:127', -+ 'ID_FS_LABEL_ENC': 'localhost.localdomain:127', -+ 'ID_FS_TYPE': 'linux_raid_member', -+ 'ID_FS_USAGE': 'raid', -+ 'ID_FS_UUID': '54956eb2-6983-8759-e2ad-4c40acc92e4b', -+ 'ID_FS_UUID_ENC': '54956eb2-6983-8759-e2ad-4c40acc92e4b', -+ 'ID_FS_UUID_SUB': '64f96f0b-e97c-9157-d393-1fe457f3dd59', -+ 'ID_FS_UUID_SUB_ENC': '64f96f0b-e97c-9157-d393-1fe457f3dd59', -+ 'ID_FS_VERSION': '1.2', -+ 'ID_MODEL': 'QEMU_HARDDISK', -+ 'ID_MODEL_ENC': 'QEMU\\x20HARDDISK\\x20\\x20\\x20', -+ 'ID_PATH': 'pci-0000:00:11.0-scsi-0:0:0:0', -+ 'ID_PATH_TAG': 'pci-0000_00_11_0-scsi-0_0_0_0', -+ 'ID_REVISION': '2.5+', -+ 'ID_SCSI': '1', -+ 'ID_SERIAL': '0QEMU_QEMU_HARDDISK_drive-scsi0-0-0-0', -+ 'ID_SERIAL_SHORT': 'drive-scsi0-0-0-0', -+ 'ID_TYPE': 'disk', -+ 'ID_VENDOR': 'QEMU', -+ 'ID_VENDOR_ENC': 'QEMU\\x20\\x20\\x20\\x20', -+ 'MAJOR': '8', -+ 'MD_DEVICE': 'md127', -+ 'MD_DEVNAME': '127', -+ 'MD_FOREIGN': 'no', -+ 'MD_STARTED': 'unsafe', -+ 'MINOR': '0', -+ 'SUBSYSTEM': 'block', -+ 'SYSTEMD_WANTS': 'mdadm-last-resort@md127.timer', -+ 'TAGS': ':systemd:', -+ 'USEC_INITIALIZED': '5529231', -+ 'SYS_NAME': 'sda', -+ 'SYS_PATH': '/sys/devices/pci0000:00/0000:00:11.0/virtio5/host8/target8:0:0/8:0:0:0/block/sda'} -+ -+ member_assemble = {'DEVLINKS': '/dev/disk/by-path/pci-0000:00:11.0-scsi-0:0:0:0 /dev/disk/by-id/scsi-0QEMU_QEMU_HARDDISK_drive-scsi0-0-0-0', -+ 'DEVNAME': '/dev/sda', -+ 'DEVPATH': '/devices/pci0000:00/0000:00:11.0/virtio5/host8/target8:0:0/8:0:0:0/block/sda', -+ 'DEVTYPE': 'disk', -+ 'ID_BUS': 'scsi', -+ 'ID_FS_LABEL': 'localhost.localdomain:127', -+ 'ID_FS_LABEL_ENC': 'localhost.localdomain:127', -+ 'ID_FS_TYPE': 'linux_raid_member', -+ 'ID_FS_USAGE': 'raid', -+ 'ID_FS_UUID': '54956eb2-6983-8759-e2ad-4c40acc92e4b', -+ 'ID_FS_UUID_ENC': '54956eb2-6983-8759-e2ad-4c40acc92e4b', -+ 'ID_FS_UUID_SUB': '64f96f0b-e97c-9157-d393-1fe457f3dd59', -+ 'ID_FS_UUID_SUB_ENC': '64f96f0b-e97c-9157-d393-1fe457f3dd59', -+ 'ID_FS_VERSION': '1.2', -+ 'ID_MODEL': 'QEMU_HARDDISK', -+ 'ID_MODEL_ENC': 'QEMU\\x20HARDDISK\\x20\\x20\\x20', -+ 'ID_PATH': 'pci-0000:00:11.0-scsi-0:0:0:0', -+ 'ID_PATH_TAG': 'pci-0000_00_11_0-scsi-0_0_0_0', -+ 'ID_REVISION': '2.5+', -+ 'ID_SCSI': '1', -+ 'ID_SERIAL': '0QEMU_QEMU_HARDDISK_drive-scsi0-0-0-0', -+ 'ID_SERIAL_SHORT': 'drive-scsi0-0-0-0', -+ 'ID_TYPE': 'disk', -+ 'ID_VENDOR': 'QEMU', -+ 'ID_VENDOR_ENC': 'QEMU\\x20\\x20\\x20\\x20', -+ 'MAJOR': '8', -+ 'MINOR': '0', -+ 'SUBSYSTEM': 'block', -+ 'TAGS': ':systemd:', -+ 'USEC_INITIALIZED': '5529231', -+ 'SYS_NAME': 'sda', -+ 'SYS_PATH': '/sys/devices/pci0000:00/0000:00:11.0/virtio5/host8/target8:0:0/8:0:0:0/block/sda'} -+ -+ raid_device = {'DEVLINKS': '/dev/disk/by-id/md-name-localhost.localdomain:127 /dev/disk/by-id/md-uuid-54956eb2:69838759:e2ad4c40:acc92e4b /dev/md/127', -+ 'DEVNAME': '/dev/md127', -+ 'DEVPATH': '/devices/virtual/block/md127', -+ 'DEVTYPE': 'disk', -+ 'ID_PART_TABLE_TYPE': 'dos', -+ 'ID_PART_TABLE_UUID': '4eec0361', -+ 'MAJOR': '9', -+ 'MD_DEVICES': '2', -+ 'MD_DEVICE_ev_sda_DEV': '/dev/sda', -+ 'MD_DEVICE_ev_sda_ROLE': '0', -+ 'MD_DEVICE_ev_sdb_DEV': '/dev/sdb', -+ 'MD_DEVICE_ev_sdb_ROLE': '1', -+ 'MD_DEVNAME': '127', -+ 'MD_LEVEL': 'raid1', -+ 'MD_METADATA': '1.2', -+ 'MD_NAME': 'localhost.localdomain:127', -+ 'MD_UUID': '54956eb2:69838759:e2ad4c40:acc92e4b', -+ 'MINOR': '127', -+ 'SUBSYSTEM': 'block', -+ 'SYSTEMD_WANTS': 'mdmonitor.service', -+ 'TAGS': ':systemd:', -+ 'USEC_INITIALIZED': '603606045', -+ 'SYS_NAME': 'md127', -+ 'SYS_PATH': '/sys/devices/virtual/block/md127'} -+ -+ raid_partition = {'DEVLINKS': '/dev/md/127p1 /dev/disk/by-id/md-uuid-54956eb2:69838759:e2ad4c40:acc92e4b-part1 /dev/disk/by-id/md-name-localhost.localdomain:127-part1', -+ 'DEVNAME': '/dev/md127p1', -+ 'DEVPATH': '/devices/virtual/block/md127/md127p1', -+ 'DEVTYPE': 'partition', -+ 'ID_PART_ENTRY_DISK': '9:127', -+ 'ID_PART_ENTRY_NUMBER': '1', -+ 'ID_PART_ENTRY_OFFSET': '2048', -+ 'ID_PART_ENTRY_SCHEME': 'dos', -+ 'ID_PART_ENTRY_SIZE': '2091008', -+ 'ID_PART_ENTRY_TYPE': '0x83', -+ 'ID_PART_ENTRY_UUID': '4eec0361-01', -+ 'MAJOR': '259', -+ 'MD_DEVICES': '2', -+ 'MD_DEVICE_ev_sda_DEV': '/dev/sda', -+ 'MD_DEVICE_ev_sda_ROLE': '0', -+ 'MD_DEVICE_ev_sdb_DEV': '/dev/sdb', -+ 'MD_DEVICE_ev_sdb_ROLE': '1', -+ 'MD_DEVNAME': '127', -+ 'MD_LEVEL': 'raid1', -+ 'MD_METADATA': '1.2', -+ 'MD_NAME': 'localhost.localdomain:127', -+ 'MD_UUID': '54956eb2:69838759:e2ad4c40:acc92e4b', -+ 'MINOR': '2', -+ 'PARTN': '1', -+ 'SUBSYSTEM': 'block', -+ 'SYSTEMD_WANTS': 'mdmonitor.service', -+ 'TAGS': ':systemd:', -+ 'USEC_INITIALIZED': '603714783', -+ 'SYS_NAME': 'md127p1', -+ 'SYS_PATH': '/sys/devices/virtual/block/md127/md127p1'} -+ -+ -+class RaidOnDisk2(): -+ member_name = "sdc" -+ raid_name = "name" -+ raid_node = "md127" -+ metadata_version = "1.2" -+ -+ member_boot = {'DEVLINKS': '/dev/disk/by-id/scsi-0QEMU_QEMU_HARDDISK_drive-scsi0-0-0-4 /dev/disk/by-path/pci-0000:00:11.0-scsi-0:0:0:4', -+ 'DEVNAME': '/dev/sdc', -+ 'DEVPATH': '/devices/pci0000:00/0000:00:11.0/virtio5/host8/target8:0:0/8:0:0:4/block/sdc', -+ 'DEVTYPE': 'disk', -+ 'ID_BUS': 'scsi', -+ 'ID_FS_LABEL': 'localhost.localdomain:name', -+ 'ID_FS_LABEL_ENC': 'localhost.localdomain:name', -+ 'ID_FS_TYPE': 'linux_raid_member', -+ 'ID_FS_USAGE': 'raid', -+ 'ID_FS_UUID': '143d480c-12c3-909f-5476-98a9f94a1c4f', -+ 'ID_FS_UUID_ENC': '143d480c-12c3-909f-5476-98a9f94a1c4f', -+ 'ID_FS_UUID_SUB': '121f2b71-3634-4183-dc9c-08bfceda765c', -+ 'ID_FS_UUID_SUB_ENC': '121f2b71-3634-4183-dc9c-08bfceda765c', -+ 'ID_FS_VERSION': '1.2', -+ 'ID_MODEL': 'QEMU_HARDDISK', -+ 'ID_MODEL_ENC': 'QEMU\\x20HARDDISK\\x20\\x20\\x20', -+ 'ID_PATH': 'pci-0000:00:11.0-scsi-0:0:0:4', -+ 'ID_PATH_TAG': 'pci-0000_00_11_0-scsi-0_0_0_4', -+ 'ID_REVISION': '2.5+', -+ 'ID_SCSI': '1', -+ 'ID_SERIAL': '0QEMU_QEMU_HARDDISK_drive-scsi0-0-0-4', -+ 'ID_SERIAL_SHORT': 'drive-scsi0-0-0-4', -+ 'ID_TYPE': 'disk', -+ 'ID_VENDOR': 'QEMU', -+ 'ID_VENDOR_ENC': 'QEMU\\x20\\x20\\x20\\x20', -+ 'MAJOR': '8', -+ 'MD_DEVICE': 'md127', -+ 'MD_DEVNAME': 'name', -+ 'MD_FOREIGN': 'no', -+ 'MD_STARTED': 'yes', -+ 'MINOR': '32', -+ 'SUBSYSTEM': 'block', -+ 'TAGS': ':systemd:', -+ 'USEC_INITIALIZED': '6109555', -+ 'SYS_NAME': 'sdc', -+ 'SYS_PATH': '/sys/devices/pci0000:00/0000:00:11.0/virtio5/host8/target8:0:0/8:0:0:4/block/sdc'} -+ -+ member_assemble = {'DEVLINKS': '/dev/disk/by-id/scsi-0QEMU_QEMU_HARDDISK_drive-scsi0-0-0-4 /dev/disk/by-path/pci-0000:00:11.0-scsi-0:0:0:4', -+ 'DEVNAME': '/dev/sdc', -+ 'DEVPATH': '/devices/pci0000:00/0000:00:11.0/virtio5/host8/target8:0:0/8:0:0:4/block/sdc', -+ 'DEVTYPE': 'disk', -+ 'ID_BUS': 'scsi', -+ 'ID_FS_LABEL': 'localhost.localdomain:name', -+ 'ID_FS_LABEL_ENC': 'localhost.localdomain:name', -+ 'ID_FS_TYPE': 'linux_raid_member', -+ 'ID_FS_USAGE': 'raid', -+ 'ID_FS_UUID': '143d480c-12c3-909f-5476-98a9f94a1c4f', -+ 'ID_FS_UUID_ENC': '143d480c-12c3-909f-5476-98a9f94a1c4f', -+ 'ID_FS_UUID_SUB': '121f2b71-3634-4183-dc9c-08bfceda765c', -+ 'ID_FS_UUID_SUB_ENC': '121f2b71-3634-4183-dc9c-08bfceda765c', -+ 'ID_FS_VERSION': '1.2', -+ 'ID_MODEL': 'QEMU_HARDDISK', -+ 'ID_MODEL_ENC': 'QEMU\\x20HARDDISK\\x20\\x20\\x20', -+ 'ID_PATH': 'pci-0000:00:11.0-scsi-0:0:0:4', -+ 'ID_PATH_TAG': 'pci-0000_00_11_0-scsi-0_0_0_4', -+ 'ID_REVISION': '2.5+', -+ 'ID_SCSI': '1', -+ 'ID_SERIAL': '0QEMU_QEMU_HARDDISK_drive-scsi0-0-0-4', -+ 'ID_SERIAL_SHORT': 'drive-scsi0-0-0-4', -+ 'ID_TYPE': 'disk', -+ 'ID_VENDOR': 'QEMU', -+ 'ID_VENDOR_ENC': 'QEMU\\x20\\x20\\x20\\x20', -+ 'MAJOR': '8', -+ 'MINOR': '32', -+ 'SUBSYSTEM': 'block', -+ 'TAGS': ':systemd:', -+ 'USEC_INITIALIZED': '6109555', -+ 'SYS_NAME': 'sdc', -+ 'SYS_PATH': '/sys/devices/pci0000:00/0000:00:11.0/virtio5/host8/target8:0:0/8:0:0:4/block/sdc'} -+ -+ raid_device = {'DEVLINKS': '/dev/disk/by-id/md-name-localhost.localdomain:name /dev/disk/by-id/md-uuid-143d480c:12c3909f:547698a9:f94a1c4f /dev/md/name', -+ 'DEVNAME': '/dev/md127', -+ 'DEVPATH': '/devices/virtual/block/md127', -+ 'DEVTYPE': 'disk', -+ 'ID_PART_TABLE_TYPE': 'dos', -+ 'ID_PART_TABLE_UUID': '19e9cb5b', -+ 'MAJOR': '9', -+ 'MD_DEVICES': '2', -+ 'MD_DEVICE_ev_sdc_DEV': '/dev/sdc', -+ 'MD_DEVICE_ev_sdc_ROLE': '0', -+ 'MD_DEVICE_ev_sdd_DEV': '/dev/sdd', -+ 'MD_DEVICE_ev_sdd_ROLE': '1', -+ 'MD_DEVNAME': 'name', -+ 'MD_LEVEL': 'raid1', -+ 'MD_METADATA': '1.2', -+ 'MD_NAME': 'localhost.localdomain:name', -+ 'MD_UUID': '143d480c:12c3909f:547698a9:f94a1c4f', -+ 'MINOR': '127', -+ 'SUBSYSTEM': 'block', -+ 'SYSTEMD_WANTS': 'mdmonitor.service', -+ 'TAGS': ':systemd:', -+ 'USEC_INITIALIZED': '5844744', -+ 'SYS_NAME': 'md127', -+ 'SYS_PATH': '/sys/devices/virtual/block/md127'} -+ -+ raid_partition = {'DEVLINKS': '/dev/disk/by-id/md-uuid-143d480c:12c3909f:547698a9:f94a1c4f-part1 /dev/disk/by-id/md-name-localhost.localdomain:name-part1 /dev/md/name1', -+ 'DEVNAME': '/dev/md127p1', -+ 'DEVPATH': '/devices/virtual/block/md127/md127p1', -+ 'DEVTYPE': 'partition', -+ 'ID_PART_ENTRY_DISK': '9:127', -+ 'ID_PART_ENTRY_NUMBER': '1', -+ 'ID_PART_ENTRY_OFFSET': '2048', -+ 'ID_PART_ENTRY_SCHEME': 'dos', -+ 'ID_PART_ENTRY_SIZE': '2091008', -+ 'ID_PART_ENTRY_TYPE': '0x83', -+ 'ID_PART_ENTRY_UUID': '19e9cb5b-01', -+ 'ID_PART_TABLE_TYPE': 'dos', -+ 'ID_PART_TABLE_UUID': 'ec985633', -+ 'MAJOR': '259', -+ 'MD_DEVICES': '2', -+ 'MD_DEVICE_ev_sdc_DEV': '/dev/sdc', -+ 'MD_DEVICE_ev_sdc_ROLE': '0', -+ 'MD_DEVICE_ev_sdd_DEV': '/dev/sdd', -+ 'MD_DEVICE_ev_sdd_ROLE': '1', -+ 'MD_DEVNAME': 'name', -+ 'MD_LEVEL': 'raid1', -+ 'MD_METADATA': '1.2', -+ 'MD_NAME': 'localhost.localdomain:name', -+ 'MD_UUID': '143d480c:12c3909f:547698a9:f94a1c4f', -+ 'MINOR': '1', -+ 'PARTN': '1', -+ 'SUBSYSTEM': 'block', -+ 'SYSTEMD_WANTS': 'mdmonitor.service', -+ 'TAGS': ':systemd:', -+ 'USEC_INITIALIZED': '5928255', -+ 'SYS_NAME': 'md127p1', -+ 'SYS_PATH': '/sys/devices/virtual/block/md127/md127p1'} -+ -+ -+class RaidOnDisk3(): -+ member_name = "sde" -+ raid_name = "125" -+ raid_node = "md125" -+ metadata_version = "0.9" -+ -+ member_boot = {'DEVLINKS': '/dev/disk/by-id/scsi-0QEMU_QEMU_HARDDISK_drive-scsi0-0-0-1 /dev/disk/by-path/pci-0000:00:11.0-scsi-0:0:0:1', -+ 'DEVNAME': '/dev/sde', -+ 'DEVPATH': '/devices/pci0000:00/0000:00:11.0/virtio5/host8/target8:0:0/8:0:0:1/block/sde', -+ 'DEVTYPE': 'disk', -+ 'ID_BUS': 'scsi', -+ 'ID_FS_TYPE': 'linux_raid_member', -+ 'ID_FS_USAGE': 'raid', -+ 'ID_FS_UUID': 'c4ef60f5-e374-5f70-bfe7-8010bc810f04', -+ 'ID_FS_UUID_ENC': 'c4ef60f5-e374-5f70-bfe7-8010bc810f04', -+ 'ID_FS_VERSION': '0.90.0', -+ 'ID_MODEL': 'QEMU_HARDDISK', -+ 'ID_MODEL_ENC': 'QEMU\\x20HARDDISK\\x20\\x20\\x20', -+ 'ID_PATH': 'pci-0000:00:11.0-scsi-0:0:0:1', -+ 'ID_PATH_TAG': 'pci-0000_00_11_0-scsi-0_0_0_1', -+ 'ID_REVISION': '2.5+', -+ 'ID_SCSI': '1', -+ 'ID_SERIAL': '0QEMU_QEMU_HARDDISK_drive-scsi0-0-0-1', -+ 'ID_SERIAL_SHORT': 'drive-scsi0-0-0-1', -+ 'ID_TYPE': 'disk', -+ 'ID_VENDOR': 'QEMU', -+ 'ID_VENDOR_ENC': 'QEMU\\x20\\x20\\x20\\x20', -+ 'MAJOR': '8', -+ 'MD_DEVICE': 'md125', -+ 'MD_DEVNAME': '125', -+ 'MD_FOREIGN': 'no', -+ 'MD_STARTED': 'unsafe', -+ 'MINOR': '64', -+ 'SUBSYSTEM': 'block', -+ 'SYSTEMD_WANTS': 'mdadm-last-resort@md125.timer', -+ 'TAGS': ':systemd:', -+ 'USEC_INITIALIZED': '5538551', -+ 'SYS_NAME': 'sde', -+ 'SYS_PATH': '/sys/devices/pci0000:00/0000:00:11.0/virtio5/host8/target8:0:0/8:0:0:1/block/sde'} -+ -+ member_assemble = {'DEVLINKS': '/dev/disk/by-id/scsi-0QEMU_QEMU_HARDDISK_drive-scsi0-0-0-1 /dev/disk/by-path/pci-0000:00:11.0-scsi-0:0:0:1', -+ 'DEVNAME': '/dev/sde', -+ 'DEVPATH': '/devices/pci0000:00/0000:00:11.0/virtio5/host8/target8:0:0/8:0:0:1/block/sde', -+ 'DEVTYPE': 'disk', -+ 'ID_BUS': 'scsi', -+ 'ID_FS_TYPE': 'linux_raid_member', -+ 'ID_FS_USAGE': 'raid', -+ 'ID_FS_UUID': 'c4ef60f5-e374-5f70-bfe7-8010bc810f04', -+ 'ID_FS_UUID_ENC': 'c4ef60f5-e374-5f70-bfe7-8010bc810f04', -+ 'ID_FS_VERSION': '0.90.0', -+ 'ID_MODEL': 'QEMU_HARDDISK', -+ 'ID_MODEL_ENC': 'QEMU\\x20HARDDISK\\x20\\x20\\x20', -+ 'ID_PATH': 'pci-0000:00:11.0-scsi-0:0:0:1', -+ 'ID_PATH_TAG': 'pci-0000_00_11_0-scsi-0_0_0_1', -+ 'ID_REVISION': '2.5+', -+ 'ID_SCSI': '1', -+ 'ID_SERIAL': '0QEMU_QEMU_HARDDISK_drive-scsi0-0-0-1', -+ 'ID_SERIAL_SHORT': 'drive-scsi0-0-0-1', -+ 'ID_TYPE': 'disk', -+ 'ID_VENDOR': 'QEMU', -+ 'ID_VENDOR_ENC': 'QEMU\\x20\\x20\\x20\\x20', -+ 'MAJOR': '8', -+ 'MINOR': '64', -+ 'SUBSYSTEM': 'block', -+ 'TAGS': ':systemd:', -+ 'USEC_INITIALIZED': '5538551', -+ 'SYS_NAME': 'sde', -+ 'SYS_PATH': '/sys/devices/pci0000:00/0000:00:11.0/virtio5/host8/target8:0:0/8:0:0:1/block/sde'} -+ -+ raid_device = {'DEVLINKS': '/dev/md/125 /dev/disk/by-id/md-uuid-c4ef60f5:e3745f70:bfe78010:bc810f04', -+ 'DEVNAME': '/dev/md125', -+ 'DEVPATH': '/devices/virtual/block/md125', -+ 'DEVTYPE': 'disk', -+ 'ID_PART_TABLE_TYPE': 'dos', -+ 'ID_PART_TABLE_UUID': 'e74877cd', -+ 'MAJOR': '9', -+ 'MD_DEVICES': '2', -+ 'MD_DEVICE_ev_sde_DEV': '/dev/sde', -+ 'MD_DEVICE_ev_sde_ROLE': '0', -+ 'MD_DEVICE_ev_sdf_DEV': '/dev/sdf', -+ 'MD_DEVICE_ev_sdf_ROLE': '1', -+ 'MD_DEVNAME': '125', -+ 'MD_LEVEL': 'raid1', -+ 'MD_METADATA': '0.90', -+ 'MD_UUID': 'c4ef60f5:e3745f70:bfe78010:bc810f04', -+ 'MINOR': '125', -+ 'SUBSYSTEM': 'block', -+ 'SYSTEMD_WANTS': 'mdmonitor.service', -+ 'TAGS': ':systemd:', -+ 'USEC_INITIALIZED': '5786380', -+ 'SYS_NAME': 'md125', -+ 'SYS_PATH': '/sys/devices/virtual/block/md125'} -+ -+ raid_partition = {'DEVLINKS': '/dev/md/125p1 /dev/disk/by-id/md-uuid-c4ef60f5:e3745f70:bfe78010:bc810f04-part1', -+ 'DEVNAME': '/dev/md125p1', -+ 'DEVPATH': '/devices/virtual/block/md125/md125p1', -+ 'DEVTYPE': 'partition', -+ 'ID_PART_ENTRY_DISK': '9:125', -+ 'ID_PART_ENTRY_NUMBER': '1', -+ 'ID_PART_ENTRY_OFFSET': '2048', -+ 'ID_PART_ENTRY_SCHEME': 'dos', -+ 'ID_PART_ENTRY_SIZE': '2094976', -+ 'ID_PART_ENTRY_TYPE': '0x83', -+ 'ID_PART_ENTRY_UUID': 'e74877cd-01', -+ 'MAJOR': '259', -+ 'MD_DEVICES': '2', -+ 'MD_DEVICE_ev_sde_DEV': '/dev/sde', -+ 'MD_DEVICE_ev_sde_ROLE': '0', -+ 'MD_DEVICE_ev_sdf_DEV': '/dev/sdf', -+ 'MD_DEVICE_ev_sdf_ROLE': '1', -+ 'MD_DEVNAME': '125', -+ 'MD_LEVEL': 'raid1', -+ 'MD_METADATA': '0.90', -+ 'MD_UUID': 'c4ef60f5:e3745f70:bfe78010:bc810f04', -+ 'MINOR': '3', -+ 'PARTN': '1', -+ 'SUBSYSTEM': 'block', -+ 'SYSTEMD_WANTS': 'mdmonitor.service', -+ 'TAGS': ':systemd:', -+ 'USEC_INITIALIZED': '8808457', -+ 'SYS_NAME': 'md125p1', -+ 'SYS_PATH': '/sys/devices/virtual/block/md125/md125p1'} -+ -+ -+class RaidOnPartition1(): -+ member_name = "sdh3" -+ raid_name = "122" -+ raid_node = "md122" -+ metadata_version = "1.2" -+ -+ member_boot = {'DEVLINKS': '/dev/disk/by-path/pci-0000:00:07.0-scsi-0:0:2:0-part3 /dev/disk/by-id/scsi-0QEMU_QEMU_HARDDISK_drive-scsi1-0-2-part3 /dev/disk/by-partuuid/73eb11a9-03', -+ 'DEVNAME': '/dev/sdh3', -+ 'DEVPATH': '/devices/pci0000:00/0000:00:07.0/host9/target9:0:2/9:0:2:0/block/sdh/sdh3', -+ 'DEVTYPE': 'partition', -+ 'ID_BUS': 'scsi', -+ 'ID_FS_LABEL': 'localhost.localdomain:122', -+ 'ID_FS_LABEL_ENC': 'localhost.localdomain:122', -+ 'ID_FS_TYPE': 'linux_raid_member', -+ 'ID_FS_USAGE': 'raid', -+ 'ID_FS_UUID': '0628d995-eb60-ebd1-a767-51730b16f212', -+ 'ID_FS_UUID_ENC': '0628d995-eb60-ebd1-a767-51730b16f212', -+ 'ID_FS_UUID_SUB': 'b301779b-f759-ad7d-5324-b38d4b6d944d', -+ 'ID_FS_UUID_SUB_ENC': 'b301779b-f759-ad7d-5324-b38d4b6d944d', -+ 'ID_FS_VERSION': '1.2', -+ 'ID_MODEL': 'QEMU_HARDDISK', -+ 'ID_MODEL_ENC': 'QEMU\\x20HARDDISK\\x20\\x20\\x20', -+ 'ID_PART_ENTRY_DISK': '8:112', -+ 'ID_PART_ENTRY_NUMBER': '3', -+ 'ID_PART_ENTRY_OFFSET': '411648', -+ 'ID_PART_ENTRY_SCHEME': 'dos', -+ 'ID_PART_ENTRY_SIZE': '204800', -+ 'ID_PART_ENTRY_TYPE': '0x83', -+ 'ID_PART_ENTRY_UUID': '73eb11a9-03', -+ 'ID_PART_TABLE_TYPE': 'dos', -+ 'ID_PART_TABLE_UUID': '73eb11a9', -+ 'ID_PATH': 'pci-0000:00:07.0-scsi-0:0:2:0', -+ 'ID_PATH_TAG': 'pci-0000_00_07_0-scsi-0_0_2_0', -+ 'ID_REVISION': '2.5+', -+ 'ID_SCSI': '1', -+ 'ID_SERIAL': '0QEMU_QEMU_HARDDISK_drive-scsi1-0-2', -+ 'ID_SERIAL_SHORT': 'drive-scsi1-0-2', -+ 'ID_TYPE': 'disk', -+ 'ID_VENDOR': 'QEMU', -+ 'ID_VENDOR_ENC': 'QEMU\\x20\\x20\\x20\\x20', -+ 'MAJOR': '8', -+ 'MD_DEVICE': 'md122', -+ 'MD_DEVNAME': '122', -+ 'MD_FOREIGN': 'no', -+ 'MD_STARTED': 'yes', -+ 'MINOR': '115', -+ 'PARTN': '3', -+ 'SUBSYSTEM': 'block', -+ 'TAGS': ':systemd:', -+ 'USEC_INITIALIZED': '8920462', -+ 'SYS_NAME': 'sdh3', -+ 'SYS_PATH': '/sys/devices/pci0000:00/0000:00:07.0/host9/target9:0:2/9:0:2:0/block/sdh/sdh3'} -+ -+ member_assemble = {'DEVLINKS': '/dev/disk/by-path/pci-0000:00:07.0-scsi-0:0:2:0-part3 /dev/disk/by-id/scsi-0QEMU_QEMU_HARDDISK_drive-scsi1-0-2-part3 /dev/disk/by-partuuid/73eb11a9-03', -+ 'DEVNAME': '/dev/sdh3', -+ 'DEVPATH': '/devices/pci0000:00/0000:00:07.0/host9/target9:0:2/9:0:2:0/block/sdh/sdh3', -+ 'DEVTYPE': 'partition', -+ 'ID_BUS': 'scsi', -+ 'ID_FS_LABEL': 'localhost.localdomain:122', -+ 'ID_FS_LABEL_ENC': 'localhost.localdomain:122', -+ 'ID_FS_TYPE': 'linux_raid_member', -+ 'ID_FS_USAGE': 'raid', -+ 'ID_FS_UUID': '0628d995-eb60-ebd1-a767-51730b16f212', -+ 'ID_FS_UUID_ENC': '0628d995-eb60-ebd1-a767-51730b16f212', -+ 'ID_FS_UUID_SUB': 'b301779b-f759-ad7d-5324-b38d4b6d944d', -+ 'ID_FS_UUID_SUB_ENC': 'b301779b-f759-ad7d-5324-b38d4b6d944d', -+ 'ID_FS_VERSION': '1.2', -+ 'ID_MODEL': 'QEMU_HARDDISK', -+ 'ID_MODEL_ENC': 'QEMU\\x20HARDDISK\\x20\\x20\\x20', -+ 'ID_PART_ENTRY_DISK': '8:112', -+ 'ID_PART_ENTRY_NUMBER': '3', -+ 'ID_PART_ENTRY_OFFSET': '411648', -+ 'ID_PART_ENTRY_SCHEME': 'dos', -+ 'ID_PART_ENTRY_SIZE': '204800', -+ 'ID_PART_ENTRY_TYPE': '0x83', -+ 'ID_PART_ENTRY_UUID': '73eb11a9-03', -+ 'ID_PART_TABLE_TYPE': 'dos', -+ 'ID_PART_TABLE_UUID': '73eb11a9', -+ 'ID_PATH': 'pci-0000:00:07.0-scsi-0:0:2:0', -+ 'ID_PATH_TAG': 'pci-0000_00_07_0-scsi-0_0_2_0', -+ 'ID_REVISION': '2.5+', -+ 'ID_SCSI': '1', -+ 'ID_SERIAL': '0QEMU_QEMU_HARDDISK_drive-scsi1-0-2', -+ 'ID_SERIAL_SHORT': 'drive-scsi1-0-2', -+ 'ID_TYPE': 'disk', -+ 'ID_VENDOR': 'QEMU', -+ 'ID_VENDOR_ENC': 'QEMU\\x20\\x20\\x20\\x20', -+ 'MAJOR': '8', -+ 'MINOR': '115', -+ 'PARTN': '3', -+ 'SUBSYSTEM': 'block', -+ 'TAGS': ':systemd:', -+ 'USEC_INITIALIZED': '8920462', -+ 'SYS_NAME': 'sdh3', -+ 'SYS_PATH': '/sys/devices/pci0000:00/0000:00:07.0/host9/target9:0:2/9:0:2:0/block/sdh/sdh3'} -+ -+ raid_device = {'DEVLINKS': '/dev/disk/by-id/md-uuid-0628d995:eb60ebd1:a7675173:0b16f212 /dev/disk/by-id/md-name-localhost.localdomain:122 /dev/md/122', -+ 'DEVNAME': '/dev/md122', -+ 'DEVPATH': '/devices/virtual/block/md122', -+ 'DEVTYPE': 'disk', -+ 'ID_PART_TABLE_TYPE': 'dos', -+ 'ID_PART_TABLE_UUID': '6dc80b3b', -+ 'MAJOR': '9', -+ 'MD_DEVICES': '2', -+ 'MD_DEVICE_ev_sdh3_DEV': '/dev/sdh3', -+ 'MD_DEVICE_ev_sdh3_ROLE': '0', -+ 'MD_DEVICE_ev_sdh5_DEV': '/dev/sdh5', -+ 'MD_DEVICE_ev_sdh5_ROLE': '1', -+ 'MD_DEVNAME': '122', -+ 'MD_LEVEL': 'raid1', -+ 'MD_METADATA': '1.2', -+ 'MD_NAME': 'localhost.localdomain:122', -+ 'MD_UUID': '0628d995:eb60ebd1:a7675173:0b16f212', -+ 'MINOR': '122', -+ 'SUBSYSTEM': 'block', -+ 'SYSTEMD_WANTS': 'mdmonitor.service', -+ 'TAGS': ':systemd:', -+ 'USEC_INITIALIZED': '8770105', -+ 'SYS_NAME': 'md122', -+ 'SYS_PATH': '/sys/devices/virtual/block/md122'} -+ -+ raid_partition = {'DEVLINKS': '/dev/disk/by-id/md-uuid-0628d995:eb60ebd1:a7675173:0b16f212-part1 /dev/disk/by-id/md-name-localhost.localdomain:122-part1 /dev/md/122p1', -+ 'DEVNAME': '/dev/md122p1', -+ 'DEVPATH': '/devices/virtual/block/md122/md122p1', -+ 'DEVTYPE': 'partition', -+ 'ID_PART_ENTRY_DISK': '9:122', -+ 'ID_PART_ENTRY_NUMBER': '1', -+ 'ID_PART_ENTRY_OFFSET': '2048', -+ 'ID_PART_ENTRY_SCHEME': 'dos', -+ 'ID_PART_ENTRY_SIZE': '200704', -+ 'ID_PART_ENTRY_TYPE': '0x83', -+ 'ID_PART_ENTRY_UUID': '6dc80b3b-01', -+ 'MAJOR': '259', -+ 'MD_DEVICES': '2', -+ 'MD_DEVICE_ev_sdh3_DEV': '/dev/sdh3', -+ 'MD_DEVICE_ev_sdh3_ROLE': '0', -+ 'MD_DEVICE_ev_sdh5_DEV': '/dev/sdh5', -+ 'MD_DEVICE_ev_sdh5_ROLE': '1', -+ 'MD_DEVNAME': '122', -+ 'MD_LEVEL': 'raid1', -+ 'MD_METADATA': '1.2', -+ 'MD_NAME': 'localhost.localdomain:122', -+ 'MD_UUID': '0628d995:eb60ebd1:a7675173:0b16f212', -+ 'MINOR': '6', -+ 'PARTN': '1', -+ 'SUBSYSTEM': 'block', -+ 'SYSTEMD_WANTS': 'mdmonitor.service', -+ 'TAGS': ':systemd:', -+ 'USEC_INITIALIZED': '9003885', -+ 'SYS_NAME': 'md122p1', -+ 'SYS_PATH': '/sys/devices/virtual/block/md122/md122p1'} -+ -+ -+class RaidOnPartition2(): -+ member_name = "sdh1" -+ raid_name = "123" -+ raid_node = "md123" -+ metadata_version = "0.9" -+ -+ member_boot = {'DEVLINKS': '/dev/disk/by-path/pci-0000:00:07.0-scsi-0:0:2:0-part1 /dev/disk/by-id/scsi-0QEMU_QEMU_HARDDISK_drive-scsi1-0-2-part1 /dev/disk/by-partuuid/73eb11a9-01', -+ 'DEVNAME': '/dev/sdh1', -+ 'DEVPATH': '/devices/pci0000:00/0000:00:07.0/host9/target9:0:2/9:0:2:0/block/sdh/sdh1', -+ 'DEVTYPE': 'partition', -+ 'ID_BUS': 'scsi', -+ 'ID_FS_TYPE': 'linux_raid_member', -+ 'ID_FS_USAGE': 'raid', -+ 'ID_FS_UUID': '335b35e0-f1af-8e86-bfe7-8010bc810f04', -+ 'ID_FS_UUID_ENC': '335b35e0-f1af-8e86-bfe7-8010bc810f04', -+ 'ID_FS_VERSION': '0.90.0', -+ 'ID_MODEL': 'QEMU_HARDDISK', -+ 'ID_MODEL_ENC': 'QEMU\\x20HARDDISK\\x20\\x20\\x20', -+ 'ID_PART_ENTRY_DISK': '8:112', -+ 'ID_PART_ENTRY_NUMBER': '1', -+ 'ID_PART_ENTRY_OFFSET': '2048', -+ 'ID_PART_ENTRY_SCHEME': 'dos', -+ 'ID_PART_ENTRY_SIZE': '204800', -+ 'ID_PART_ENTRY_TYPE': '0x83', -+ 'ID_PART_ENTRY_UUID': '73eb11a9-01', -+ 'ID_PART_TABLE_TYPE': 'dos', -+ 'ID_PART_TABLE_UUID': '73eb11a9', -+ 'ID_PATH': 'pci-0000:00:07.0-scsi-0:0:2:0', -+ 'ID_PATH_TAG': 'pci-0000_00_07_0-scsi-0_0_2_0', -+ 'ID_REVISION': '2.5+', -+ 'ID_SCSI': '1', -+ 'ID_SERIAL': '0QEMU_QEMU_HARDDISK_drive-scsi1-0-2', -+ 'ID_SERIAL_SHORT': 'drive-scsi1-0-2', -+ 'ID_TYPE': 'disk', -+ 'ID_VENDOR': 'QEMU', -+ 'ID_VENDOR_ENC': 'QEMU\\x20\\x20\\x20\\x20', -+ 'MAJOR': '8', -+ 'MD_DEVICE': 'md123', -+ 'MD_DEVNAME': '123', -+ 'MD_FOREIGN': 'no', -+ 'MD_STARTED': 'unsafe', -+ 'MINOR': '113', -+ 'PARTN': '1', -+ 'SUBSYSTEM': 'block', -+ 'SYSTEMD_WANTS': 'mdadm-last-resort@md123.timer', -+ 'TAGS': ':systemd:', -+ 'USEC_INITIALIZED': '8778733', -+ 'SYS_NAME': 'sdh1', -+ 'SYS_PATH': '/sys/devices/pci0000:00/0000:00:07.0/host9/target9:0:2/9:0:2:0/block/sdh/sdh1'} -+ -+ member_assemble = {'DEVLINKS': '/dev/disk/by-path/pci-0000:00:07.0-scsi-0:0:2:0-part1 /dev/disk/by-id/scsi-0QEMU_QEMU_HARDDISK_drive-scsi1-0-2-part1 /dev/disk/by-partuuid/73eb11a9-01', -+ 'DEVNAME': '/dev/sdh1', -+ 'DEVPATH': '/devices/pci0000:00/0000:00:07.0/host9/target9:0:2/9:0:2:0/block/sdh/sdh1', -+ 'DEVTYPE': 'partition', -+ 'ID_BUS': 'scsi', -+ 'ID_FS_TYPE': 'linux_raid_member', -+ 'ID_FS_USAGE': 'raid', -+ 'ID_FS_UUID': '335b35e0-f1af-8e86-bfe7-8010bc810f04', -+ 'ID_FS_UUID_ENC': '335b35e0-f1af-8e86-bfe7-8010bc810f04', -+ 'ID_FS_VERSION': '0.90.0', -+ 'ID_MODEL': 'QEMU_HARDDISK', -+ 'ID_MODEL_ENC': 'QEMU\\x20HARDDISK\\x20\\x20\\x20', -+ 'ID_PART_ENTRY_DISK': '8:112', -+ 'ID_PART_ENTRY_NUMBER': '1', -+ 'ID_PART_ENTRY_OFFSET': '2048', -+ 'ID_PART_ENTRY_SCHEME': 'dos', -+ 'ID_PART_ENTRY_SIZE': '204800', -+ 'ID_PART_ENTRY_TYPE': '0x83', -+ 'ID_PART_ENTRY_UUID': '73eb11a9-01', -+ 'ID_PART_TABLE_TYPE': 'dos', -+ 'ID_PART_TABLE_UUID': '73eb11a9', -+ 'ID_PATH': 'pci-0000:00:07.0-scsi-0:0:2:0', -+ 'ID_PATH_TAG': 'pci-0000_00_07_0-scsi-0_0_2_0', -+ 'ID_REVISION': '2.5+', -+ 'ID_SCSI': '1', -+ 'ID_SERIAL': '0QEMU_QEMU_HARDDISK_drive-scsi1-0-2', -+ 'ID_SERIAL_SHORT': 'drive-scsi1-0-2', -+ 'ID_TYPE': 'disk', -+ 'ID_VENDOR': 'QEMU', -+ 'ID_VENDOR_ENC': 'QEMU\\x20\\x20\\x20\\x20', -+ 'MAJOR': '8', -+ 'MINOR': '113', -+ 'PARTN': '1', -+ 'SUBSYSTEM': 'block', -+ 'TAGS': ':systemd:', -+ 'UDISKS_MD_MEMBER_DEVICES': '2', -+ 'UDISKS_MD_MEMBER_EVENTS': '18', -+ 'UDISKS_MD_MEMBER_LEVEL': 'raid1', -+ 'UDISKS_MD_MEMBER_UPDATE_TIME': '1597143914', -+ 'UDISKS_MD_MEMBER_UUID': '335b35e0:f1af8e86:bfe78010:bc810f04', -+ 'USEC_INITIALIZED': '8778733', -+ 'SYS_NAME': 'sdh1', -+ 'SYS_PATH': '/sys/devices/pci0000:00/0000:00:07.0/host9/target9:0:2/9:0:2:0/block/sdh/sdh1'} -+ -+ raid_device = {'DEVLINKS': '/dev/md/123 /dev/disk/by-id/md-uuid-335b35e0:f1af8e86:bfe78010:bc810f04', -+ 'DEVNAME': '/dev/md123', -+ 'DEVPATH': '/devices/virtual/block/md123', -+ 'DEVTYPE': 'disk', -+ 'ID_PART_TABLE_TYPE': 'dos', -+ 'ID_PART_TABLE_UUID': '653f84c8', -+ 'MAJOR': '9', -+ 'MD_DEVICES': '2', -+ 'MD_DEVICE_ev_sdh1_DEV': '/dev/sdh1', -+ 'MD_DEVICE_ev_sdh1_ROLE': '0', -+ 'MD_DEVICE_ev_sdh2_DEV': '/dev/sdh2', -+ 'MD_DEVICE_ev_sdh2_ROLE': '1', -+ 'MD_DEVNAME': '123', -+ 'MD_LEVEL': 'raid1', -+ 'MD_METADATA': '0.90', -+ 'MD_UUID': '335b35e0:f1af8e86:bfe78010:bc810f04', -+ 'MINOR': '123', -+ 'SUBSYSTEM': 'block', -+ 'SYSTEMD_WANTS': 'mdmonitor.service', -+ 'TAGS': ':systemd:', -+ 'USEC_INITIALIZED': '8760382', -+ 'SYS_NAME': 'md123', -+ 'SYS_PATH': '/sys/devices/virtual/block/md123'} -+ -+ raid_partition = {'DEVLINKS': '/dev/disk/by-id/md-uuid-335b35e0:f1af8e86:bfe78010:bc810f04-part1 /dev/md/123p1', -+ 'DEVNAME': '/dev/md123p1', -+ 'DEVPATH': '/devices/virtual/block/md123/md123p1', -+ 'DEVTYPE': 'partition', -+ 'ID_PART_ENTRY_DISK': '9:123', -+ 'ID_PART_ENTRY_NUMBER': '1', -+ 'ID_PART_ENTRY_OFFSET': '2048', -+ 'ID_PART_ENTRY_SCHEME': 'dos', -+ 'ID_PART_ENTRY_SIZE': '202624', -+ 'ID_PART_ENTRY_TYPE': '0x83', -+ 'ID_PART_ENTRY_UUID': '653f84c8-01', -+ 'MAJOR': '259', -+ 'MD_DEVICES': '2', -+ 'MD_DEVICE_ev_sdh1_DEV': '/dev/sdh1', -+ 'MD_DEVICE_ev_sdh1_ROLE': '0', -+ 'MD_DEVICE_ev_sdh2_DEV': '/dev/sdh2', -+ 'MD_DEVICE_ev_sdh2_ROLE': '1', -+ 'MD_DEVNAME': '123', -+ 'MD_LEVEL': 'raid1', -+ 'MD_METADATA': '0.90', -+ 'MD_UUID': '335b35e0:f1af8e86:bfe78010:bc810f04', -+ 'MINOR': '5', -+ 'PARTN': '1', -+ 'SUBSYSTEM': 'block', -+ 'SYSTEMD_WANTS': 'mdmonitor.service', -+ 'TAGS': ':systemd:', -+ 'USEC_INITIALIZED': '8952876', -+ 'SYS_NAME': 'md123p1', -+ 'SYS_PATH': '/sys/devices/virtual/block/md123/md123p1'} -diff --git a/tests/udev_test.py b/tests/udev_test.py -index 653eeb6d..d30a647b 100644 ---- a/tests/udev_test.py -+++ b/tests/udev_test.py -@@ -2,6 +2,8 @@ - import unittest - import mock - -+from udev_data import raid_data -+ - - class UdevTest(unittest.TestCase): - -@@ -77,3 +79,47 @@ class UdevTest(unittest.TestCase): - # Normal MD RAID (w/ at least one non-disk member) - device_get_slaves.side_effect = lambda info: mixed_parents if info['SYS_PATH'] == mock.sentinel.md_path else list() - self.assertFalse(blivet.udev.device_is_disk(info)) -+ -+ -+class UdevGetNameRaidTest(unittest.TestCase): -+ -+ def _test_raid_name(self, udev_data): -+ import blivet.udev -+ -+ # members don't have the device_get_sysfs_path(info) + "/md" folder -+ with mock.patch("blivet.udev.device_is_md", return_value=False): -+ member_name = blivet.udev.device_get_name(udev_data.member_boot) -+ self.assertEqual(member_name, udev_data.member_name) -+ -+ member_name = blivet.udev.device_get_name(udev_data.member_assemble) -+ self.assertEqual(member_name, udev_data.member_name) -+ -+ with mock.patch("blivet.udev.device_is_md", return_value=True): -+ raid_name = blivet.udev.device_get_name(udev_data.raid_device) -+ self.assertEqual(raid_name, udev_data.raid_name) -+ -+ # partitions also don't have the device_get_sysfs_path(info) + "/md" folder -+ with mock.patch("blivet.udev.device_is_md", return_value=False): -+ part_name = blivet.udev.device_get_name(udev_data.raid_partition) -+ expected_name = udev_data.raid_name + "p1" if udev_data.raid_name[-1].isdigit() else udev_data.raid_name + "1" -+ self.assertEqual(part_name, expected_name) -+ -+ def test_raid_name_on_disk_no_name(self): -+ data = raid_data.RaidOnDisk1() -+ self._test_raid_name(data) -+ -+ def test_raid_name_on_disk__with_name(self): -+ data = raid_data.RaidOnDisk2() -+ self._test_raid_name(data) -+ -+ def test_raid_name_on_disk_old_metadata(self): -+ data = raid_data.RaidOnDisk3() -+ self._test_raid_name(data) -+ -+ def test_raid_name_on_part_no_name(self): -+ data = raid_data.RaidOnPartition1() -+ self._test_raid_name(data) -+ -+ def test_raid_name_on_part_old_metadata(self): -+ data = raid_data.RaidOnPartition2() -+ self._test_raid_name(data) --- -2.25.4 - diff --git a/SOURCES/0011-Fix-ignoring-disk-devices-with-parents-or-children.patch b/SOURCES/0011-Fix-ignoring-disk-devices-with-parents-or-children.patch deleted file mode 100644 index 6ce0a64..0000000 --- a/SOURCES/0011-Fix-ignoring-disk-devices-with-parents-or-children.patch +++ /dev/null @@ -1,269 +0,0 @@ -From f19140993e94be9e58c8a01c18f1907792f59927 Mon Sep 17 00:00:00 2001 -From: Vojtech Trefny -Date: Wed, 5 Aug 2020 13:44:38 +0200 -Subject: [PATCH] Fix ignoring disk devices with parents or children - -For disk-like devices like multipath we should allow to ignore -these by simply ignoring the mpath device or by ignoring all of its -drives. - -- when ignoring the "mpatha" device we should also ignore "sda" and -"sdb" -- when ignoring both "sda" and "sdb" we should also ignore "mpatha" -- when ignoring only "sda" we should not ignore "mpatha" (we don't -want to deal with an "incomplete" multipath device in the tree) - -This is consistent with the existing behaviour when using exclusive -disks (or "ignoredisks --only-use" in kickstart). - -Resolves: rhbz#1866243 ---- - blivet/devicetree.py | 51 ++++++++----- - tests/devicetree_test.py | 157 ++++++++++++++++++++++++++++----------- - 2 files changed, 146 insertions(+), 62 deletions(-) - -diff --git a/blivet/devicetree.py b/blivet/devicetree.py -index 5cc360e1..2afb0d0e 100644 ---- a/blivet/devicetree.py -+++ b/blivet/devicetree.py -@@ -907,31 +907,48 @@ class DeviceTreeBase(object): - hidden.add_hook(new=False) - lvm.lvm_cc_removeFilterRejectRegexp(hidden.name) - -+ def _disk_in_taglist(self, disk, taglist): -+ # Taglist is a list containing mix of disk names and tags into which disk may belong. -+ # Check if it does. Raise ValueError if unknown tag is encountered. -+ if disk.name in taglist: -+ return True -+ tags = [t[1:] for t in taglist if t.startswith("@")] -+ for tag in tags: -+ if tag not in Tags.__members__: -+ raise ValueError("unknown ignoredisk tag '@%s' encountered" % tag) -+ if Tags(tag) in disk.tags: -+ return True -+ return False -+ - def _is_ignored_disk(self, disk): - """ Checks config for lists of exclusive and ignored disks - and returns if the given one should be ignored - """ -- -- def disk_in_taglist(disk, taglist): -- # Taglist is a list containing mix of disk names and tags into which disk may belong. -- # Check if it does. Raise ValueError if unknown tag is encountered. -- if disk.name in taglist: -- return True -- tags = [t[1:] for t in taglist if t.startswith("@")] -- for tag in tags: -- if tag not in Tags.__members__: -- raise ValueError("unknown ignoredisk tag '@%s' encountered" % tag) -- if Tags(tag) in disk.tags: -- return True -- return False -- -- return ((self.ignored_disks and disk_in_taglist(disk, self.ignored_disks)) or -- (self.exclusive_disks and not disk_in_taglist(disk, self.exclusive_disks))) -+ return ((self.ignored_disks and self._disk_in_taglist(disk, self.ignored_disks)) or -+ (self.exclusive_disks and not self._disk_in_taglist(disk, self.exclusive_disks))) - - def _hide_ignored_disks(self): - # hide any subtrees that begin with an ignored disk - for disk in [d for d in self._devices if d.is_disk]: -- if self._is_ignored_disk(disk): -+ is_ignored = self.ignored_disks and self._disk_in_taglist(disk, self.ignored_disks) -+ is_exclusive = self.exclusive_disks and self._disk_in_taglist(disk, self.exclusive_disks) -+ -+ if is_ignored: -+ if len(disk.children) == 1: -+ if not all(self._is_ignored_disk(d) for d in disk.children[0].parents): -+ raise DeviceTreeError("Including only a subset of raid/multipath member disks is not allowed.") -+ -+ # and also children like fwraid or mpath -+ self.hide(disk.children[0]) -+ -+ # this disk is ignored: ignore it and all it's potential parents -+ for p in disk.parents: -+ self.hide(p) -+ -+ # and finally hide the disk itself -+ self.hide(disk) -+ -+ if self.exclusive_disks and not is_exclusive: - ignored = True - # If the filter allows all members of a fwraid or mpath, the - # fwraid or mpath itself is implicitly allowed as well. I don't -diff --git a/tests/devicetree_test.py b/tests/devicetree_test.py -index a8f369cf..6032e7f6 100644 ---- a/tests/devicetree_test.py -+++ b/tests/devicetree_test.py -@@ -370,51 +370,6 @@ class DeviceTreeTestCase(unittest.TestCase): - 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 test_get_related_disks(self): - tree = DeviceTree() - -@@ -447,3 +402,115 @@ class DeviceTreeTestCase(unittest.TestCase): - tree.unhide(sda) - self.assertEqual(tree.get_related_disks(sda), set([sda, sdb])) - self.assertEqual(tree.get_related_disks(sdb), set([sda, sdb])) -+ -+ -+class DeviceTreeIgnoredExclusiveMultipathTestCase(unittest.TestCase): -+ -+ def setUp(self): -+ self.tree = DeviceTree() -+ -+ self.sda = DiskDevice("sda") -+ self.sdb = DiskDevice("sdb") -+ self.sdc = DiskDevice("sdc") -+ -+ self.tree._add_device(self.sda) -+ self.tree._add_device(self.sdb) -+ self.tree._add_device(self.sdc) -+ -+ self.assertTrue(self.sda in self.tree.devices) -+ self.assertTrue(self.sdb in self.tree.devices) -+ self.assertTrue(self.sdc in self.tree.devices) -+ -+ # now test exclusive_disks special cases for multipath -+ self.sda.format = get_format("multipath_member", exists=True) -+ self.sdb.format = get_format("multipath_member", exists=True) -+ self.sdc.format = get_format("multipath_member", exists=True) -+ self.mpatha = MultipathDevice("mpatha", parents=[self.sda, self.sdb, self.sdc]) -+ self.tree._add_device(self.mpatha) -+ -+ def test_exclusive_disks_multipath_1(self): -+ # multipath is exclusive -> all disks should be exclusive -+ self.tree.ignored_disks = [] -+ self.tree.exclusive_disks = ["mpatha"] -+ -+ with patch.object(self.tree, "hide") as hide: -+ self.tree._hide_ignored_disks() -+ self.assertFalse(hide.called) -+ -+ self.tree._hide_ignored_disks() -+ self.assertTrue(self.sda in self.tree.devices) -+ self.assertTrue(self.sdb in self.tree.devices) -+ self.assertTrue(self.sdc in self.tree.devices) -+ self.assertTrue(self.mpatha in self.tree.devices) -+ -+ def test_exclusive_disks_multipath_2(self): -+ # all disks exclusive -> mpath should also be exclusive -+ self.tree.exclusive_disks = ["sda", "sdb", "sdc"] -+ with patch.object(self.tree, "hide") as hide: -+ self.tree._hide_ignored_disks() -+ self.assertFalse(hide.called) -+ -+ self.tree._hide_ignored_disks() -+ self.assertTrue(self.sda in self.tree.devices) -+ self.assertTrue(self.sdb in self.tree.devices) -+ self.assertTrue(self.sdc in self.tree.devices) -+ self.assertTrue(self.mpatha in self.tree.devices) -+ -+ def test_exclusive_disks_multipath_3(self): -+ # some disks exclusive -> mpath should be hidden -+ self.tree.exclusive_disks = ["sda", "sdb"] -+ with patch.object(self.tree, "hide") as hide: -+ self.tree._hide_ignored_disks() -+ hide.assert_any_call(self.mpatha) -+ hide.assert_any_call(self.sdc) -+ -+ # verify that hide works as expected -+ self.tree._hide_ignored_disks() -+ self.assertTrue(self.sda in self.tree.devices) -+ self.assertTrue(self.sdb in self.tree.devices) -+ self.assertFalse(self.sdc in self.tree.devices) -+ self.assertFalse(self.mpatha in self.tree.devices) -+ -+ def test_ignored_disks_multipath_1(self): -+ # mpatha ignored -> disks should be hidden -+ self.tree.ignored_disks = ["mpatha"] -+ self.tree.exclusive_disks = [] -+ -+ with patch.object(self.tree, "hide") as hide: -+ self.tree._hide_ignored_disks() -+ hide.assert_any_call(self.mpatha) -+ hide.assert_any_call(self.sda) -+ hide.assert_any_call(self.sdb) -+ hide.assert_any_call(self.sdc) -+ -+ self.tree._hide_ignored_disks() -+ self.assertFalse(self.sda in self.tree.devices) -+ self.assertFalse(self.sdb in self.tree.devices) -+ self.assertFalse(self.sdc in self.tree.devices) -+ self.assertFalse(self.mpatha in self.tree.devices) -+ -+ def test_ignored_disks_multipath_2(self): -+ # all disks ignored -> mpath should be hidden -+ self.tree.ignored_disks = ["sda", "sdb", "sdc"] -+ self.tree.exclusive_disks = [] -+ -+ with patch.object(self.tree, "hide") as hide: -+ self.tree._hide_ignored_disks() -+ hide.assert_any_call(self.mpatha) -+ hide.assert_any_call(self.sda) -+ hide.assert_any_call(self.sdb) -+ hide.assert_any_call(self.sdc) -+ -+ self.tree._hide_ignored_disks() -+ self.assertFalse(self.sda in self.tree.devices) -+ self.assertFalse(self.sdb in self.tree.devices) -+ self.assertFalse(self.sdc in self.tree.devices) -+ self.assertFalse(self.mpatha in self.tree.devices) -+ -+ def test_ignored_disks_multipath_3(self): -+ # some disks ignored -> error -+ self.tree.ignored_disks = ["sda", "sdb"] -+ self.tree.exclusive_disks = [] -+ -+ with self.assertRaises(DeviceTreeError): -+ self.tree._hide_ignored_disks() --- -2.25.4 - diff --git a/SOURCES/0012-xfs-grow-support.patch b/SOURCES/0012-xfs-grow-support.patch deleted file mode 100644 index 1607c51..0000000 --- a/SOURCES/0012-xfs-grow-support.patch +++ /dev/null @@ -1,459 +0,0 @@ -From 433d863cd8a57e5fc30948ff905e6a477ed5f17c Mon Sep 17 00:00:00 2001 -From: Vojtech Trefny -Date: Tue, 14 Jul 2020 11:27:08 +0200 -Subject: [PATCH 1/4] Add support for XFS format grow - ---- - blivet/formats/fs.py | 2 ++ - blivet/tasks/availability.py | 1 + - blivet/tasks/fsresize.py | 54 ++++++++++++++++++++++++++++++++++++ - 3 files changed, 57 insertions(+) - -diff --git a/blivet/formats/fs.py b/blivet/formats/fs.py -index eee15aaa..12cb9885 100644 ---- a/blivet/formats/fs.py -+++ b/blivet/formats/fs.py -@@ -1089,11 +1089,13 @@ class XFS(FS): - _formattable = True - _linux_native = True - _supported = True -+ _resizable = True - _packages = ["xfsprogs"] - _info_class = fsinfo.XFSInfo - _mkfs_class = fsmkfs.XFSMkfs - _readlabel_class = fsreadlabel.XFSReadLabel - _size_info_class = fssize.XFSSize -+ _resize_class = fsresize.XFSResize - _sync_class = fssync.XFSSync - _writelabel_class = fswritelabel.XFSWriteLabel - _writeuuid_class = fswriteuuid.XFSWriteUUID -diff --git a/blivet/tasks/availability.py b/blivet/tasks/availability.py -index b6b5955a..df62780c 100644 ---- a/blivet/tasks/availability.py -+++ b/blivet/tasks/availability.py -@@ -455,5 +455,6 @@ TUNE2FS_APP = application_by_version("tune2fs", E2FSPROGS_VERSION) - XFSADMIN_APP = application("xfs_admin") - XFSDB_APP = application("xfs_db") - XFSFREEZE_APP = application("xfs_freeze") -+XFSRESIZE_APP = application("xfs_growfs") - - MOUNT_APP = application("mount") -diff --git a/blivet/tasks/fsresize.py b/blivet/tasks/fsresize.py -index e7e26984..12c0367f 100644 ---- a/blivet/tasks/fsresize.py -+++ b/blivet/tasks/fsresize.py -@@ -20,7 +20,10 @@ - # Red Hat Author(s): Anne Mulhern - - import abc -+import os -+import tempfile - -+from contextlib import contextmanager - from six import add_metaclass - - from ..errors import FSError -@@ -32,6 +35,9 @@ from . import task - from . import fstask - from . import dfresize - -+import logging -+log = logging.getLogger("blivet") -+ - - @add_metaclass(abc.ABCMeta) - class FSResizeTask(fstask.FSTask): -@@ -115,6 +121,54 @@ class NTFSResize(FSResize): - ] - - -+class XFSResize(FSResize): -+ ext = availability.XFSRESIZE_APP -+ unit = B -+ size_fmt = None -+ -+ @contextmanager -+ def _do_temp_mount(self): -+ if self.fs.status: -+ yield -+ else: -+ dev_name = os.path.basename(self.fs.device) -+ tmpdir = tempfile.mkdtemp(prefix="xfs-tempmount-%s" % dev_name) -+ log.debug("mounting XFS on '%s' to '%s' for resize", self.fs.device, tmpdir) -+ try: -+ self.fs.mount(mountpoint=tmpdir) -+ except FSError as e: -+ raise FSError("Failed to mount XFS filesystem for resize: %s" % str(e)) -+ -+ try: -+ yield -+ finally: -+ util.umount(mountpoint=tmpdir) -+ os.rmdir(tmpdir) -+ -+ def _get_block_size(self): -+ if self.fs._current_info: -+ # this should be set by update_size_info() -+ for line in self.fs._current_info.split("\n"): -+ if line.startswith("blocksize ="): -+ return int(line.split("=")[-1]) -+ -+ raise FSError("Failed to get XFS filesystem block size for resize") -+ -+ def size_spec(self): -+ # size for xfs_growfs is in blocks -+ return str(self.fs.target_size.convert_to(self.unit) / self._get_block_size()) -+ -+ @property -+ def args(self): -+ return [self.fs.system_mountpoint, "-D", self.size_spec()] -+ -+ def do_task(self): -+ """ Resizes the XFS format. """ -+ -+ with self._do_temp_mount(): -+ super(XFSResize, self).do_task() -+ -+ - class TmpFSResize(FSResize): - - ext = availability.MOUNT_APP --- -2.26.2 - - -From 56d05334231c30699a9c77dedbc23fdb021b9dee Mon Sep 17 00:00:00 2001 -From: Vojtech Trefny -Date: Tue, 14 Jul 2020 11:27:51 +0200 -Subject: [PATCH 2/4] Add tests for XFS resize - -XFS supports only grow so we can't reuse most of the fstesting -code and we also need to test the resize on partition because -XFS won't allow grow to size bigger than the underlying block -device. ---- - tests/formats_test/fs_test.py | 91 +++++++++++++++++++++++++++++++++ - tests/formats_test/fstesting.py | 33 ++++++------ - 2 files changed, 107 insertions(+), 17 deletions(-) - -diff --git a/tests/formats_test/fs_test.py b/tests/formats_test/fs_test.py -index 15fc0c35..9bc5d20d 100644 ---- a/tests/formats_test/fs_test.py -+++ b/tests/formats_test/fs_test.py -@@ -2,8 +2,13 @@ import os - import tempfile - import unittest - -+import parted -+ - import blivet.formats.fs as fs - from blivet.size import Size, ROUND_DOWN -+from blivet.errors import DeviceFormatError -+from blivet.formats import get_format -+from blivet.devices import PartitionDevice, DiskDevice - - from tests import loopbackedtestcase - -@@ -50,6 +55,92 @@ class ReiserFSTestCase(fstesting.FSAsRoot): - class XFSTestCase(fstesting.FSAsRoot): - _fs_class = fs.XFS - -+ def can_resize(self, an_fs): -+ resize_tasks = (an_fs._resize, an_fs._size_info) -+ return not any(t.availability_errors for t in resize_tasks) -+ -+ def _create_partition(self, disk, size): -+ disk.format = get_format("disklabel", device=disk.path, label_type="msdos") -+ disk.format.create() -+ pstart = disk.format.alignment.grainSize -+ pend = pstart + int(Size(size) / disk.format.parted_device.sectorSize) -+ disk.format.add_partition(pstart, pend, parted.PARTITION_NORMAL) -+ disk.format.parted_disk.commit() -+ part = disk.format.parted_disk.getPartitionBySector(pstart) -+ -+ device = PartitionDevice(os.path.basename(part.path)) -+ device.disk = disk -+ device.exists = True -+ device.parted_partition = part -+ -+ return device -+ -+ def _remove_partition(self, partition, disk): -+ disk.format.remove_partition(partition.parted_partition) -+ disk.format.parted_disk.commit() -+ -+ 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) -+ -+ self._remove_partition(part, disk) -+ -+ # and no errors should occur when checking -+ self.assertIsNone(an_fs.do_check()) -+ -+ def test_shrink(self): -+ self.skipTest("Not checking resize for this test category.") -+ -+ def test_too_small(self): -+ self.skipTest("Not checking resize for this test category.") -+ -+ def test_no_explicit_target_size2(self): -+ self.skipTest("Not checking resize for this test category.") -+ -+ def test_too_big2(self): -+ # XXX this tests assumes that resizing to max size - 1 B will fail, but xfs_grow won't -+ self.skipTest("Not checking resize for this test category.") -+ - - class HFSTestCase(fstesting.FSAsRoot): - _fs_class = fs.HFS -diff --git a/tests/formats_test/fstesting.py b/tests/formats_test/fstesting.py -index 62f806f9..86b2a116 100644 ---- a/tests/formats_test/fstesting.py -+++ b/tests/formats_test/fstesting.py -@@ -11,16 +11,6 @@ from blivet.size import Size, ROUND_DOWN - from blivet.formats import fs - - --def can_resize(an_fs): -- """ Returns True if this filesystem has all necessary resizing tools -- available. -- -- :param an_fs: a filesystem object -- """ -- resize_tasks = (an_fs._resize, an_fs._size_info, an_fs._minsize) -- return not any(t.availability_errors for t in resize_tasks) -- -- - @add_metaclass(abc.ABCMeta) - class FSAsRoot(loopbackedtestcase.LoopBackedTestCase): - -@@ -32,6 +22,15 @@ class FSAsRoot(loopbackedtestcase.LoopBackedTestCase): - def __init__(self, methodName='run_test'): - super(FSAsRoot, self).__init__(methodName=methodName, device_spec=[self._DEVICE_SIZE]) - -+ def can_resize(self, an_fs): -+ """ Returns True if this filesystem has all necessary resizing tools -+ available. -+ -+ :param an_fs: a filesystem object -+ """ -+ resize_tasks = (an_fs._resize, an_fs._size_info, an_fs._minsize) -+ return not any(t.availability_errors for t in resize_tasks) -+ - def _test_sizes(self, an_fs): - """ Test relationships between different size values. - -@@ -190,7 +189,7 @@ class FSAsRoot(loopbackedtestcase.LoopBackedTestCase): - # 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 can_resize(an_fs): -+ if not self.can_resize(an_fs): - self.assertFalse(an_fs.resizable) - # Not resizable, so can not do resizing actions. - with self.assertRaises(DeviceFormatError): -@@ -221,7 +220,7 @@ class FSAsRoot(loopbackedtestcase.LoopBackedTestCase): - # in constructor call behavior would be different. - - an_fs = self._fs_class() -- if not can_resize(an_fs): -+ if not self.can_resize(an_fs): - self.skipTest("Not checking resize for this test category.") - if not an_fs.formattable: - self.skipTest("can not create filesystem %s" % an_fs.name) -@@ -244,7 +243,7 @@ class FSAsRoot(loopbackedtestcase.LoopBackedTestCase): - """ - SIZE = Size("64 MiB") - an_fs = self._fs_class(size=SIZE) -- if not can_resize(an_fs): -+ if not self.can_resize(an_fs): - self.skipTest("Not checking resize for this test category.") - if not an_fs.formattable: - self.skipTest("can not create filesystem %s" % an_fs.name) -@@ -264,7 +263,7 @@ class FSAsRoot(loopbackedtestcase.LoopBackedTestCase): - - def test_shrink(self): - an_fs = self._fs_class() -- if not can_resize(an_fs): -+ if not self.can_resize(an_fs): - self.skipTest("Not checking resize for this test category.") - if not an_fs.formattable: - self.skipTest("can not create filesystem %s" % an_fs.name) -@@ -296,7 +295,7 @@ class FSAsRoot(loopbackedtestcase.LoopBackedTestCase): - - def test_too_small(self): - an_fs = self._fs_class() -- if not can_resize(an_fs): -+ if not self.can_resize(an_fs): - self.skipTest("Not checking resize for this test category.") - if not an_fs.formattable: - self.skipTest("can not create or resize filesystem %s" % an_fs.name) -@@ -315,7 +314,7 @@ class FSAsRoot(loopbackedtestcase.LoopBackedTestCase): - - def test_too_big(self): - an_fs = self._fs_class() -- if not can_resize(an_fs): -+ if not self.can_resize(an_fs): - self.skipTest("Not checking resize for this test category.") - if not an_fs.formattable: - self.skipTest("can not create filesystem %s" % an_fs.name) -@@ -334,7 +333,7 @@ class FSAsRoot(loopbackedtestcase.LoopBackedTestCase): - - def test_too_big2(self): - an_fs = self._fs_class() -- if not can_resize(an_fs): -+ if not self.can_resize(an_fs): - self.skipTest("Not checking resize for this test category.") - if not an_fs.formattable: - self.skipTest("can not create filesystem %s" % an_fs.name) --- -2.26.2 - - -From 51acc04f4639f143b55789a06a68aae988a91296 Mon Sep 17 00:00:00 2001 -From: Vojtech Trefny -Date: Wed, 15 Jul 2020 12:59:04 +0200 -Subject: [PATCH 3/4] Add support for checking and fixing XFS using xfs_repair - ---- - blivet/formats/fs.py | 1 + - blivet/tasks/availability.py | 1 + - blivet/tasks/fsck.py | 12 ++++++++++++ - tests/formats_test/fs_test.py | 6 +++--- - 4 files changed, 17 insertions(+), 3 deletions(-) - -diff --git a/blivet/formats/fs.py b/blivet/formats/fs.py -index 12cb9885..06fbdf10 100644 ---- a/blivet/formats/fs.py -+++ b/blivet/formats/fs.py -@@ -1091,6 +1091,7 @@ class XFS(FS): - _supported = True - _resizable = True - _packages = ["xfsprogs"] -+ _fsck_class = fsck.XFSCK - _info_class = fsinfo.XFSInfo - _mkfs_class = fsmkfs.XFSMkfs - _readlabel_class = fsreadlabel.XFSReadLabel -diff --git a/blivet/tasks/availability.py b/blivet/tasks/availability.py -index df62780c..f3b76650 100644 ---- a/blivet/tasks/availability.py -+++ b/blivet/tasks/availability.py -@@ -456,5 +456,6 @@ XFSADMIN_APP = application("xfs_admin") - XFSDB_APP = application("xfs_db") - XFSFREEZE_APP = application("xfs_freeze") - XFSRESIZE_APP = application("xfs_growfs") -+XFSREPAIR_APP = application("xfs_repair") - - MOUNT_APP = application("mount") -diff --git a/blivet/tasks/fsck.py b/blivet/tasks/fsck.py -index 5274f13a..8477f5f8 100644 ---- a/blivet/tasks/fsck.py -+++ b/blivet/tasks/fsck.py -@@ -123,6 +123,18 @@ class Ext2FSCK(FSCK): - return "\n".join(msgs) or None - - -+class XFSCK(FSCK): -+ _fsck_errors = {1: "Runtime error encountered during repair operation.", -+ 2: "XFS repair was unable to proceed due to a dirty log."} -+ -+ ext = availability.XFSREPAIR_APP -+ options = [] -+ -+ def _error_message(self, rc): -+ msgs = (self._fsck_errors[c] for c in self._fsck_errors.keys() if rc & c) -+ return "\n".join(msgs) or None -+ -+ - class HFSPlusFSCK(FSCK): - _fsck_errors = {3: "Quick check found a dirty filesystem; no repairs done.", - 4: "Root filesystem was dirty. System should be rebooted.", -diff --git a/tests/formats_test/fs_test.py b/tests/formats_test/fs_test.py -index 9bc5d20d..8fb099fd 100644 ---- a/tests/formats_test/fs_test.py -+++ b/tests/formats_test/fs_test.py -@@ -123,10 +123,10 @@ class XFSTestCase(fstesting.FSAsRoot): - self.assertEqual(an_fs._size, ACTUAL_SIZE) - self._test_sizes(an_fs) - -- self._remove_partition(part, disk) -+ # and no errors should occur when checking -+ self.assertIsNone(an_fs.do_check()) - -- # and no errors should occur when checking -- self.assertIsNone(an_fs.do_check()) -+ self._remove_partition(part, disk) - - def test_shrink(self): - self.skipTest("Not checking resize for this test category.") --- -2.26.2 - - -From 2a6947098e66f880193f3bac2282a6c7857ca5f7 Mon Sep 17 00:00:00 2001 -From: Vojtech Trefny -Date: Thu, 16 Jul 2020 09:05:35 +0200 -Subject: [PATCH 4/4] Use xfs_db in read-only mode when getting XFS information - -This way it will also work on mounted filesystems. ---- - blivet/tasks/fsinfo.py | 2 +- - 1 file changed, 1 insertion(+), 1 deletion(-) - -diff --git a/blivet/tasks/fsinfo.py b/blivet/tasks/fsinfo.py -index af208f5d..41ff700f 100644 ---- a/blivet/tasks/fsinfo.py -+++ b/blivet/tasks/fsinfo.py -@@ -95,7 +95,7 @@ class ReiserFSInfo(FSInfo): - - class XFSInfo(FSInfo): - ext = availability.XFSDB_APP -- options = ["-c", "sb 0", "-c", "p dblocks", "-c", "p blocksize"] -+ options = ["-c", "sb 0", "-c", "p dblocks", "-c", "p blocksize", "-r"] - - - class UnimplementedFSInfo(fstask.UnimplementedFSTask): --- -2.26.2 - diff --git a/SOURCES/0013-Do-not-limit-swap-to-128-GiB.patch b/SOURCES/0013-Do-not-limit-swap-to-128-GiB.patch deleted file mode 100644 index 5b9f0ed..0000000 --- a/SOURCES/0013-Do-not-limit-swap-to-128-GiB.patch +++ /dev/null @@ -1,76 +0,0 @@ -From aa4ce218fe9b4ee3571d872ff1575a499596181c Mon Sep 17 00:00:00 2001 -From: Vojtech Trefny -Date: Fri, 29 May 2020 12:14:30 +0200 -Subject: [PATCH 1/2] Do not limit swap to 128 GiB - -The limit was part of change to limit suggested swap size in -kickstart which doesn't use the SwapSpace._max_size so there is no -reason to limit this for manual installations. -16 TiB seems to be max usable swap size based on mkswap code. - -Resolves: rhbz#1656485 ---- - blivet/formats/swap.py | 3 +-- - 1 file changed, 1 insertion(+), 2 deletions(-) - -diff --git a/blivet/formats/swap.py b/blivet/formats/swap.py -index 4b8a7edf..3cc59138 100644 ---- a/blivet/formats/swap.py -+++ b/blivet/formats/swap.py -@@ -52,8 +52,7 @@ class SwapSpace(DeviceFormat): - _linux_native = True # for clearpart - _plugin = availability.BLOCKDEV_SWAP_PLUGIN - -- # see rhbz#744129 for details -- _max_size = Size("128 GiB") -+ _max_size = Size("16 TiB") - - config_actions_map = {"label": "write_label"} - --- -2.26.2 - - -From 93aa6ad87116f1c86616d73dbe561251c4a0c286 Mon Sep 17 00:00:00 2001 -From: Vojtech Trefny -Date: Thu, 11 Jun 2020 14:27:44 +0200 -Subject: [PATCH 2/2] Add test for SwapSpace max size - ---- - tests/formats_test/swap_test.py | 24 ++++++++++++++++++++++++ - 1 file changed, 24 insertions(+) - create mode 100644 tests/formats_test/swap_test.py - -diff --git a/tests/formats_test/swap_test.py b/tests/formats_test/swap_test.py -new file mode 100644 -index 00000000..56356144 ---- /dev/null -+++ b/tests/formats_test/swap_test.py -@@ -0,0 +1,24 @@ -+import test_compat # pylint: disable=unused-import -+ -+import six -+import unittest -+ -+from blivet.devices.storage import StorageDevice -+from blivet.errors import DeviceError -+from blivet.formats import get_format -+ -+from blivet.size import Size -+ -+ -+class SwapNodevTestCase(unittest.TestCase): -+ -+ def test_swap_max_size(self): -+ StorageDevice("dev", size=Size("129 GiB"), -+ fmt=get_format("swap")) -+ -+ StorageDevice("dev", size=Size("15 TiB"), -+ fmt=get_format("swap")) -+ -+ with six.assertRaisesRegex(self, DeviceError, "device is too large for new format"): -+ StorageDevice("dev", size=Size("17 TiB"), -+ fmt=get_format("swap")) --- -2.26.2 - diff --git a/SOURCES/0014-Use-UnusableConfigurationError-for-patially-hidden-multipath-devices.patch b/SOURCES/0014-Use-UnusableConfigurationError-for-patially-hidden-multipath-devices.patch deleted file mode 100644 index 1e14de6..0000000 --- a/SOURCES/0014-Use-UnusableConfigurationError-for-patially-hidden-multipath-devices.patch +++ /dev/null @@ -1,78 +0,0 @@ -From 4e6a322d32d2a12f8a87ab763a6286cf3d7b5c27 Mon Sep 17 00:00:00 2001 -From: Vojtech Trefny -Date: Tue, 8 Sep 2020 13:57:40 +0200 -Subject: [PATCH] Use UnusableConfigurationError for partially hidden multipath - devices - -Follow-up for https://github.com/storaged-project/blivet/pull/883 -to make Anaconda show an error message instead of crashing. - -Resolves: rhbz#1877052 ---- - blivet/devicetree.py | 4 ++-- - blivet/errors.py | 6 ++++++ - tests/devicetree_test.py | 4 ++-- - 3 files changed, 10 insertions(+), 4 deletions(-) - -diff --git a/blivet/devicetree.py b/blivet/devicetree.py -index 2afb0d0e..57a9bbd7 100644 ---- a/blivet/devicetree.py -+++ b/blivet/devicetree.py -@@ -32,7 +32,7 @@ from gi.repository import BlockDev as blockdev - - from .actionlist import ActionList - from .callbacks import callbacks --from .errors import DeviceError, DeviceTreeError, StorageError, DuplicateUUIDError -+from .errors import DeviceError, DeviceTreeError, StorageError, DuplicateUUIDError, InvalidMultideviceSelection - from .deviceaction import ActionDestroyDevice, ActionDestroyFormat - from .devices import BTRFSDevice, NoDevice, PartitionDevice - from .devices import LVMLogicalVolumeDevice, LVMVolumeGroupDevice -@@ -936,7 +936,7 @@ class DeviceTreeBase(object): - if is_ignored: - if len(disk.children) == 1: - if not all(self._is_ignored_disk(d) for d in disk.children[0].parents): -- raise DeviceTreeError("Including only a subset of raid/multipath member disks is not allowed.") -+ raise InvalidMultideviceSelection("Including only a subset of raid/multipath member disks is not allowed.") - - # and also children like fwraid or mpath - self.hide(disk.children[0]) -diff --git a/blivet/errors.py b/blivet/errors.py -index 811abf81..7a93f1ce 100644 ---- a/blivet/errors.py -+++ b/blivet/errors.py -@@ -233,6 +233,12 @@ class DuplicateVGError(UnusableConfigurationError): - "Hint 2: You can get the VG UUIDs by running " - "'pvs -o +vg_uuid'.") - -+ -+class InvalidMultideviceSelection(UnusableConfigurationError): -+ suggestion = N_("All parent devices must be selected when choosing exclusive " -+ "or ignored disks for a multipath or firmware RAID device.") -+ -+ - # DeviceAction - - -diff --git a/tests/devicetree_test.py b/tests/devicetree_test.py -index 6032e7f6..4e47ffc3 100644 ---- a/tests/devicetree_test.py -+++ b/tests/devicetree_test.py -@@ -5,7 +5,7 @@ import six - import unittest - - from blivet.actionlist import ActionList --from blivet.errors import DeviceTreeError, DuplicateUUIDError -+from blivet.errors import DeviceTreeError, DuplicateUUIDError, InvalidMultideviceSelection - from blivet.deviceaction import ACTION_TYPE_DESTROY, ACTION_OBJECT_DEVICE - from blivet.devicelibs import lvm - from blivet.devices import DiskDevice -@@ -512,5 +512,5 @@ class DeviceTreeIgnoredExclusiveMultipathTestCase(unittest.TestCase): - self.tree.ignored_disks = ["sda", "sdb"] - self.tree.exclusive_disks = [] - -- with self.assertRaises(DeviceTreeError): -+ with self.assertRaises(InvalidMultideviceSelection): - self.tree._hide_ignored_disks() --- -2.26.2 - diff --git a/SOURCES/0015-Fix-possible-UnicodeDecodeError-when-reading-model-f.patch b/SOURCES/0015-Fix-possible-UnicodeDecodeError-when-reading-model-f.patch deleted file mode 100644 index 24e408e..0000000 --- a/SOURCES/0015-Fix-possible-UnicodeDecodeError-when-reading-model-f.patch +++ /dev/null @@ -1,32 +0,0 @@ -From 866a48e6c3d8246d2897bb402a191df5f2848aa4 Mon Sep 17 00:00:00 2001 -From: Vojtech Trefny -Date: Tue, 23 Jun 2020 10:33:33 +0200 -Subject: [PATCH] Fix possible UnicodeDecodeError when reading model from sysfs - -Some Innovation IT NVMe devices have an (invalid) unicode in their -model name. - -Resolves: rhbz#1849326 ---- - blivet/udev.py | 5 +++-- - 1 file changed, 3 insertions(+), 2 deletions(-) - -diff --git a/blivet/udev.py b/blivet/udev.py -index 41c99496..2c795225 100644 ---- a/blivet/udev.py -+++ b/blivet/udev.py -@@ -185,8 +185,9 @@ def __is_blacklisted_blockdev(dev_name): - if any(re.search(expr, dev_name) for expr in device_name_blacklist): - return True - -- if os.path.exists("/sys/class/block/%s/device/model" % (dev_name,)): -- model = open("/sys/class/block/%s/device/model" % (dev_name,)).read() -+ model_path = "/sys/class/block/%s/device/model" % dev_name -+ if os.path.exists(model_path): -+ model = open(model_path, encoding="utf-8", errors="replace").read() - for bad in ("IBM *STMF KERNEL", "SCEI Flash-5", "DGC LUNZ"): - if model.find(bad) != -1: - log.info("ignoring %s with model %s", dev_name, model) --- -2.26.2 - diff --git a/SOURCES/0016-Basic-LVM-VDO-support.patch b/SOURCES/0016-Basic-LVM-VDO-support.patch deleted file mode 100644 index b52342b..0000000 --- a/SOURCES/0016-Basic-LVM-VDO-support.patch +++ /dev/null @@ -1,415 +0,0 @@ -From 3f6bbf52442609b8e6e3919a3fdd8c5af64923e6 Mon Sep 17 00:00:00 2001 -From: Vojtech Trefny -Date: Tue, 12 May 2020 12:48:41 +0200 -Subject: [PATCH 1/3] Add basic support for LVM VDO devices - -This adds support for LVM VDO devices detection during populate -and allows removing both VDO LVs and VDO pools using actions. ---- - blivet/devices/lvm.py | 150 +++++++++++++++++++++++++++++++- - blivet/populator/helpers/lvm.py | 16 +++- - tests/action_test.py | 39 +++++++++ - tests/devices_test/lvm_test.py | 34 ++++++++ - tests/storagetestcase.py | 11 ++- - 5 files changed, 245 insertions(+), 5 deletions(-) - -diff --git a/blivet/devices/lvm.py b/blivet/devices/lvm.py -index 97de6acd..d9e24a33 100644 ---- a/blivet/devices/lvm.py -+++ b/blivet/devices/lvm.py -@@ -1789,8 +1789,132 @@ class LVMThinLogicalVolumeMixin(object): - data.pool_name = self.pool.lvname - - -+class LVMVDOPoolMixin(object): -+ def __init__(self): -+ self._lvs = [] -+ -+ @property -+ def is_vdo_pool(self): -+ return self.seg_type == "vdo-pool" -+ -+ @property -+ def type(self): -+ return "lvmvdopool" -+ -+ @property -+ def resizable(self): -+ return False -+ -+ @util.requires_property("is_vdo_pool") -+ def _add_log_vol(self, lv): -+ """ Add an LV to this VDO pool. """ -+ if lv in self._lvs: -+ raise ValueError("lv is already part of this VDO pool") -+ -+ self.vg._add_log_vol(lv) -+ log.debug("Adding %s/%s to %s", lv.name, lv.size, self.name) -+ self._lvs.append(lv) -+ -+ @util.requires_property("is_vdo_pool") -+ def _remove_log_vol(self, lv): -+ """ Remove an LV from this VDO pool. """ -+ if lv not in self._lvs: -+ raise ValueError("specified lv is not part of this VDO pool") -+ -+ self._lvs.remove(lv) -+ self.vg._remove_log_vol(lv) -+ -+ @property -+ @util.requires_property("is_vdo_pool") -+ def lvs(self): -+ """ A list of this VDO pool's LVs """ -+ return self._lvs[:] # we don't want folks changing our list -+ -+ @property -+ def direct(self): -+ """ Is this device directly accessible? """ -+ return False -+ -+ def _create(self): -+ """ Create the device. """ -+ raise NotImplementedError -+ -+ -+class LVMVDOLogicalVolumeMixin(object): -+ def __init__(self): -+ pass -+ -+ def _init_check(self): -+ pass -+ -+ def _check_parents(self): -+ """Check that this device has parents as expected""" -+ if isinstance(self.parents, (list, ParentList)): -+ if len(self.parents) != 1: -+ raise ValueError("constructor requires a single vdo-pool LV") -+ -+ container = self.parents[0] -+ else: -+ container = self.parents -+ -+ if not container or not isinstance(container, LVMLogicalVolumeDevice) or not container.is_vdo_pool: -+ raise ValueError("constructor requires a vdo-pool LV") -+ -+ @property -+ def vg_space_used(self): -+ return Size(0) # the pool's size is already accounted for in the vg -+ -+ @property -+ def is_vdo_lv(self): -+ return self.seg_type == "vdo" -+ -+ @property -+ def vg(self): -+ # parents[0] is the pool, not the VG so set the VG here -+ return self.pool.vg -+ -+ @property -+ def type(self): -+ return "vdolv" -+ -+ @property -+ def resizable(self): -+ return False -+ -+ @property -+ @util.requires_property("is_vdo_lv") -+ def pool(self): -+ return self.parents[0] -+ -+ def _create(self): -+ """ Create the device. """ -+ raise NotImplementedError -+ -+ def _destroy(self): -+ # nothing to do here, VDO LV is destroyed automatically together with -+ # the VDO pool -+ pass -+ -+ def remove_hook(self, modparent=True): -+ if modparent: -+ self.pool._remove_log_vol(self) -+ -+ # pylint: disable=bad-super-call -+ super(LVMLogicalVolumeBase, self).remove_hook(modparent=modparent) -+ -+ def add_hook(self, new=True): -+ # pylint: disable=bad-super-call -+ super(LVMLogicalVolumeBase, self).add_hook(new=new) -+ if new: -+ return -+ -+ if self not in self.pool.lvs: -+ self.pool._add_log_vol(self) -+ -+ - class LVMLogicalVolumeDevice(LVMLogicalVolumeBase, LVMInternalLogicalVolumeMixin, LVMSnapshotMixin, -- LVMThinPoolMixin, LVMThinLogicalVolumeMixin): -+ LVMThinPoolMixin, LVMThinLogicalVolumeMixin, LVMVDOPoolMixin, -+ LVMVDOLogicalVolumeMixin): - """ An LVM Logical Volume """ - - # generally resizable, see :property:`resizable` for details -@@ -1879,6 +2003,8 @@ class LVMLogicalVolumeDevice(LVMLogicalVolumeBase, LVMInternalLogicalVolumeMixin - LVMLogicalVolumeBase.__init__(self, name, parents, size, uuid, seg_type, - fmt, exists, sysfs_path, grow, maxsize, - percent, cache_request, pvs, from_lvs) -+ LVMVDOPoolMixin.__init__(self) -+ LVMVDOLogicalVolumeMixin.__init__(self) - - LVMInternalLogicalVolumeMixin._init_check(self) - LVMSnapshotMixin._init_check(self) -@@ -1905,6 +2031,10 @@ class LVMLogicalVolumeDevice(LVMLogicalVolumeBase, LVMInternalLogicalVolumeMixin - ret.append(LVMThinPoolMixin) - if self.is_thin_lv: - ret.append(LVMThinLogicalVolumeMixin) -+ if self.is_vdo_pool: -+ ret.append(LVMVDOPoolMixin) -+ if self.is_vdo_lv: -+ ret.append(LVMVDOLogicalVolumeMixin) - return ret - - def _try_specific_call(self, name, *args, **kwargs): -@@ -2066,6 +2196,11 @@ class LVMLogicalVolumeDevice(LVMLogicalVolumeBase, LVMInternalLogicalVolumeMixin - def display_lv_name(self): - return self.lvname - -+ @property -+ @type_specific -+ def pool(self): -+ return super(LVMLogicalVolumeDevice, self).pool -+ - def _setup(self, orig=False): - """ Open, or set up, a device. """ - log_method_call(self, self.name, orig=orig, status=self.status, -@@ -2167,6 +2302,19 @@ class LVMLogicalVolumeDevice(LVMLogicalVolumeBase, LVMInternalLogicalVolumeMixin - udev.settle() - blockdev.lvm.lvresize(self.vg.name, self._name, self.size) - -+ @type_specific -+ def _add_log_vol(self, lv): -+ pass -+ -+ @type_specific -+ def _remove_log_vol(self, lv): -+ pass -+ -+ @property -+ @type_specific -+ def lvs(self): -+ return [] -+ - @property - @type_specific - def direct(self): -diff --git a/blivet/populator/helpers/lvm.py b/blivet/populator/helpers/lvm.py -index 4b674fac..ff8bf59f 100644 ---- a/blivet/populator/helpers/lvm.py -+++ b/blivet/populator/helpers/lvm.py -@@ -211,9 +211,6 @@ class LVMFormatPopulator(FormatPopulator): - origin = self._devicetree.get_device_by_name(origin_device_name) - - lv_kwargs["origin"] = origin -- elif lv_attr[0] == 'v': -- # skip vorigins -- return - elif lv_attr[0] in 'IrielTCo' and lv_name.endswith(']'): - # an internal LV, add the an instance of the appropriate class - # to internal_lvs for later processing when non-internal LVs are -@@ -237,6 +234,19 @@ class LVMFormatPopulator(FormatPopulator): - origin = self._devicetree.get_device_by_name(origin_device_name) - lv_kwargs["origin"] = origin - -+ lv_parents = [self._devicetree.get_device_by_name(pool_device_name)] -+ elif lv_attr[0] == 'd': -+ # vdo pool -+ # nothing to do here -+ pass -+ elif lv_attr[0] == 'v': -+ if lv_type != "vdo": -+ # skip vorigins -+ return -+ pool_name = blockdev.lvm.vdolvpoolname(vg_name, lv_name) -+ pool_device_name = "%s-%s" % (vg_name, pool_name) -+ add_required_lv(pool_device_name, "failed to look up VDO pool") -+ - lv_parents = [self._devicetree.get_device_by_name(pool_device_name)] - elif lv_name.endswith(']'): - # unrecognized Internal LVM2 device -diff --git a/tests/action_test.py b/tests/action_test.py -index 90c1b312..8f9a7424 100644 ---- a/tests/action_test.py -+++ b/tests/action_test.py -@@ -1252,6 +1252,45 @@ class DeviceActionTestCase(StorageTestCase): - self.assertEqual(set(self.storage.lvs), {pool}) - self.assertEqual(set(pool._internal_lvs), {lv1, lv2}) - -+ def test_lvm_vdo_destroy(self): -+ self.destroy_all_devices() -+ sdc = self.storage.devicetree.get_device_by_name("sdc") -+ sdc1 = self.new_device(device_class=PartitionDevice, name="sdc1", -+ size=Size("50 GiB"), parents=[sdc], -+ fmt=blivet.formats.get_format("lvmpv")) -+ self.schedule_create_device(sdc1) -+ -+ vg = self.new_device(device_class=LVMVolumeGroupDevice, -+ name="vg", parents=[sdc1]) -+ self.schedule_create_device(vg) -+ -+ pool = self.new_device(device_class=LVMLogicalVolumeDevice, -+ name="data", parents=[vg], -+ size=Size("10 GiB"), -+ seg_type="vdo-pool", exists=True) -+ self.storage.devicetree._add_device(pool) -+ lv = self.new_device(device_class=LVMLogicalVolumeDevice, -+ name="meta", parents=[pool], -+ size=Size("50 GiB"), -+ seg_type="vdo", exists=True) -+ self.storage.devicetree._add_device(lv) -+ -+ remove_lv = self.schedule_destroy_device(lv) -+ self.assertListEqual(pool.lvs, []) -+ self.assertNotIn(lv, vg.lvs) -+ -+ # cancelling the action should put lv back to both vg and pool lvs -+ self.storage.devicetree.actions.remove(remove_lv) -+ self.assertListEqual(pool.lvs, [lv]) -+ self.assertIn(lv, vg.lvs) -+ -+ # can't remove non-leaf pool -+ with self.assertRaises(ValueError): -+ self.schedule_destroy_device(pool) -+ -+ self.schedule_destroy_device(lv) -+ self.schedule_destroy_device(pool) -+ - - class ConfigurationActionsTest(unittest.TestCase): - -diff --git a/tests/devices_test/lvm_test.py b/tests/devices_test/lvm_test.py -index 9e701d18..204cb99a 100644 ---- a/tests/devices_test/lvm_test.py -+++ b/tests/devices_test/lvm_test.py -@@ -405,6 +405,40 @@ class LVMDeviceTest(unittest.TestCase): - exists=False) - self.assertFalse(vg.is_empty) - -+ def test_lvm_vdo_pool(self): -+ pv = StorageDevice("pv1", fmt=blivet.formats.get_format("lvmpv"), -+ size=Size("1 GiB"), exists=True) -+ vg = LVMVolumeGroupDevice("testvg", parents=[pv]) -+ pool = LVMLogicalVolumeDevice("testpool", parents=[vg], size=Size("512 MiB"), -+ seg_type="vdo-pool", exists=True) -+ self.assertTrue(pool.is_vdo_pool) -+ -+ free = vg.free_space -+ lv = LVMLogicalVolumeDevice("testlv", parents=[pool], size=Size("2 GiB"), -+ seg_type="vdo", exists=True) -+ self.assertTrue(lv.is_vdo_lv) -+ self.assertEqual(lv.vg, vg) -+ self.assertEqual(lv.pool, pool) -+ -+ # free space in the vg shouldn't be affected by the vdo lv -+ self.assertEqual(lv.vg_space_used, 0) -+ self.assertEqual(free, vg.free_space) -+ -+ self.assertListEqual(pool.lvs, [lv]) -+ -+ # now try to destroy both the pool and the vdo lv -+ # for the lv this should be a no-op, destroying the pool should destroy both -+ with patch("blivet.devices.lvm.blockdev.lvm") as lvm: -+ lv.destroy() -+ lv.remove_hook() -+ self.assertFalse(lv.exists) -+ self.assertFalse(lvm.lvremove.called) -+ self.assertListEqual(pool.lvs, []) -+ -+ pool.destroy() -+ self.assertFalse(pool.exists) -+ self.assertTrue(lvm.lvremove.called) -+ - - class TypeSpecificCallsTest(unittest.TestCase): - def test_type_specific_calls(self): -diff --git a/tests/storagetestcase.py b/tests/storagetestcase.py -index e581bca6..1844dec5 100644 ---- a/tests/storagetestcase.py -+++ b/tests/storagetestcase.py -@@ -96,7 +96,16 @@ class StorageTestCase(unittest.TestCase): - def new_device(self, *args, **kwargs): - """ Return a new Device instance suitable for testing. """ - device_class = kwargs.pop("device_class") -- exists = kwargs.pop("exists", False) -+ -+ # we intentionally don't pass the "exists" kwarg to the constructor -+ # becauses this causes issues with some devices (especially partitions) -+ # but we still need it for some LVs like VDO because we can't create -+ # those so we need to fake their existence even for the constructor -+ if device_class is blivet.devices.LVMLogicalVolumeDevice: -+ exists = kwargs.get("exists", False) -+ else: -+ exists = kwargs.pop("exists", False) -+ - part_type = kwargs.pop("part_type", parted.PARTITION_NORMAL) - device = device_class(*args, **kwargs) - --- -2.26.2 - - -From f05a66e1bed1ca1f3cd7d7ffecd6693ab4d7f32a Mon Sep 17 00:00:00 2001 -From: Vojtech Trefny -Date: Tue, 12 May 2020 12:52:47 +0200 -Subject: [PATCH 2/3] Fix checking for filesystem support in action_test - ---- - tests/action_test.py | 2 +- - 1 file changed, 1 insertion(+), 1 deletion(-) - -diff --git a/tests/action_test.py b/tests/action_test.py -index 8f9a7424..228eb97a 100644 ---- a/tests/action_test.py -+++ b/tests/action_test.py -@@ -56,7 +56,7 @@ FORMAT_CLASSES = [ - - - @unittest.skipUnless(not any(x.unavailable_type_dependencies() for x in DEVICE_CLASSES), "some unsupported device classes required for this test") --@unittest.skipUnless(not any(x().utils_available for x in FORMAT_CLASSES), "some unsupported format classes required for this test") -+@unittest.skipUnless(all(x().utils_available for x in FORMAT_CLASSES), "some unsupported format classes required for this test") - class DeviceActionTestCase(StorageTestCase): - - """ DeviceActionTestSuite """ --- -2.26.2 - - -From 69bd2e69e21c8779377a6f54b3d83cb35138867a Mon Sep 17 00:00:00 2001 -From: Vojtech Trefny -Date: Tue, 12 May 2020 12:54:03 +0200 -Subject: [PATCH 3/3] Fix LV min size for resize in test_action_dependencies - -We've recently changed min size for all filesystems so we can't -resize the LV to the device minimal size. -This was overlooked in the original change because these tests -were skipped. ---- - tests/action_test.py | 2 +- - 1 file changed, 1 insertion(+), 1 deletion(-) - -diff --git a/tests/action_test.py b/tests/action_test.py -index 228eb97a..77176f46 100644 ---- a/tests/action_test.py -+++ b/tests/action_test.py -@@ -870,7 +870,7 @@ class DeviceActionTestCase(StorageTestCase): - name="testlv2", parents=[testvg]) - testlv2.format = self.new_format("ext4", device=testlv2.path, - exists=True, device_instance=testlv2) -- shrink_lv2 = ActionResizeDevice(testlv2, testlv2.size - Size("10 GiB")) -+ shrink_lv2 = ActionResizeDevice(testlv2, testlv2.size - Size("10 GiB") + Ext4FS._min_size) - shrink_lv2.apply() - - self.assertTrue(grow_lv.requires(shrink_lv2)) --- -2.26.2 - diff --git a/SOURCES/0017-Let-parted-fix-fixable-issues-with-partition-table.patch b/SOURCES/0017-Let-parted-fix-fixable-issues-with-partition-table.patch deleted file mode 100644 index af2c4d8..0000000 --- a/SOURCES/0017-Let-parted-fix-fixable-issues-with-partition-table.patch +++ /dev/null @@ -1,30 +0,0 @@ -From d477f8d076789cbe1c0a85545ea8b5133fdc4bdf Mon Sep 17 00:00:00 2001 -From: Vojtech Trefny -Date: Fri, 18 Sep 2020 13:58:48 +0200 -Subject: [PATCH] Let parted fix fixable issues with partition table - -This will automatically fix issues like GPT partition table not -covering whole device after disk size change. - -Resolves: rhbz#1846869 ---- - blivet/populator/populator.py | 3 +++ - 1 file changed, 3 insertions(+) - -diff --git a/blivet/populator/populator.py b/blivet/populator/populator.py -index 465c272d..fe566816 100644 ---- a/blivet/populator/populator.py -+++ b/blivet/populator/populator.py -@@ -64,6 +64,9 @@ def parted_exn_handler(exn_type, exn_options, exn_msg): - if exn_type == parted.EXCEPTION_TYPE_ERROR and \ - exn_options == parted.EXCEPTION_OPT_YES_NO: - ret = parted.EXCEPTION_RESOLVE_YES -+ elif exn_type == parted.EXCEPTION_TYPE_WARNING and \ -+ exn_options & parted.EXCEPTION_RESOLVE_FIX: -+ ret = parted.EXCEPTION_RESOLVE_FIX - return ret - - --- -2.29.2 - diff --git a/SOURCES/0018-Fix-possible-UnicodeDecodeError-when-reading-sysfs-a.patch b/SOURCES/0018-Fix-possible-UnicodeDecodeError-when-reading-sysfs-a.patch deleted file mode 100644 index 11b6a40..0000000 --- a/SOURCES/0018-Fix-possible-UnicodeDecodeError-when-reading-sysfs-a.patch +++ /dev/null @@ -1,112 +0,0 @@ -From 430cd2cdba8fba434b5bed2d2a7ed97803c62f6d Mon Sep 17 00:00:00 2001 -From: Vojtech Trefny -Date: Tue, 5 Jan 2021 16:56:52 +0100 -Subject: [PATCH 1/3] Fix possible UnicodeDecodeError when reading sysfs - attributes - -This is a follow-up for https://github.com/storaged-project/blivet/pull/861 -where we fixed reading device model in "__is_blacklisted_blockdev" -but we read the device model from other places too so it makes -more sense to "fix" all sysfs attribute reads. ---- - blivet/util.py | 2 +- - 1 file changed, 1 insertion(+), 1 deletion(-) - -diff --git a/blivet/util.py b/blivet/util.py -index 2fa9c8fc..48b7818f 100644 ---- a/blivet/util.py -+++ b/blivet/util.py -@@ -379,7 +379,7 @@ def get_sysfs_attr(path, attr, root=None): - log.warning("%s is not a valid attribute", attr) - return None - -- f = open(fullattr, "r") -+ f = open(fullattr, "r", encoding="utf-8", errors="replace") - data = f.read() - f.close() - sdata = "".join(["%02x" % (ord(x),) for x in data]) --- -2.29.2 - - -From 15350b52f30910d4fadad92da0195710adcb69a0 Mon Sep 17 00:00:00 2001 -From: Vojtech Trefny -Date: Tue, 5 Jan 2021 16:59:14 +0100 -Subject: [PATCH 2/3] Use util.get_sysfs_attr in __is_ignored_blockdev to read - device mode - ---- - blivet/udev.py | 5 ++--- - 1 file changed, 2 insertions(+), 3 deletions(-) - -diff --git a/blivet/udev.py b/blivet/udev.py -index 2c795225..25375459 100644 ---- a/blivet/udev.py -+++ b/blivet/udev.py -@@ -185,9 +185,8 @@ def __is_blacklisted_blockdev(dev_name): - if any(re.search(expr, dev_name) for expr in device_name_blacklist): - return True - -- model_path = "/sys/class/block/%s/device/model" % dev_name -- if os.path.exists(model_path): -- model = open(model_path, encoding="utf-8", errors="replace").read() -+ model = util.get_sysfs_attr("/sys/class/block/%s" % dev_name, "device/model") -+ if model: - for bad in ("IBM *STMF KERNEL", "SCEI Flash-5", "DGC LUNZ"): - if model.find(bad) != -1: - log.info("ignoring %s with model %s", dev_name, model) --- -2.29.2 - - -From 64ece8c0dafb550bbde4798a766515fb04f44568 Mon Sep 17 00:00:00 2001 -From: Vojtech Trefny -Date: Wed, 6 Jan 2021 12:34:49 +0100 -Subject: [PATCH 3/3] Add test for util.get_sysfs_attr - ---- - tests/util_test.py | 23 +++++++++++++++++++++++ - 1 file changed, 23 insertions(+) - -diff --git a/tests/util_test.py b/tests/util_test.py -index 9a2ff492..853b6166 100644 ---- a/tests/util_test.py -+++ b/tests/util_test.py -@@ -2,7 +2,9 @@ - import test_compat - - from six.moves import mock -+import os - import six -+import tempfile - import unittest - from decimal import Decimal - -@@ -157,3 +159,24 @@ class DependencyGuardTestCase(unittest.TestCase): - with mock.patch.object(_requires_something, '_check_avail', return_value=True): - self.assertEqual(self._test_dependency_guard_non_critical(), True) - self.assertEqual(self._test_dependency_guard_critical(), True) -+ -+ -+class GetSysfsAttrTestCase(unittest.TestCase): -+ -+ def test_get_sysfs_attr(self): -+ -+ with tempfile.TemporaryDirectory() as sysfs: -+ model_file = os.path.join(sysfs, "model") -+ with open(model_file, "w") as f: -+ f.write("test model\n") -+ -+ model = util.get_sysfs_attr(sysfs, "model") -+ self.assertEqual(model, "test model") -+ -+ # now with some invalid byte in the model -+ with open(model_file, "wb") as f: -+ f.write(b"test model\xef\n") -+ -+ # the unicode replacement character (U+FFFD) should be used instead -+ model = util.get_sysfs_attr(sysfs, "model") -+ self.assertEqual(model, "test model\ufffd") --- -2.29.2 - diff --git a/SOURCES/0019-LVM-VDO-support.patch b/SOURCES/0019-LVM-VDO-support.patch deleted file mode 100644 index c79d6c1..0000000 --- a/SOURCES/0019-LVM-VDO-support.patch +++ /dev/null @@ -1,2027 +0,0 @@ -From 18f05802f07f580ed31f38931b1103842397d598 Mon Sep 17 00:00:00 2001 -From: Vojtech Trefny -Date: Mon, 2 Nov 2020 14:19:52 +0100 -Subject: [PATCH 01/17] Fix type of LVM VDO logical volumes - -We should use "lvmvdolv" to make it similar to other "lvmXYZ" -types. ---- - blivet/devices/lvm.py | 2 +- - 1 file changed, 1 insertion(+), 1 deletion(-) - -diff --git a/blivet/devices/lvm.py b/blivet/devices/lvm.py -index d9e24a33..9639256d 100644 ---- a/blivet/devices/lvm.py -+++ b/blivet/devices/lvm.py -@@ -1875,7 +1875,7 @@ def vg(self): - - @property - def type(self): -- return "vdolv" -+ return "lvmvdolv" - - @property - def resizable(self): - -From 7f4815e14075550f55f2afb44bfba461eacea1c4 Mon Sep 17 00:00:00 2001 -From: Vojtech Trefny -Date: Mon, 2 Nov 2020 14:21:33 +0100 -Subject: [PATCH 02/17] Add VDO pool data LV to internal LVs during populate - ---- - blivet/devices/lvm.py | 9 ++++++++- - blivet/populator/helpers/lvm.py | 2 +- - 2 files changed, 9 insertions(+), 2 deletions(-) - -diff --git a/blivet/devices/lvm.py b/blivet/devices/lvm.py -index 9639256d..d0957d6a 100644 ---- a/blivet/devices/lvm.py -+++ b/blivet/devices/lvm.py -@@ -1119,7 +1119,7 @@ class LVMInternalLVtype(Enum): - - @classmethod - def get_type(cls, lv_attr, lv_name): # pylint: disable=unused-argument -- attr_letters = {cls.data: ("T", "C"), -+ attr_letters = {cls.data: ("T", "C", "D"), - cls.meta: ("e",), - cls.log: ("l", "L"), - cls.image: ("i", "I"), -@@ -1824,6 +1824,13 @@ def _remove_log_vol(self, lv): - self._lvs.remove(lv) - self.vg._remove_log_vol(lv) - -+ @property -+ @util.requires_property("is_vdo_pool") -+ def _vdopool_data_lv(self): -+ if not self._internal_lvs: -+ return None -+ return self._internal_lvs[0] -+ - @property - @util.requires_property("is_vdo_pool") - def lvs(self): -diff --git a/blivet/populator/helpers/lvm.py b/blivet/populator/helpers/lvm.py -index ff8bf59f..b1626306 100644 ---- a/blivet/populator/helpers/lvm.py -+++ b/blivet/populator/helpers/lvm.py -@@ -211,7 +211,7 @@ def add_lv(lv): - origin = self._devicetree.get_device_by_name(origin_device_name) - - lv_kwargs["origin"] = origin -- elif lv_attr[0] in 'IrielTCo' and lv_name.endswith(']'): -+ elif lv_attr[0] in 'IrielTCoD' and lv_name.endswith(']'): - # an internal LV, add the an instance of the appropriate class - # to internal_lvs for later processing when non-internal LVs are - # processed - -From c164864955e371aef78b5020f28bf0c9d235ac7c Mon Sep 17 00:00:00 2001 -From: Vojtech Trefny -Date: Mon, 2 Nov 2020 14:22:12 +0100 -Subject: [PATCH 03/17] Add availability functions for LVM VDO - -VDO is currently available only on RHEL/CentOS so we need a -separate availability check for LVM VDO devices. ---- - blivet/devices/lvm.py | 6 ++++++ - blivet/tasks/availability.py | 8 ++++++++ - 2 files changed, 14 insertions(+) - -diff --git a/blivet/devices/lvm.py b/blivet/devices/lvm.py -index d0957d6a..ffc65dcd 100644 ---- a/blivet/devices/lvm.py -+++ b/blivet/devices/lvm.py -@@ -1790,6 +1790,9 @@ def populate_ksdata(self, data): - - - class LVMVDOPoolMixin(object): -+ -+ _external_dependencies = [availability.BLOCKDEV_LVM_PLUGIN, availability.BLOCKDEV_LVM_PLUGIN_VDO] -+ - def __init__(self): - self._lvs = [] - -@@ -1848,6 +1851,9 @@ def _create(self): - - - class LVMVDOLogicalVolumeMixin(object): -+ -+ _external_dependencies = [availability.BLOCKDEV_LVM_PLUGIN, availability.BLOCKDEV_LVM_PLUGIN_VDO] -+ - def __init__(self): - pass - -diff --git a/blivet/tasks/availability.py b/blivet/tasks/availability.py -index f3b76650..b107428e 100644 ---- a/blivet/tasks/availability.py -+++ b/blivet/tasks/availability.py -@@ -372,6 +372,13 @@ def available_resource(name): - blockdev.LVMTechMode.MODIFY)}) - BLOCKDEV_LVM_TECH = BlockDevMethod(BLOCKDEV_LVM) - -+BLOCKDEV_LVM_VDO = BlockDevTechInfo(plugin_name="lvm", -+ check_fn=blockdev.lvm_is_tech_avail, -+ technologies={blockdev.LVMTech.VDO: (blockdev.LVMTechMode.CREATE | -+ blockdev.LVMTechMode.REMOVE | -+ blockdev.LVMTechMode.QUERY)}) -+BLOCKDEV_LVM_TECH_VDO = BlockDevMethod(BLOCKDEV_LVM_VDO) -+ - # libblockdev mdraid plugin required technologies and modes - BLOCKDEV_MD_ALL_MODES = (blockdev.MDTechMode.CREATE | - blockdev.MDTechMode.DELETE | -@@ -410,6 +417,7 @@ def available_resource(name): - BLOCKDEV_DM_PLUGIN_RAID = blockdev_plugin("dm", BLOCKDEV_DM_TECH_RAID) - BLOCKDEV_LOOP_PLUGIN = blockdev_plugin("loop", BLOCKDEV_LOOP_TECH) - BLOCKDEV_LVM_PLUGIN = blockdev_plugin("lvm", BLOCKDEV_LVM_TECH) -+BLOCKDEV_LVM_PLUGIN_VDO = blockdev_plugin("lvm", BLOCKDEV_LVM_TECH_VDO) - BLOCKDEV_MDRAID_PLUGIN = blockdev_plugin("mdraid", BLOCKDEV_MD_TECH) - BLOCKDEV_MPATH_PLUGIN = blockdev_plugin("mpath", BLOCKDEV_MPATH_TECH) - BLOCKDEV_SWAP_PLUGIN = blockdev_plugin("swap", BLOCKDEV_SWAP_TECH) - -From d782620129d47a7b79b0e6b80455e6d93f8bcc88 Mon Sep 17 00:00:00 2001 -From: Vojtech Trefny -Date: Mon, 2 Nov 2020 14:27:55 +0100 -Subject: [PATCH 04/17] Read the LVM VDO pool current size from the internal - data LV - -The pool device mapper device size is always 512k when active. ---- - blivet/devices/lvm.py | 9 +++++++++ - 1 file changed, 9 insertions(+) - -diff --git a/blivet/devices/lvm.py b/blivet/devices/lvm.py -index ffc65dcd..73743fa8 100644 ---- a/blivet/devices/lvm.py -+++ b/blivet/devices/lvm.py -@@ -1845,6 +1845,15 @@ def direct(self): - """ Is this device directly accessible? """ - return False - -+ def read_current_size(self): -+ log_method_call(self, exists=self.exists, path=self.path, -+ sysfs_path=self.sysfs_path) -+ if self.size != Size(0): -+ return self.size -+ if self._vdopool_data_lv: -+ return self._vdopool_data_lv.read_current_size() -+ return Size(0) -+ - def _create(self): - """ Create the device. """ - raise NotImplementedError - -From 2da48ae84f4eac84e8cf998ee2402249a5a52626 Mon Sep 17 00:00:00 2001 -From: Vojtech Trefny -Date: Mon, 2 Nov 2020 14:29:43 +0100 -Subject: [PATCH 05/17] Add "vdo_lv" property to LVMVDOPoolMixin - ---- - blivet/devices/lvm.py | 7 +++++++ - 1 file changed, 7 insertions(+) - -diff --git a/blivet/devices/lvm.py b/blivet/devices/lvm.py -index 73743fa8..2f93fa22 100644 ---- a/blivet/devices/lvm.py -+++ b/blivet/devices/lvm.py -@@ -1840,6 +1840,13 @@ def lvs(self): - """ A list of this VDO pool's LVs """ - return self._lvs[:] # we don't want folks changing our list - -+ @property -+ @util.requires_property("is_vdo_pool") -+ def vdo_lv(self): -+ if not self._lvs: -+ return None -+ return self._lvs[0] -+ - @property - def direct(self): - """ Is this device directly accessible? """ - -From bbfa2cbdc6cb85d405b895c66eb4867cea4218b4 Mon Sep 17 00:00:00 2001 -From: Vojtech Trefny -Date: Mon, 2 Nov 2020 14:30:37 +0100 -Subject: [PATCH 06/17] Add support for creating LVM VDO pools and LVM VDO - volumes - -The pool and the volume are created by one call but these can have -different properties (like size) and are in fact two block devices -when created, we also need to create two devices and add them to -the devicetree. The pool device must be always created first and -the _create function for the VDO volume is a no-op. ---- - blivet/devices/lvm.py | 63 +++++++++++++++++++++++++++++++++++++------ - 1 file changed, 55 insertions(+), 8 deletions(-) - -diff --git a/blivet/devices/lvm.py b/blivet/devices/lvm.py -index 2f93fa22..0802e2de 100644 ---- a/blivet/devices/lvm.py -+++ b/blivet/devices/lvm.py -@@ -311,7 +311,7 @@ def _add_log_vol(self, lv): - - # verify we have the space, then add it - # do not verify for growing vg (because of ks) -- if not lv.exists and not self.growable and not lv.is_thin_lv and lv.size > self.free_space: -+ if not lv.exists and not self.growable and not (lv.is_thin_lv or lv.is_vdo_lv) and lv.size > self.free_space: - raise errors.DeviceError("new lv is too large to fit in free space", self.name) - - log.debug("Adding %s/%s to %s", lv.name, lv.size, self.name) -@@ -639,7 +639,7 @@ def __init__(self, name, parents=None, size=None, uuid=None, seg_type=None, - percent=None, cache_request=None, pvs=None, from_lvs=None): - - if not exists: -- if seg_type not in [None, "linear", "thin", "thin-pool", "cache"] + lvm.raid_seg_types: -+ if seg_type not in [None, "linear", "thin", "thin-pool", "cache", "vdo-pool", "vdo"] + lvm.raid_seg_types: - raise ValueError("Invalid or unsupported segment type: %s" % seg_type) - if seg_type and seg_type in lvm.raid_seg_types and not pvs: - raise ValueError("List of PVs has to be given for every non-linear LV") -@@ -1793,7 +1793,11 @@ class LVMVDOPoolMixin(object): - - _external_dependencies = [availability.BLOCKDEV_LVM_PLUGIN, availability.BLOCKDEV_LVM_PLUGIN_VDO] - -- def __init__(self): -+ def __init__(self, compression=True, deduplication=True, index_memory=0, write_policy=None): -+ self.compression = compression -+ self.deduplication = deduplication -+ self.index_memory = index_memory -+ self.write_policy = write_policy - self._lvs = [] - - @property -@@ -1863,7 +1867,19 @@ def read_current_size(self): - - def _create(self): - """ Create the device. """ -- raise NotImplementedError -+ -+ if not self.vdo_lv: -+ raise errors.DeviceError("Cannot create new VDO pool without a VDO LV.") -+ -+ if self.write_policy: -+ write_policy = blockdev.lvm_get_vdo_write_policy_str(self.write_policy) -+ else: -+ write_policy = blockdev.LVMVDOWritePolicy.AUTO -+ -+ blockdev.lvm.vdo_pool_create(self.vg.name, self.vdo_lv.lvname, self.lvname, -+ self.size, self.vdo_lv.size, self.index_memory, -+ self.compression, self.deduplication, -+ write_policy) - - - class LVMVDOLogicalVolumeMixin(object): -@@ -1915,9 +1931,26 @@ def resizable(self): - def pool(self): - return self.parents[0] - -+ def _set_size(self, newsize): -+ if not isinstance(newsize, Size): -+ raise AttributeError("new size must of type Size") -+ -+ newsize = self.vg.align(newsize) -+ newsize = self.vg.align(util.numeric_type(newsize)) -+ # just make sure the size is set (no VG size/free space check needed for -+ # a VDO LV) -+ DMDevice._set_size(self, newsize) -+ -+ def _pre_create(self): -+ # skip LVMLogicalVolumeDevice's _pre_create() method as it checks for a -+ # free space in a VG which doesn't make sense for a VDO LV and causes a -+ # bug by limitting the VDO LV's size to VG free space which is nonsense -+ super(LVMLogicalVolumeBase, self)._pre_create() # pylint: disable=bad-super-call -+ - def _create(self): -- """ Create the device. """ -- raise NotImplementedError -+ # nothing to do here, VDO LV is created automatically together with -+ # the VDO pool -+ pass - - def _destroy(self): - # nothing to do here, VDO LV is destroyed automatically together with -@@ -1953,7 +1986,9 @@ def __init__(self, name, parents=None, size=None, uuid=None, seg_type=None, - fmt=None, exists=False, sysfs_path='', grow=None, maxsize=None, - percent=None, cache_request=None, pvs=None, - parent_lv=None, int_type=None, origin=None, vorigin=False, -- metadata_size=None, chunk_size=None, profile=None, from_lvs=None): -+ metadata_size=None, chunk_size=None, profile=None, from_lvs=None, -+ compression=False, deduplication=False, index_memory=0, -+ write_policy=None): - """ - :param name: the device name (generally a device node's basename) - :type name: str -@@ -2012,6 +2047,17 @@ def __init__(self, name, parents=None, size=None, uuid=None, seg_type=None, - :keyword from_lvs: LVs to create the new LV from (in the (data_lv, metadata_lv) order) - :type from_lvs: tuple of :class:`LVMLogicalVolumeDevice` - -+ For VDO pools only: -+ -+ :keyword compression: whether to enable compression on the VDO pool -+ :type compression: bool -+ :keyword dudplication: whether to enable dudplication on the VDO pool -+ :type dudplication: bool -+ :keyword index_memory: amount of index memory (in bytes) or 0 for default -+ :type index_memory: int -+ :keyword write_policy: write policy for the volume or None for default -+ :type write_policy: str -+ - """ - - if isinstance(parents, (list, ParentList)): -@@ -2032,7 +2078,8 @@ def __init__(self, name, parents=None, size=None, uuid=None, seg_type=None, - LVMLogicalVolumeBase.__init__(self, name, parents, size, uuid, seg_type, - fmt, exists, sysfs_path, grow, maxsize, - percent, cache_request, pvs, from_lvs) -- LVMVDOPoolMixin.__init__(self) -+ LVMVDOPoolMixin.__init__(self, compression, deduplication, index_memory, -+ write_policy) - LVMVDOLogicalVolumeMixin.__init__(self) - - LVMInternalLogicalVolumeMixin._init_check(self) - -From 2d1593b50dc6232e213b4df86dfbf5cf6d282dcd Mon Sep 17 00:00:00 2001 -From: Vojtech Trefny -Date: Mon, 2 Nov 2020 14:31:35 +0100 -Subject: [PATCH 07/17] Allow creating LVM VDO pools and volumes using - "blivet.new_lv" - -The steps to create the VDO devices would typically look like: - -pool = b.new_lv(vdo_pool=True, parents=[data], size=Size("8 GiB")) -vdolv = b.new_lv(vdo_lv=True, parents=[pool], size=Size("40 GiB")) -b.create_device(pool) -b.create_device(vdolv) -b.do_it() ---- - blivet/blivet.py | 18 ++++++++++++++---- - tests/devices_test/lvm_test.py | 31 +++++++++++++++++++++++++++++++ - 2 files changed, 45 insertions(+), 4 deletions(-) - -diff --git a/blivet/blivet.py b/blivet/blivet.py -index e7dbd37b..754eb152 100644 ---- a/blivet/blivet.py -+++ b/blivet/blivet.py -@@ -573,6 +573,10 @@ def new_lv(self, *args, **kwargs): - :type thin_pool: bool - :keyword thin_volume: whether to create a thin volume - :type thin_volume: bool -+ :keyword vdo_pool: whether to create a vdo pool -+ :type vdo_pool: bool -+ :keyword vdo_lv: whether to create a vdo lv -+ :type vdo_lv: bool - :returns: the new device - :rtype: :class:`~.devices.LVMLogicalVolumeDevice` - -@@ -589,8 +593,10 @@ def new_lv(self, *args, **kwargs): - """ - thin_volume = kwargs.pop("thin_volume", False) - thin_pool = kwargs.pop("thin_pool", False) -+ vdo_pool = kwargs.pop("vdo_pool", False) -+ vdo_lv = kwargs.pop("vdo_lv", False) - parent = kwargs.get("parents", [None])[0] -- if thin_volume and parent: -+ if (thin_volume or vdo_lv) and parent: - # kwargs["parents"] will contain the pool device, so... - vg = parent.vg - else: -@@ -600,6 +606,10 @@ def new_lv(self, *args, **kwargs): - kwargs["seg_type"] = "thin" - if thin_pool: - kwargs["seg_type"] = "thin-pool" -+ if vdo_pool: -+ kwargs["seg_type"] = "vdo-pool" -+ if vdo_lv: -+ kwargs["seg_type"] = "vdo" - - mountpoint = kwargs.pop("mountpoint", None) - if 'fmt_type' in kwargs: -@@ -625,7 +635,7 @@ def new_lv(self, *args, **kwargs): - swap = False - - prefix = "" -- if thin_pool: -+ if thin_pool or vdo_pool: - prefix = "pool" - - name = self.suggest_device_name(parent=vg, -@@ -636,10 +646,10 @@ def new_lv(self, *args, **kwargs): - if "%s-%s" % (vg.name, name) in self.names: - raise ValueError("name already in use") - -- if thin_pool or thin_volume: -+ if thin_pool or thin_volume or vdo_pool or vdo_lv: - cache_req = kwargs.pop("cache_request", None) - if cache_req: -- raise ValueError("Creating cached thin volumes and pools is not supported") -+ raise ValueError("Creating cached thin and VDO volumes and pools is not supported") - - return LVMLogicalVolumeDevice(name, *args, **kwargs) - -diff --git a/tests/devices_test/lvm_test.py b/tests/devices_test/lvm_test.py -index 204cb99a..493d3ba1 100644 ---- a/tests/devices_test/lvm_test.py -+++ b/tests/devices_test/lvm_test.py -@@ -689,3 +689,34 @@ def test_new_lv_from_non_existing_lvs(self): - with patch.object(pool, "_pre_create"): - pool.create() - self.assertTrue(lvm.thpool_convert.called) -+ -+ def test_new_vdo_pool(self): -+ b = blivet.Blivet() -+ pv = StorageDevice("pv1", fmt=blivet.formats.get_format("lvmpv"), -+ size=Size("10 GiB"), exists=True) -+ vg = LVMVolumeGroupDevice("testvg", parents=[pv], exists=True) -+ -+ for dev in (pv, vg): -+ b.devicetree._add_device(dev) -+ -+ # check that all the above devices are in the expected places -+ self.assertEqual(set(b.devices), {pv, vg}) -+ self.assertEqual(set(b.vgs), {vg}) -+ -+ self.assertEqual(vg.size, Size("10236 MiB")) -+ -+ vdopool = b.new_lv(name="vdopool", vdo_pool=True, -+ parents=[vg], compression=True, -+ deduplication=True, -+ size=blivet.size.Size("8 GiB")) -+ -+ vdolv = b.new_lv(name="vdolv", vdo_lv=True, -+ parents=[vdopool], -+ size=blivet.size.Size("40 GiB")) -+ -+ b.create_device(vdopool) -+ b.create_device(vdolv) -+ -+ self.assertEqual(vdopool.children[0], vdolv) -+ self.assertEqual(vdolv.parents[0], vdopool) -+ self.assertListEqual(vg.lvs, [vdopool, vdolv]) - -From 31ec429ad7bd0857a768e2dfebe1de088dafc144 Mon Sep 17 00:00:00 2001 -From: Vojtech Trefny -Date: Mon, 2 Nov 2020 14:32:47 +0100 -Subject: [PATCH 08/17] Add LVM VDO device factory - ---- - blivet/devicefactory.py | 100 +++++++++++++++++++++++++++- - tests/devicefactory_test.py | 128 +++++++++++++++++++++++++++++++++--- - 2 files changed, 218 insertions(+), 10 deletions(-) - -diff --git a/blivet/devicefactory.py b/blivet/devicefactory.py -index 9214ad54..c95037cc 100644 ---- a/blivet/devicefactory.py -+++ b/blivet/devicefactory.py -@@ -27,7 +27,7 @@ - from .devices import BTRFSDevice, DiskDevice - from .devices import LUKSDevice, LVMLogicalVolumeDevice - from .devices import PartitionDevice, MDRaidArrayDevice --from .devices.lvm import DEFAULT_THPOOL_RESERVE -+from .devices.lvm import LVMVDOPoolMixin, DEFAULT_THPOOL_RESERVE - from .formats import get_format - from .devicelibs import btrfs - from .devicelibs import mdraid -@@ -58,6 +58,7 @@ - DEVICE_TYPE_BTRFS = 3 - DEVICE_TYPE_DISK = 4 - DEVICE_TYPE_LVM_THINP = 5 -+DEVICE_TYPE_LVM_VDO = 6 - - - def is_supported_device_type(device_type): -@@ -69,6 +70,9 @@ def is_supported_device_type(device_type): - :returns: True if this device type is supported - :rtype: bool - """ -+ if device_type == DEVICE_TYPE_LVM_VDO: -+ return not any(e for e in LVMVDOPoolMixin._external_dependencies if not e.available) -+ - devices = [] - if device_type == DEVICE_TYPE_BTRFS: - devices = [BTRFSDevice] -@@ -96,7 +100,7 @@ def get_supported_raid_levels(device_type): - pkg = None - if device_type == DEVICE_TYPE_BTRFS: - pkg = btrfs -- elif device_type in (DEVICE_TYPE_LVM, DEVICE_TYPE_LVM_THINP): -+ elif device_type in (DEVICE_TYPE_LVM, DEVICE_TYPE_LVM_THINP, DEVICE_TYPE_LVM_VDO): - pkg = lvm - elif device_type == DEVICE_TYPE_MD: - pkg = mdraid -@@ -116,6 +120,8 @@ def get_device_type(device): - "lvmlv": DEVICE_TYPE_LVM, - "lvmthinlv": DEVICE_TYPE_LVM_THINP, - "lvmthinpool": DEVICE_TYPE_LVM, -+ "lvmvdolv": DEVICE_TYPE_LVM_VDO, -+ "lvmvdopool": DEVICE_TYPE_LVM, - "btrfs subvolume": DEVICE_TYPE_BTRFS, - "btrfs volume": DEVICE_TYPE_BTRFS, - "mdarray": DEVICE_TYPE_MD} -@@ -136,6 +142,7 @@ def get_device_factory(blivet, device_type=DEVICE_TYPE_LVM, **kwargs): - DEVICE_TYPE_PARTITION: PartitionFactory, - DEVICE_TYPE_MD: MDFactory, - DEVICE_TYPE_LVM_THINP: LVMThinPFactory, -+ DEVICE_TYPE_LVM_VDO: LVMVDOFactory, - DEVICE_TYPE_DISK: DeviceFactory} - - factory_class = class_table[device_type] -@@ -1738,6 +1745,95 @@ def _get_new_device(self, *args, **kwargs): - return super(LVMThinPFactory, self)._get_new_device(*args, **kwargs) - - -+class LVMVDOFactory(LVMFactory): -+ -+ """ Factory for creating LVM VDO volumes. -+ -+ :keyword pool_name: name for the VDO pool, if not specified unique name will be generated -+ :type pool_name: str -+ :keyword virtual_size: size for the VDO volume, usually bigger than pool size, if not -+ specified physical size (pool size) will be used -+ :type size: :class:`~.size.Size` -+ :keyword compression: whether to enable compression (defaults to True) -+ :type compression: bool -+ :keyword deduplication: whether to enable deduplication (defaults to True) -+ :type deduplication: bool -+ """ -+ -+ def __init__(self, storage, **kwargs): -+ self.pool_name = kwargs.pop("pool_name", None) -+ self.virtual_size = kwargs.pop("virtual_size", None) -+ self.compression = kwargs.pop("compression", True) -+ self.deduplication = kwargs.pop("deduplication", True) -+ super(LVMVDOFactory, self).__init__(storage, **kwargs) -+ -+ def _get_new_pool(self, *args, **kwargs): -+ kwargs["vdo_pool"] = True -+ return super(LVMVDOFactory, self)._get_new_device(*args, **kwargs) -+ -+ def _set_device_size(self): -+ """ Set the size of the factory device. """ -+ super(LVMVDOFactory, self)._set_device_size() -+ -+ self.device.pool.size = self.size -+ self._reconfigure_container() -+ -+ if not self.virtual_size or self.virtual_size < self.size: -+ # virtual_size is not set or smaller than current size --> it should be same as the pool size -+ self.device.size = self.size -+ else: -+ self.device.size = self.virtual_size -+ -+ def _set_pool_name(self): -+ safe_new_name = self.storage.safe_device_name(self.pool_name) -+ if self.device.pool.name != safe_new_name: -+ if not safe_new_name: -+ log.error("not renaming '%s' to invalid name '%s'", -+ self.device.pool.name, self.pool_name) -+ return -+ if safe_new_name in self.storage.names: -+ log.error("not renaming '%s' to in-use name '%s'", -+ self.device.pool.name, safe_new_name) -+ return -+ -+ log.debug("renaming device '%s' to '%s'", -+ self.device.pool.name, safe_new_name) -+ self.device.pool.raw_device.name = safe_new_name -+ -+ def _set_name(self): -+ super(LVMVDOFactory, self)._set_name() -+ if self.pool_name: -+ self._set_pool_name() -+ -+ def _reconfigure_device(self): -+ super(LVMVDOFactory, self)._reconfigure_device() -+ -+ self.device.pool.compression = self.compression -+ self.device.pool.deduplication = self.deduplication -+ -+ # -+ # methods to configure the factory's device -+ # -+ def _get_new_device(self, *args, **kwargs): -+ """ Create and return the factory device as a StorageDevice. """ -+ pool = self._get_new_pool(name=self.pool_name, -+ size=self.size, -+ parents=[self.vg], -+ compression=self.compression, -+ deduplication=self.deduplication) -+ self.storage.create_device(pool) -+ -+ kwargs["parents"] = [pool] -+ kwargs["vdo_lv"] = True -+ -+ if self.virtual_size: -+ vdolv_kwargs = kwargs.copy() -+ vdolv_kwargs["size"] = self.virtual_size -+ else: -+ vdolv_kwargs = kwargs -+ return super(LVMVDOFactory, self)._get_new_device(*args, **vdolv_kwargs) -+ -+ - class MDFactory(DeviceFactory): - - """ Factory for creating MD RAID devices. """ -diff --git a/tests/devicefactory_test.py b/tests/devicefactory_test.py -index 08068779..7cdb51c5 100644 ---- a/tests/devicefactory_test.py -+++ b/tests/devicefactory_test.py -@@ -4,6 +4,9 @@ - from decimal import Decimal - import os - -+import test_compat # pylint: disable=unused-import -+from six.moves.mock import patch # pylint: disable=no-name-in-module,import-error -+ - import blivet - - from blivet import devicefactory -@@ -93,10 +96,12 @@ def _validate_factory_device(self, *args, **kwargs): - self.assertEqual(device.format.label, - kwargs.get('label')) - -- self.assertLessEqual(device.size, kwargs.get("size")) -- self.assertGreaterEqual(device.size, device.format.min_size) -- if device.format.max_size: -- self.assertLessEqual(device.size, device.format.max_size) -+ # sizes with VDO are special, we have a special check in LVMVDOFactoryTestCase._validate_factory_device -+ if device_type != devicefactory.DEVICE_TYPE_LVM_VDO: -+ self.assertLessEqual(device.size, kwargs.get("size")) -+ self.assertGreaterEqual(device.size, device.format.min_size) -+ if device.format.max_size: -+ self.assertLessEqual(device.size, device.format.max_size) - - self.assertEqual(device.encrypted, - kwargs.get("encrypted", False) or -@@ -115,7 +120,11 @@ def test_device_factory(self): - "mountpoint": '/factorytest'} - device = self._factory_device(device_type, **kwargs) - self._validate_factory_device(device, device_type, **kwargs) -- self.b.recursive_remove(device) -+ -+ if device.type == "lvmvdolv": -+ self.b.recursive_remove(device.pool) -+ else: -+ self.b.recursive_remove(device) - - if self.encryption_supported: - # Encrypt the leaf device -@@ -157,6 +166,12 @@ def test_device_factory(self): - device = self._factory_device(device_type, **kwargs) - self._validate_factory_device(device, device_type, **kwargs) - -+ # change size up -+ kwargs["device"] = device -+ kwargs["size"] = Size("900 MiB") -+ device = self._factory_device(device_type, **kwargs) -+ self._validate_factory_device(device, device_type, **kwargs) -+ - # Change LUKS version - kwargs["luks_version"] = "luks1" - device = self._factory_device(device_type, **kwargs) -@@ -179,7 +194,7 @@ def _get_size_delta(self, devices=None): - """ - return Size("1 MiB") - -- def test_get_free_disk_space(self): -+ def test_get_free_disk_space(self, *args): # pylint: disable=unused-argument - # get_free_disk_space should return the total free space on disks - kwargs = self._get_test_factory_args() - kwargs["size"] = Size("500 MiB") -@@ -206,7 +221,7 @@ def test_get_free_disk_space(self): - sum(d.size for d in self.b.disks) - device_space, - delta=self._get_size_delta(devices=[device])) - -- def test_normalize_size(self): -+ def test_normalize_size(self, *args): # pylint: disable=unused-argument - # _normalize_size should adjust target size to within the format limits - fstype = "ext2" - ext2 = get_format(fstype) -@@ -258,7 +273,7 @@ def test_default_factory_type(self): - factory = devicefactory.get_device_factory(self.b) - self.assertIsInstance(factory, devicefactory.LVMFactory) - -- def test_factory_defaults(self): -+ def test_factory_defaults(self, *args): # pylint: disable=unused-argument - ctor_kwargs = self._get_test_factory_args() - factory = devicefactory.get_device_factory(self.b, self.device_type, **ctor_kwargs) - for setting, value in factory._default_settings.items(): -@@ -522,6 +537,103 @@ def _get_size_delta(self, devices=None): - return delta - - -+class LVMVDOFactoryTestCase(LVMFactoryTestCase): -+ device_class = LVMLogicalVolumeDevice -+ device_type = devicefactory.DEVICE_TYPE_LVM_VDO -+ encryption_supported = False -+ -+ def _validate_factory_device(self, *args, **kwargs): -+ super(LVMVDOFactoryTestCase, self)._validate_factory_device(*args, -+ **kwargs) -+ device = args[0] -+ -+ if kwargs.get("encrypted", False): -+ vdolv = device.parents[0] -+ else: -+ vdolv = device -+ -+ self.assertTrue(hasattr(vdolv, "pool")) -+ -+ virtual_size = kwargs.get("virtual_size", 0) -+ if virtual_size: -+ self.assertEqual(vdolv.size, virtual_size) -+ else: -+ self.assertEqual(vdolv.size, vdolv.pool.size) -+ self.assertGreaterEqual(vdolv.size, vdolv.pool.size) -+ -+ compression = kwargs.get("compression", True) -+ self.assertEqual(vdolv.pool.compression, compression) -+ -+ deduplication = kwargs.get("deduplication", True) -+ self.assertEqual(vdolv.pool.deduplication, deduplication) -+ -+ pool_name = kwargs.get("pool_name", None) -+ if pool_name: -+ self.assertEqual(vdolv.pool.lvname, pool_name) -+ -+ return device -+ -+ @patch("blivet.formats.lvmpv.LVMPhysicalVolume.formattable", return_value=True) -+ @patch("blivet.formats.lvmpv.LVMPhysicalVolume.destroyable", return_value=True) -+ @patch("blivet.static_data.lvm_info.blockdev.lvm.lvs", return_value=[]) -+ @patch("blivet.devices.lvm.LVMVolumeGroupDevice.type_external_dependencies", return_value=set()) -+ @patch("blivet.devices.lvm.LVMLogicalVolumeBase.type_external_dependencies", return_value=set()) -+ def test_device_factory(self, *args): # pylint: disable=unused-argument,arguments-differ -+ device_type = self.device_type -+ kwargs = {"disks": self.b.disks, -+ "size": Size("400 MiB"), -+ "fstype": 'ext4', -+ "mountpoint": '/factorytest'} -+ device = self._factory_device(device_type, **kwargs) -+ self._validate_factory_device(device, device_type, **kwargs) -+ self.b.recursive_remove(device.pool) -+ -+ kwargs = {"disks": self.b.disks, -+ "size": Size("400 MiB"), -+ "fstype": 'ext4', -+ "mountpoint": '/factorytest', -+ "pool_name": "vdopool", -+ "deduplication": True, -+ "compression": True} -+ device = self._factory_device(device_type, **kwargs) -+ self._validate_factory_device(device, device_type, **kwargs) -+ -+ # change size without specifying virtual_size: both sizes should grow -+ kwargs["size"] = Size("600 MiB") -+ kwargs["device"] = device -+ device = self._factory_device(device_type, **kwargs) -+ self._validate_factory_device(device, device_type, **kwargs) -+ -+ # change virtual size -+ kwargs["virtual_size"] = Size("6 GiB") -+ kwargs["device"] = device -+ device = self._factory_device(device_type, **kwargs) -+ self._validate_factory_device(device, device_type, **kwargs) -+ -+ # change virtual size to smaller than size -+ kwargs["virtual_size"] = Size("500 GiB") -+ kwargs["device"] = device -+ device = self._factory_device(device_type, **kwargs) -+ self._validate_factory_device(device, device_type, **kwargs) -+ -+ # change deduplication and compression -+ kwargs["deduplication"] = False -+ kwargs["device"] = device -+ device = self._factory_device(device_type, **kwargs) -+ self._validate_factory_device(device, device_type, **kwargs) -+ -+ kwargs["compression"] = False -+ kwargs["device"] = device -+ device = self._factory_device(device_type, **kwargs) -+ self._validate_factory_device(device, device_type, **kwargs) -+ -+ # rename the pool -+ kwargs["pool_name"] = "vdopool2" -+ kwargs["device"] = device -+ device = self._factory_device(device_type, **kwargs) -+ self._validate_factory_device(device, device_type, **kwargs) -+ -+ - class MDFactoryTestCase(DeviceFactoryTestCase): - device_type = devicefactory.DEVICE_TYPE_MD - device_class = MDRaidArrayDevice - -From 22ba2b96111d5f153a3b55d3c56d84e597cf9a90 Mon Sep 17 00:00:00 2001 -From: Vojtech Trefny -Date: Mon, 2 Nov 2020 14:33:06 +0100 -Subject: [PATCH 09/17] Add VM test for LVM VDO - ---- - tests/vmtests/blivet_reset_vmtest.py | 15 +++++++++++++++ - tests/vmtests/runvmtests.py | 3 ++- - 2 files changed, 17 insertions(+), 1 deletion(-) - -diff --git a/tests/vmtests/blivet_reset_vmtest.py b/tests/vmtests/blivet_reset_vmtest.py -index 8743d51e..47fc84c4 100644 ---- a/tests/vmtests/blivet_reset_vmtest.py -+++ b/tests/vmtests/blivet_reset_vmtest.py -@@ -192,6 +192,21 @@ def setUp(self): - self.collect_expected_data() - - -+class LVMVDOTestCase(BlivetResetTestCase): -+ -+ def _set_up_storage(self): -+ if not devicefactory.is_supported_device_type(devicefactory.DEVICE_TYPE_LVM_VDO): -+ self.skipTest("VDO not supported, skipping") -+ -+ self.blivet.factory_device(devicefactory.DEVICE_TYPE_LVM_VDO, -+ size=Size("10 GiB"), -+ fstype="ext4", -+ disks=self.blivet.disks[:], -+ name="vdolv", -+ pool_name="vdopool", -+ virtual_size=Size("40 GiB")) -+ -+ - @unittest.skip("temporarily disabled due to issues with raids with metadata version 0.90") - class MDRaid0TestCase(BlivetResetTestCase): - -diff --git a/tests/vmtests/runvmtests.py b/tests/vmtests/runvmtests.py -index 88143d3a..6f20484f 100644 ---- a/tests/vmtests/runvmtests.py -+++ b/tests/vmtests/runvmtests.py -@@ -12,7 +12,8 @@ - "tests.vmtests.blivet_reset_vmtest.LVMThinSnapShotTestCase", - "tests.vmtests.blivet_reset_vmtest.LVMRaidTestCase", - "tests.vmtests.blivet_reset_vmtest.MDRaid0TestCase", -- "tests.vmtests.blivet_reset_vmtest.LVMOnMDTestCase"] -+ "tests.vmtests.blivet_reset_vmtest.LVMOnMDTestCase", -+ "tests.vmtests.blivet_reset_vmtest.LVMVDOTestCase"] - - SNAP_NAME = "snapshot" - - -From 52b37bb86e856f1ede71f7cceb7284a639d741f4 Mon Sep 17 00:00:00 2001 -From: Vojtech Trefny -Date: Thu, 19 Nov 2020 13:07:17 +0100 -Subject: [PATCH 10/17] Allow adding nodiscard option when running mkfs - -For filesystems that support it we might want to add some nodiscard -option to mkfs when creating format on devices like LVM VDO -volumes where discard is very slow and doesn't really makes sense -when running mkfs. ---- - blivet/formats/fs.py | 12 +++++- - blivet/tasks/fsmkfs.py | 59 +++++++++++++++++++++++++++--- - tests/formats_test/methods_test.py | 3 +- - 3 files changed, 66 insertions(+), 8 deletions(-) - -diff --git a/blivet/formats/fs.py b/blivet/formats/fs.py -index 4ba83e6d..e61e5b86 100644 ---- a/blivet/formats/fs.py -+++ b/blivet/formats/fs.py -@@ -132,6 +132,7 @@ def __init__(self, **kwargs): - self.mountopts = kwargs.get("mountopts", "") - self.label = kwargs.get("label") - self.fsprofile = kwargs.get("fsprofile") -+ self._mkfs_nodiscard = kwargs.get("nodiscard", False) - - self._user_mountopts = self.mountopts - -@@ -263,6 +264,14 @@ def label_format_ok(self, label): - label = property(lambda s: s._get_label(), lambda s, l: s._set_label(l), - doc="this filesystem's label") - -+ def can_nodiscard(self): -+ """Returns True if this filesystem supports nodiscard option during -+ creation, otherwise False. -+ -+ :rtype: bool -+ """ -+ return self._mkfs.can_nodiscard and self._mkfs.available -+ - def can_set_uuid(self): - """Returns True if this filesystem supports setting an UUID during - creation, otherwise False. -@@ -402,7 +411,8 @@ def _create(self, **kwargs): - try: - self._mkfs.do_task(options=kwargs.get("options"), - label=not self.relabels(), -- set_uuid=self.can_set_uuid()) -+ set_uuid=self.can_set_uuid(), -+ nodiscard=self.can_nodiscard()) - except FSWriteLabelError as e: - log.warning("Choosing not to apply label (%s) during creation of filesystem %s. Label format is unacceptable for this filesystem.", self.label, self.type) - except FSWriteUUIDError as e: -diff --git a/blivet/tasks/fsmkfs.py b/blivet/tasks/fsmkfs.py -index ad166aa0..c982f7e7 100644 ---- a/blivet/tasks/fsmkfs.py -+++ b/blivet/tasks/fsmkfs.py -@@ -37,6 +37,7 @@ class FSMkfsTask(fstask.FSTask): - - can_label = abc.abstractproperty(doc="whether this task labels") - can_set_uuid = abc.abstractproperty(doc="whether this task can set UUID") -+ can_nodiscard = abc.abstractproperty(doc="whether this task can set nodiscard option") - - - @add_metaclass(abc.ABCMeta) -@@ -48,6 +49,9 @@ class FSMkfs(task.BasicApplication, FSMkfsTask): - label_option = abc.abstractproperty( - doc="Option for setting a filesystem label.") - -+ nodiscard_option = abc.abstractproperty( -+ doc="Option for setting nodiscrad option for mkfs.") -+ - args = abc.abstractproperty(doc="options for creating filesystem") - - @abc.abstractmethod -@@ -80,6 +84,15 @@ def can_set_uuid(self): - """ - return self.get_uuid_args is not None - -+ @property -+ def can_nodiscard(self): -+ """Whether this task can set nodiscard option for a filesystem. -+ -+ :returns: True if nodiscard can be set -+ :rtype: bool -+ """ -+ return self.nodiscard_option is not None -+ - @property - def _label_options(self): - """ Any labeling options that a particular filesystem may use. -@@ -100,6 +113,23 @@ def _label_options(self): - else: - raise FSWriteLabelError("Choosing not to apply label (%s) during creation of filesystem %s. Label format is unacceptable for this filesystem." % (self.fs.label, self.fs.type)) - -+ @property -+ def _nodiscard_option(self): -+ """ Any nodiscard options that a particular filesystem may use. -+ -+ :returns: nodiscard options -+ :rtype: list of str -+ """ -+ # Do not know how to set nodiscard while formatting. -+ if self.nodiscard_option is None: -+ return [] -+ -+ # nodiscard option not requested -+ if not self.fs._mkfs_nodiscard: -+ return [] -+ -+ return self.nodiscard_option -+ - @property - def _uuid_options(self): - """Any UUID options that a particular filesystem may use. -@@ -119,7 +149,7 @@ def _uuid_options(self): - " is unacceptable for this filesystem." - % (self.fs.uuid, self.fs.type)) - -- def _format_options(self, options=None, label=False, set_uuid=False): -+ def _format_options(self, options=None, label=False, set_uuid=False, nodiscard=False): - """Get a list of format options to be used when creating the - filesystem. - -@@ -135,11 +165,12 @@ def _format_options(self, options=None, label=False, set_uuid=False): - - label_options = self._label_options if label else [] - uuid_options = self._uuid_options if set_uuid else [] -+ nodiscard_option = self._nodiscard_option if nodiscard else [] - create_options = shlex.split(self.fs.create_options or "") - return (options + self.args + label_options + uuid_options + -- create_options + [self.fs.device]) -+ nodiscard_option + create_options + [self.fs.device]) - -- def _mkfs_command(self, options, label, set_uuid): -+ def _mkfs_command(self, options, label, set_uuid, nodiscard): - """Return the command to make the filesystem. - - :param options: any special options -@@ -148,12 +179,14 @@ def _mkfs_command(self, options, label, set_uuid): - :type label: bool - :param set_uuid: whether to set an UUID - :type set_uuid: bool -+ :param nodiscard: whether to run mkfs with nodiscard option -+ :type nodiscard: bool - :returns: the mkfs command - :rtype: list of str - """ -- return [str(self.ext)] + self._format_options(options, label, set_uuid) -+ return [str(self.ext)] + self._format_options(options, label, set_uuid, nodiscard) - -- def do_task(self, options=None, label=False, set_uuid=False): -+ def do_task(self, options=None, label=False, set_uuid=False, nodiscard=False): - """Create the format on the device and label if possible and desired. - - :param options: any special options, may be None -@@ -168,7 +201,7 @@ def do_task(self, options=None, label=False, set_uuid=False): - raise FSError("\n".join(error_msgs)) - - options = options or [] -- cmd = self._mkfs_command(options, label, set_uuid) -+ cmd = self._mkfs_command(options, label, set_uuid, nodiscard) - try: - ret = util.run_program(cmd) - except OSError as e: -@@ -181,6 +214,7 @@ def do_task(self, options=None, label=False, set_uuid=False): - class BTRFSMkfs(FSMkfs): - ext = availability.MKFS_BTRFS_APP - label_option = None -+ nodiscard_option = ["--nodiscard"] - - def get_uuid_args(self, uuid): - return ["-U", uuid] -@@ -193,6 +227,7 @@ def args(self): - class Ext2FSMkfs(FSMkfs): - ext = availability.MKE2FS_APP - label_option = "-L" -+ nodiscard_option = ["-E", "nodiscard"] - - _opts = [] - -@@ -215,6 +250,7 @@ class Ext4FSMkfs(Ext3FSMkfs): - class FATFSMkfs(FSMkfs): - ext = availability.MKDOSFS_APP - label_option = "-n" -+ nodiscard_option = None - - def get_uuid_args(self, uuid): - return ["-i", uuid.replace('-', '')] -@@ -227,6 +263,7 @@ def args(self): - class GFS2Mkfs(FSMkfs): - ext = availability.MKFS_GFS2_APP - label_option = None -+ nodiscard_option = None - get_uuid_args = None - - @property -@@ -237,6 +274,7 @@ def args(self): - class HFSMkfs(FSMkfs): - ext = availability.HFORMAT_APP - label_option = "-l" -+ nodiscard_option = None - get_uuid_args = None - - @property -@@ -247,6 +285,7 @@ def args(self): - class HFSPlusMkfs(FSMkfs): - ext = availability.MKFS_HFSPLUS_APP - label_option = "-v" -+ nodiscard_option = None - get_uuid_args = None - - @property -@@ -257,6 +296,7 @@ def args(self): - class JFSMkfs(FSMkfs): - ext = availability.MKFS_JFS_APP - label_option = "-L" -+ nodiscard_option = None - get_uuid_args = None - - @property -@@ -267,6 +307,7 @@ def args(self): - class NTFSMkfs(FSMkfs): - ext = availability.MKNTFS_APP - label_option = "-L" -+ nodiscard_option = None - get_uuid_args = None - - @property -@@ -277,6 +318,7 @@ def args(self): - class ReiserFSMkfs(FSMkfs): - ext = availability.MKREISERFS_APP - label_option = "-l" -+ nodiscard_option = None - - def get_uuid_args(self, uuid): - return ["-u", uuid] -@@ -289,6 +331,7 @@ def args(self): - class XFSMkfs(FSMkfs): - ext = availability.MKFS_XFS_APP - label_option = "-L" -+ nodiscard_option = ["-K"] - - def get_uuid_args(self, uuid): - return ["-m", "uuid=" + uuid] -@@ -307,3 +350,7 @@ def can_label(self): - @property - def can_set_uuid(self): - return False -+ -+ @property -+ def can_nodiscard(self): -+ return False -diff --git a/tests/formats_test/methods_test.py b/tests/formats_test/methods_test.py -index 710fa1c5..b2674ea7 100644 ---- a/tests/formats_test/methods_test.py -+++ b/tests/formats_test/methods_test.py -@@ -307,7 +307,8 @@ def _test_create_backend(self): - self.format._mkfs.do_task.assert_called_with( - options=None, - label=not self.format.relabels(), -- set_uuid=self.format.can_set_uuid() -+ set_uuid=self.format.can_set_uuid(), -+ nodiscard=self.format.can_nodiscard() - ) - - def _test_setup_backend(self): - -From ac04f74fa9bc8ded3facd302ca74ec033009a0bd Mon Sep 17 00:00:00 2001 -From: Vojtech Trefny -Date: Thu, 19 Nov 2020 13:19:21 +0100 -Subject: [PATCH 11/17] Add nodiscard option by default when creating VDO - logical volumes - -User can override this by passing "nodiscard=False" to the LV -constructor, but we want nodiscard by default. ---- - blivet/blivet.py | 8 +++++++- - blivet/devicefactory.py | 6 ++++++ - tests/devicefactory_test.py | 7 +++++++ - 3 files changed, 20 insertions(+), 1 deletion(-) - -diff --git a/blivet/blivet.py b/blivet/blivet.py -index 754eb152..e4115691 100644 ---- a/blivet/blivet.py -+++ b/blivet/blivet.py -@@ -613,9 +613,15 @@ def new_lv(self, *args, **kwargs): - - mountpoint = kwargs.pop("mountpoint", None) - if 'fmt_type' in kwargs: -+ fmt_args = kwargs.pop("fmt_args", {}) -+ if vdo_lv and "nodiscard" not in fmt_args.keys(): -+ # we don't want to run discard on VDO LV during mkfs so if user don't -+ # tell us not to do it, we should add the nodiscard option to mkfs -+ fmt_args["nodiscard"] = True -+ - kwargs["fmt"] = get_format(kwargs.pop("fmt_type"), - mountpoint=mountpoint, -- **kwargs.pop("fmt_args", {})) -+ **fmt_args) - - name = kwargs.pop("name", None) - if name: -diff --git a/blivet/devicefactory.py b/blivet/devicefactory.py -index c95037cc..085f2fd6 100644 ---- a/blivet/devicefactory.py -+++ b/blivet/devicefactory.py -@@ -1811,6 +1811,12 @@ def _reconfigure_device(self): - self.device.pool.compression = self.compression - self.device.pool.deduplication = self.deduplication - -+ def _set_format(self): -+ super(LVMVDOFactory, self)._set_format() -+ -+ # preserve nodiscard mkfs option after changing filesystem -+ self.device.format._mkfs_nodiscard = True -+ - # - # methods to configure the factory's device - # -diff --git a/tests/devicefactory_test.py b/tests/devicefactory_test.py -index 7cdb51c5..4de1e05b 100644 ---- a/tests/devicefactory_test.py -+++ b/tests/devicefactory_test.py -@@ -571,6 +571,10 @@ def _validate_factory_device(self, *args, **kwargs): - if pool_name: - self.assertEqual(vdolv.pool.lvname, pool_name) - -+ # nodiscard should be always set for VDO LV format -+ if vdolv.format.type: -+ self.assertTrue(vdolv.format._mkfs_nodiscard) -+ - return device - - @patch("blivet.formats.lvmpv.LVMPhysicalVolume.formattable", return_value=True) -@@ -633,6 +637,9 @@ def test_device_factory(self, *args): # pylint: disable=unused-argument,argumen - device = self._factory_device(device_type, **kwargs) - self._validate_factory_device(device, device_type, **kwargs) - -+ # change fstype -+ kwargs["fstype"] = "xfs" -+ - - class MDFactoryTestCase(DeviceFactoryTestCase): - device_type = devicefactory.DEVICE_TYPE_MD - -From 43f25ce84729c321d1ff2bbba2f50489f6d736b4 Mon Sep 17 00:00:00 2001 -From: Vojtech Trefny -Date: Thu, 19 Nov 2020 13:31:40 +0100 -Subject: [PATCH 12/17] Add LVM VDO example - ---- - examples/lvm_vdo.py | 61 +++++++++++++++++++++++++++++++++++++++++++++ - 1 file changed, 61 insertions(+) - create mode 100644 examples/lvm_vdo.py - -diff --git a/examples/lvm_vdo.py b/examples/lvm_vdo.py -new file mode 100644 -index 00000000..ad081642 ---- /dev/null -+++ b/examples/lvm_vdo.py -@@ -0,0 +1,61 @@ -+import os -+ -+import blivet -+from blivet.size import Size -+from blivet.util import set_up_logging, create_sparse_tempfile -+ -+set_up_logging() -+b = blivet.Blivet() # create an instance of Blivet (don't add system devices) -+ -+# create a disk image file on which to create new devices -+disk1_file = create_sparse_tempfile("disk1", Size("100GiB")) -+b.disk_images["disk1"] = disk1_file -+disk2_file = create_sparse_tempfile("disk2", Size("100GiB")) -+b.disk_images["disk2"] = disk2_file -+ -+b.reset() -+ -+try: -+ disk1 = b.devicetree.get_device_by_name("disk1") -+ disk2 = b.devicetree.get_device_by_name("disk2") -+ -+ b.initialize_disk(disk1) -+ b.initialize_disk(disk2) -+ -+ pv = b.new_partition(size=Size("50GiB"), fmt_type="lvmpv", parents=[disk1]) -+ b.create_device(pv) -+ pv2 = b.new_partition(size=Size("50GiB"), fmt_type="lvmpv", parents=[disk2]) -+ b.create_device(pv2) -+ -+ # allocate the partitions (decide where and on which disks they'll reside) -+ blivet.partitioning.do_partitioning(b) -+ -+ vg = b.new_vg(parents=[pv, pv2]) -+ b.create_device(vg) -+ -+ # create 80 GiB VDO pool -+ # there can be only one VDO LV on the pool and these are created together -+ # with one LVM call, we have 2 separate devices because there are two block -+ # devices in the end and it allows to control the different "physical" size of -+ # the pool and "logical" size of the VDO LV (which is usually bigger, accounting -+ # for the saved space with deduplication and/or compression) -+ pool = b.new_lv(size=Size("80GiB"), parents=[vg], name="vdopool", vdo_pool=True, -+ deduplication=True, compression=True) -+ b.create_device(pool) -+ -+ # create the VDO LV with 400 GiB "virtual size" and ext4 filesystem on the VDO -+ # pool -+ lv = b.new_lv(size=Size("400GiB"), parents=[pool], name="vdolv", vdo_lv=True, -+ fmt_type="ext4") -+ b.create_device(lv) -+ -+ print(b.devicetree) -+ -+ # write the new partitions to disk and format them as specified -+ b.do_it() -+ print(b.devicetree) -+ input("Check the state and hit ENTER to trigger cleanup") -+finally: -+ b.devicetree.teardown_disk_images() -+ os.unlink(disk1_file) -+ os.unlink(disk2_file) - -From c487a1e6023b54f5beea8d99ba2f5da5d80590ee Mon Sep 17 00:00:00 2001 -From: Vojtech Trefny -Date: Wed, 25 Nov 2020 13:30:15 +0100 -Subject: [PATCH 13/17] Add LVM VDO documentation - ---- - doc/lvmvdo.rst | 86 ++++++++++++++++++++++++++++++++++++++++++++++++++ - 1 file changed, 86 insertions(+) - create mode 100644 doc/lvmvdo.rst - -diff --git a/doc/lvmvdo.rst b/doc/lvmvdo.rst -new file mode 100644 -index 00000000..3965abd3 ---- /dev/null -+++ b/doc/lvmvdo.rst -@@ -0,0 +1,86 @@ -+LVM VDO support -+=============== -+ -+Support for creating LVM VDO devices has been added in Blivet 3.4. -+ -+These devices are similar to LVM thinly provisioned volumes, but there are some special steps -+and limitations when creating these devices which this document describes. -+ -+LVM VDO in Blivet -+----------------- -+ -+LVM VDO devices are represented by two ``LVMLogicalVolumeDevice`` devices: -+ -+- VDO Pool logical volume with type 'lvmvdopool' -+- VDO logical volume with type 'lvmvdolv' which is the child of the VDO Pool device -+ -+Existing LVM VDO setup in Blivet: -+ -+ existing 20 GiB disk vdb (265) with existing msdos disklabel -+ existing 20 GiB partition vdb1 (275) with existing lvmpv -+ existing 20 GiB lvmvg data (284) -+ existing 10 GiB lvmvdopool data-vdopool (288) -+ existing 50 GiB lvmvdolv data-vdolv (295) -+ -+When creating LVM VDO setup using Blivet these two devices must be created together as these -+are created by a single LVM command. -+ -+It currently isn't possible to create additional VDO logical volumes in the pool. It is however -+possible to create multiple VDO pools in a single volume group. -+ -+Deduplication and compression are properties of the VDO pool. Size specified for the VDO pool -+volume will be used as the "physical" size for the pool and size specified for the VDO logical volume -+will be used as the "virtual" size for the VDO volume. -+ -+When creating format, it must be created on the VDO logical volume. For filesystems with discard -+support, no discard option will be automatically added when calling the ``mkfs`` command -+(e.g. ``-K`` for ``mkfs.xfs``). -+ -+Example for creating a *80 GiB* VDO pool with *400 GiB* VDO logical volume with an *ext4* format with -+both deduplication and compression enabled: -+ -+ pool = b.new_lv(size=Size("80GiB"), parents=[vg], name="vdopool", vdo_pool=True, -+ deduplication=True, compression=True) -+ b.create_device(pool) -+ -+ lv = b.new_lv(size=Size("400GiB"), parents=[pool], name="vdolv", vdo_lv=True, -+ fmt_type="ext4") -+ b.create_device(lv) -+ -+When removing existing LVM VDO devices, both devices must be removed from the devicetree and the VDO -+logical volume must be removed first (``recursive_remove`` can be used to automate these two steps). -+ -+Managing of existing LVM VDO devices is currently not supported. -+ -+ -+LVM VDO in Devicefactory -+------------------------ -+ -+For the top-down specified creation using device factories a new ``LVMVDOFactory`` factory has been -+added. Factory device in this case is the VDO logical volume and is again automatically created -+together with the VDO pool. -+ -+Example of creating a new LVM VDO setup using the ``devicefactory`` module: -+ -+ factory = blivet.devicefactory.LVMVDOFactory(b, size=Size("5 GiB"), virtual_size=Size("50 GiB"), -+ disks=disks, fstype="xfs", -+ container_name="data", -+ pool_name="myvdopool", -+ compression=True, deduplication=True) -+ factory.configure() -+ factory.device -+ -+ LVMLogicalVolumeDevice instance (0x7f14d17422b0) -- -+ name = data-00 status = False id = 528 -+ children = [] -+ parents = ['non-existent 5 GiB lvmvdopool data-myvdopool (519)'] -+ ... -+ -+``size`` in this case sets the pool (physical) size, the VDO logical volume size can be specified -+with ``virtual_size`` (if not specified it will be same as the pool size). Name for the VDO volume -+can be specified using the ``name`` keyword argument. ``pool_name`` argument is optional and -+a unique name will be generated if omitted. Both ``compression`` and ``deduplication`` default to -+``True`` (enabled) if not specified. -+ -+This factory can create only a single VDO logical volume in a single VDO pool but additional VDO pools -+can be added by repeating the steps to create the first one. - -From c6c776cf137b5c6ae454487df469e9a6dba8a5d1 Mon Sep 17 00:00:00 2001 -From: Vojtech Trefny -Date: Wed, 9 Dec 2020 14:06:27 +0100 -Subject: [PATCH 14/17] Set minimum size for LVM VDO pool devices - ---- - blivet/devicefactory.py | 3 +++ - blivet/devices/lvm.py | 26 ++++++++++++++++++++++++++ - tests/devicefactory_test.py | 29 ++++++++++++++++++++--------- - tests/devices_test/lvm_test.py | 6 ++++++ - 4 files changed, 55 insertions(+), 9 deletions(-) - -diff --git a/blivet/devicefactory.py b/blivet/devicefactory.py -index 085f2fd6..5e47eb9a 100644 ---- a/blivet/devicefactory.py -+++ b/blivet/devicefactory.py -@@ -277,6 +277,7 @@ class DeviceFactory(object): - "container_size": SIZE_POLICY_AUTO, - "container_raid_level": None, - "container_encrypted": None} -+ _device_min_size = Size(0) # no limit by default, limited only by filesystem size - - def __init__(self, storage, **kwargs): - """ -@@ -1760,6 +1761,8 @@ class LVMVDOFactory(LVMFactory): - :type deduplication: bool - """ - -+ _device_min_size = LVMVDOPoolMixin._min_size -+ - def __init__(self, storage, **kwargs): - self.pool_name = kwargs.pop("pool_name", None) - self.virtual_size = kwargs.pop("virtual_size", None) -diff --git a/blivet/devices/lvm.py b/blivet/devices/lvm.py -index 0802e2de..785fa2d2 100644 ---- a/blivet/devices/lvm.py -+++ b/blivet/devices/lvm.py -@@ -1792,6 +1792,7 @@ def populate_ksdata(self, data): - class LVMVDOPoolMixin(object): - - _external_dependencies = [availability.BLOCKDEV_LVM_PLUGIN, availability.BLOCKDEV_LVM_PLUGIN_VDO] -+ _min_size = Size("5 GiB") # 2.5 GiB for index and one 2 GiB slab rounded up to 5 GiB - - def __init__(self, compression=True, deduplication=True, index_memory=0, write_policy=None): - self.compression = compression -@@ -1800,6 +1801,9 @@ def __init__(self, compression=True, deduplication=True, index_memory=0, write_p - self.write_policy = write_policy - self._lvs = [] - -+ if not self.exists and self.size < self.min_size: -+ raise ValueError("Requested size %s is smaller than minimum %s" % (self.size, self.min_size)) -+ - @property - def is_vdo_pool(self): - return self.seg_type == "vdo-pool" -@@ -1856,6 +1860,23 @@ def direct(self): - """ Is this device directly accessible? """ - return False - -+ @property -+ @util.requires_property("is_vdo_pool") -+ def min_size(self): -+ if self.exists: -+ return self.current_size -+ -+ return self._min_size -+ -+ def _set_size(self, newsize): -+ if not isinstance(newsize, Size): -+ raise AttributeError("new size must of type Size") -+ -+ if newsize < self.min_size: -+ raise ValueError("Requested size %s is smaller than minimum %s" % (newsize, self.min_size)) -+ -+ DMDevice._set_size(self, newsize) -+ - def read_current_size(self): - log_method_call(self, exists=self.exists, path=self.path, - sysfs_path=self.sysfs_path) -@@ -2229,6 +2250,11 @@ def max_size(self): - max_format = self.format.max_size - return min(max_lv, max_format) if max_format else max_lv - -+ @property -+ @type_specific -+ def min_size(self): -+ return super(LVMLogicalVolumeDevice, self).min_size -+ - @property - @type_specific - def vg_space_used(self): -diff --git a/tests/devicefactory_test.py b/tests/devicefactory_test.py -index 4de1e05b..a1334cda 100644 ---- a/tests/devicefactory_test.py -+++ b/tests/devicefactory_test.py -@@ -49,13 +49,18 @@ class DeviceFactoryTestCase(unittest.TestCase): - encryption_supported = True - """ whether encryption of this device type is supported by blivet """ - -+ factory_class = None -+ """ devicefactory class used in this test case """ -+ -+ _disk_size = Size("2 GiB") -+ - def setUp(self): - if self.device_type is None: - raise unittest.SkipTest("abstract base class") - - self.b = blivet.Blivet() # don't populate it -- self.disk_files = [create_sparse_tempfile("factorytest", Size("2 GiB")), -- create_sparse_tempfile("factorytest", Size("2 GiB"))] -+ self.disk_files = [create_sparse_tempfile("factorytest", self._disk_size), -+ create_sparse_tempfile("factorytest", self._disk_size)] - for filename in self.disk_files: - disk = DiskFile(filename) - self.b.devicetree._add_device(disk) -@@ -197,7 +202,7 @@ def _get_size_delta(self, devices=None): - def test_get_free_disk_space(self, *args): # pylint: disable=unused-argument - # get_free_disk_space should return the total free space on disks - kwargs = self._get_test_factory_args() -- kwargs["size"] = Size("500 MiB") -+ kwargs["size"] = max(Size("500 MiB"), self.factory_class._device_min_size) - factory = devicefactory.get_device_factory(self.b, - self.device_type, - disks=self.b.disks, -@@ -285,7 +290,7 @@ def test_factory_defaults(self, *args): # pylint: disable=unused-argument - kwargs = self._get_test_factory_args() - kwargs.update({"disks": self.b.disks[:], - "fstype": "swap", -- "size": Size("2GiB"), -+ "size": max(Size("2GiB"), self.factory_class._device_min_size), - "label": "SWAP"}) - device = self._factory_device(self.device_type, **kwargs) - factory = devicefactory.get_device_factory(self.b, self.device_type, -@@ -302,6 +307,7 @@ def test_factory_defaults(self, *args): # pylint: disable=unused-argument - class PartitionFactoryTestCase(DeviceFactoryTestCase): - device_class = PartitionDevice - device_type = devicefactory.DEVICE_TYPE_PARTITION -+ factory_class = devicefactory.PartitionFactory - - def test_bug1178884(self): - # Test a change of format and size where old size is too large for the -@@ -330,6 +336,7 @@ def _get_size_delta(self, devices=None): - class LVMFactoryTestCase(DeviceFactoryTestCase): - device_class = LVMLogicalVolumeDevice - device_type = devicefactory.DEVICE_TYPE_LVM -+ factory_class = devicefactory.LVMFactory - - def _validate_factory_device(self, *args, **kwargs): - super(LVMFactoryTestCase, self)._validate_factory_device(*args, **kwargs) -@@ -510,6 +517,7 @@ class LVMThinPFactoryTestCase(LVMFactoryTestCase): - device_class = LVMLogicalVolumeDevice - device_type = devicefactory.DEVICE_TYPE_LVM_THINP - encryption_supported = False -+ factory_class = devicefactory.LVMThinPFactory - - def _validate_factory_device(self, *args, **kwargs): - super(LVMThinPFactoryTestCase, self)._validate_factory_device(*args, -@@ -541,6 +549,8 @@ class LVMVDOFactoryTestCase(LVMFactoryTestCase): - device_class = LVMLogicalVolumeDevice - device_type = devicefactory.DEVICE_TYPE_LVM_VDO - encryption_supported = False -+ _disk_size = Size("10 GiB") # we need bigger disks for VDO -+ factory_class = devicefactory.LVMVDOFactory - - def _validate_factory_device(self, *args, **kwargs): - super(LVMVDOFactoryTestCase, self)._validate_factory_device(*args, -@@ -585,7 +595,7 @@ def _validate_factory_device(self, *args, **kwargs): - def test_device_factory(self, *args): # pylint: disable=unused-argument,arguments-differ - device_type = self.device_type - kwargs = {"disks": self.b.disks, -- "size": Size("400 MiB"), -+ "size": Size("6 GiB"), - "fstype": 'ext4', - "mountpoint": '/factorytest'} - device = self._factory_device(device_type, **kwargs) -@@ -593,7 +603,7 @@ def test_device_factory(self, *args): # pylint: disable=unused-argument,argumen - self.b.recursive_remove(device.pool) - - kwargs = {"disks": self.b.disks, -- "size": Size("400 MiB"), -+ "size": Size("6 GiB"), - "fstype": 'ext4', - "mountpoint": '/factorytest', - "pool_name": "vdopool", -@@ -603,19 +613,19 @@ def test_device_factory(self, *args): # pylint: disable=unused-argument,argumen - self._validate_factory_device(device, device_type, **kwargs) - - # change size without specifying virtual_size: both sizes should grow -- kwargs["size"] = Size("600 MiB") -+ kwargs["size"] = Size("8 GiB") - kwargs["device"] = device - device = self._factory_device(device_type, **kwargs) - self._validate_factory_device(device, device_type, **kwargs) - - # change virtual size -- kwargs["virtual_size"] = Size("6 GiB") -+ kwargs["virtual_size"] = Size("40 GiB") - kwargs["device"] = device - device = self._factory_device(device_type, **kwargs) - self._validate_factory_device(device, device_type, **kwargs) - - # change virtual size to smaller than size -- kwargs["virtual_size"] = Size("500 GiB") -+ kwargs["virtual_size"] = Size("10 GiB") - kwargs["device"] = device - device = self._factory_device(device_type, **kwargs) - self._validate_factory_device(device, device_type, **kwargs) -@@ -644,6 +654,7 @@ def test_device_factory(self, *args): # pylint: disable=unused-argument,argumen - class MDFactoryTestCase(DeviceFactoryTestCase): - device_type = devicefactory.DEVICE_TYPE_MD - device_class = MDRaidArrayDevice -+ factory_class = devicefactory.MDFactory - - def test_device_factory(self): - # RAID0 across two disks -diff --git a/tests/devices_test/lvm_test.py b/tests/devices_test/lvm_test.py -index 493d3ba1..78b140ba 100644 ---- a/tests/devices_test/lvm_test.py -+++ b/tests/devices_test/lvm_test.py -@@ -705,6 +705,12 @@ def test_new_vdo_pool(self): - - self.assertEqual(vg.size, Size("10236 MiB")) - -+ with self.assertRaises(ValueError): -+ vdopool = b.new_lv(name="vdopool", vdo_pool=True, -+ parents=[vg], compression=True, -+ deduplication=True, -+ size=blivet.size.Size("1 GiB")) -+ - vdopool = b.new_lv(name="vdopool", vdo_pool=True, - parents=[vg], compression=True, - deduplication=True, - -From 197f2877709e702c101ada6b9a055a88f09320c8 Mon Sep 17 00:00:00 2001 -From: Vojtech Trefny -Date: Fri, 11 Dec 2020 14:20:48 +0100 -Subject: [PATCH 15/17] Use better description for libblockdev plugins in - tasks.availability - -The old names were quite confusing when showing that "lvm" is -missing when in fact libblockdev LVM plugin is missing. Also with -LVM VDO we need to be able to tell the difference between missing -LVM plugin and missing LVM VDO support. ---- - blivet/tasks/availability.py | 26 +++++++++++++------------- - 1 file changed, 13 insertions(+), 13 deletions(-) - -diff --git a/blivet/tasks/availability.py b/blivet/tasks/availability.py -index b107428e..52418685 100644 ---- a/blivet/tasks/availability.py -+++ b/blivet/tasks/availability.py -@@ -236,13 +236,13 @@ def availability_errors(self, resource): - :returns: [] if the name of the plugin is loaded - :rtype: list of str - """ -- if resource.name not in blockdev.get_available_plugin_names(): # pylint: disable=no-value-for-parameter -- return ["libblockdev plugin %s not loaded" % resource.name] -+ if self._tech_info.plugin_name not in blockdev.get_available_plugin_names(): # pylint: disable=no-value-for-parameter -+ return ["libblockdev plugin %s not loaded" % self._tech_info.plugin_name] - else: - tech_missing = self._check_technologies() - if tech_missing: - return ["libblockdev plugin %s is loaded but some required " -- "technologies are not available:\n%s" % (resource.name, tech_missing)] -+ "technologies are not available:\n%s" % (self._tech_info.plugin_name, tech_missing)] - else: - return [] - -@@ -411,16 +411,16 @@ def available_resource(name): - # we can't just check if the plugin is loaded, we also need to make sure - # that all technologies required by us our supported (some may be missing - # due to missing dependencies) --BLOCKDEV_BTRFS_PLUGIN = blockdev_plugin("btrfs", BLOCKDEV_BTRFS_TECH) --BLOCKDEV_CRYPTO_PLUGIN = blockdev_plugin("crypto", BLOCKDEV_CRYPTO_TECH) --BLOCKDEV_DM_PLUGIN = blockdev_plugin("dm", BLOCKDEV_DM_TECH) --BLOCKDEV_DM_PLUGIN_RAID = blockdev_plugin("dm", BLOCKDEV_DM_TECH_RAID) --BLOCKDEV_LOOP_PLUGIN = blockdev_plugin("loop", BLOCKDEV_LOOP_TECH) --BLOCKDEV_LVM_PLUGIN = blockdev_plugin("lvm", BLOCKDEV_LVM_TECH) --BLOCKDEV_LVM_PLUGIN_VDO = blockdev_plugin("lvm", BLOCKDEV_LVM_TECH_VDO) --BLOCKDEV_MDRAID_PLUGIN = blockdev_plugin("mdraid", BLOCKDEV_MD_TECH) --BLOCKDEV_MPATH_PLUGIN = blockdev_plugin("mpath", BLOCKDEV_MPATH_TECH) --BLOCKDEV_SWAP_PLUGIN = blockdev_plugin("swap", BLOCKDEV_SWAP_TECH) -+BLOCKDEV_BTRFS_PLUGIN = blockdev_plugin("libblockdev btrfs plugin", BLOCKDEV_BTRFS_TECH) -+BLOCKDEV_CRYPTO_PLUGIN = blockdev_plugin("libblockdev crypto plugin", BLOCKDEV_CRYPTO_TECH) -+BLOCKDEV_DM_PLUGIN = blockdev_plugin("libblockdev dm plugin", BLOCKDEV_DM_TECH) -+BLOCKDEV_DM_PLUGIN_RAID = blockdev_plugin("libblockdev dm plugin (raid technology)", BLOCKDEV_DM_TECH_RAID) -+BLOCKDEV_LOOP_PLUGIN = blockdev_plugin("libblockdev loop plugin", BLOCKDEV_LOOP_TECH) -+BLOCKDEV_LVM_PLUGIN = blockdev_plugin("libblockdev lvm plugin", BLOCKDEV_LVM_TECH) -+BLOCKDEV_LVM_PLUGIN_VDO = blockdev_plugin("libblockdev lvm plugin (vdo technology)", BLOCKDEV_LVM_TECH_VDO) -+BLOCKDEV_MDRAID_PLUGIN = blockdev_plugin("libblockdev mdraid plugin", BLOCKDEV_MD_TECH) -+BLOCKDEV_MPATH_PLUGIN = blockdev_plugin("libblockdev mpath plugin", BLOCKDEV_MPATH_TECH) -+BLOCKDEV_SWAP_PLUGIN = blockdev_plugin("libblockdev swap plugin", BLOCKDEV_SWAP_TECH) - - # applications with versions - # we need e2fsprogs newer than 1.41 and we are checking the version by running - -From 5fc047b48b0de18fa249f102d2a7163ac2d6e6a6 Mon Sep 17 00:00:00 2001 -From: Vojtech Trefny -Date: Fri, 11 Dec 2020 14:24:18 +0100 -Subject: [PATCH 16/17] Fix external dependencies for LVM VDO devices - -The external and unavailable dependencies code is mostly supposed -to work with just class objects and not instances, which is problem -for LVM devices where the LVMLogicalVolumeDevice can't depend on -LVM VDO and special LVM VDO device mixin classes don't inherit -from the Device class so they are missing some availability -functions. -This fix adds the neccessary functions to LVM VDO mixin classes to -make sure both "unavailable_type_dependencies" and -"type_external_dependencies" work with LVMVDOLogicalVolumeMixin -and LVMVDOPoolMixin. When working with an LVMLogicalVolumeDevice -instance its dependencies are correctly set based on type of the -logical volume. ---- - blivet/devicefactory.py | 7 +-- - blivet/devices/lvm.py | 31 ++++++++++ - tests/action_test.py | 7 +++ - tests/devicefactory_test.py | 32 ++++++++++ - tests/devices_test/lvm_test.py | 106 +++++++++++++++++++++++++++++++++ - 5 files changed, 179 insertions(+), 4 deletions(-) - -diff --git a/blivet/devicefactory.py b/blivet/devicefactory.py -index 5e47eb9a..b29a107a 100644 ---- a/blivet/devicefactory.py -+++ b/blivet/devicefactory.py -@@ -27,7 +27,7 @@ - from .devices import BTRFSDevice, DiskDevice - from .devices import LUKSDevice, LVMLogicalVolumeDevice - from .devices import PartitionDevice, MDRaidArrayDevice --from .devices.lvm import LVMVDOPoolMixin, DEFAULT_THPOOL_RESERVE -+from .devices.lvm import LVMVDOPoolMixin, LVMVDOLogicalVolumeMixin, DEFAULT_THPOOL_RESERVE - from .formats import get_format - from .devicelibs import btrfs - from .devicelibs import mdraid -@@ -70,9 +70,6 @@ def is_supported_device_type(device_type): - :returns: True if this device type is supported - :rtype: bool - """ -- if device_type == DEVICE_TYPE_LVM_VDO: -- return not any(e for e in LVMVDOPoolMixin._external_dependencies if not e.available) -- - devices = [] - if device_type == DEVICE_TYPE_BTRFS: - devices = [BTRFSDevice] -@@ -84,6 +81,8 @@ def is_supported_device_type(device_type): - devices = [PartitionDevice] - elif device_type == DEVICE_TYPE_MD: - devices = [MDRaidArrayDevice] -+ elif device_type == DEVICE_TYPE_LVM_VDO: -+ devices = [LVMLogicalVolumeDevice, LVMVDOPoolMixin, LVMVDOLogicalVolumeMixin] - - return not any(c.unavailable_type_dependencies() for c in devices) - -diff --git a/blivet/devices/lvm.py b/blivet/devices/lvm.py -index 785fa2d2..ac900bf3 100644 ---- a/blivet/devices/lvm.py -+++ b/blivet/devices/lvm.py -@@ -1804,6 +1804,17 @@ def __init__(self, compression=True, deduplication=True, index_memory=0, write_p - if not self.exists and self.size < self.min_size: - raise ValueError("Requested size %s is smaller than minimum %s" % (self.size, self.min_size)) - -+ # these two methods are defined in Device but LVMVDOPoolMixin doesn't inherit from -+ # it and we can't have this code in LVMLogicalVolumeDevice because we need to be able -+ # to get dependencies without creating instance of the class -+ @classmethod -+ def type_external_dependencies(cls): -+ return set(d for d in cls._external_dependencies) | LVMLogicalVolumeDevice.type_external_dependencies() -+ -+ @classmethod -+ def unavailable_type_dependencies(cls): -+ return set(e for e in cls.type_external_dependencies() if not e.available) -+ - @property - def is_vdo_pool(self): - return self.seg_type == "vdo-pool" -@@ -1926,6 +1937,17 @@ def _check_parents(self): - if not container or not isinstance(container, LVMLogicalVolumeDevice) or not container.is_vdo_pool: - raise ValueError("constructor requires a vdo-pool LV") - -+ # these two methods are defined in Device but LVMVDOLogicalVolumeMixin doesn't inherit -+ # from it and we can't have this code in LVMLogicalVolumeDevice because we need to be -+ # able to get dependencies without creating instance of the class -+ @classmethod -+ def type_external_dependencies(cls): -+ return set(d for d in cls._external_dependencies) | LVMLogicalVolumeDevice.type_external_dependencies() -+ -+ @classmethod -+ def unavailable_type_dependencies(cls): -+ return set(e for e in cls.type_external_dependencies() if not e.available) -+ - @property - def vg_space_used(self): - return Size(0) # the pool's size is already accounted for in the vg -@@ -2217,6 +2239,15 @@ def _convert_from_lvs(self): - """Convert the LVs to create this LV from into its internal LVs""" - raise ValueError("Cannot create a new LV of type '%s' from other LVs" % self.seg_type) - -+ @property -+ def external_dependencies(self): -+ deps = super(LVMLogicalVolumeBase, self).external_dependencies -+ if self.is_vdo_pool: -+ deps.update(LVMVDOPoolMixin.type_external_dependencies()) -+ if self.is_vdo_lv: -+ deps.update(LVMVDOLogicalVolumeMixin.type_external_dependencies()) -+ return deps -+ - @property - @type_specific - def vg(self): -diff --git a/tests/action_test.py b/tests/action_test.py -index 77176f46..38a2e872 100644 ---- a/tests/action_test.py -+++ b/tests/action_test.py -@@ -18,6 +18,8 @@ - from blivet.devices import MDRaidArrayDevice - from blivet.devices import LVMVolumeGroupDevice - from blivet.devices import LVMLogicalVolumeDevice -+from blivet.devices.lvm import LVMVDOPoolMixin -+from blivet.devices.lvm import LVMVDOLogicalVolumeMixin - - # format classes - from blivet.formats.fs import Ext2FS -@@ -1252,6 +1254,11 @@ def test_lv_from_lvs_actions(self): - self.assertEqual(set(self.storage.lvs), {pool}) - self.assertEqual(set(pool._internal_lvs), {lv1, lv2}) - -+ -+@unittest.skipUnless(not any(x.unavailable_type_dependencies() for x in DEVICE_CLASSES + [LVMVDOPoolMixin, LVMVDOLogicalVolumeMixin]), "some unsupported device classes required for this test") -+@unittest.skipUnless(all(x().utils_available for x in FORMAT_CLASSES), "some unsupported format classes required for this test") -+class DeviceActionLVMVDOTestCase(DeviceActionTestCase): -+ - def test_lvm_vdo_destroy(self): - self.destroy_all_devices() - sdc = self.storage.devicetree.get_device_by_name("sdc") -diff --git a/tests/devicefactory_test.py b/tests/devicefactory_test.py -index a1334cda..e4210ead 100644 ---- a/tests/devicefactory_test.py -+++ b/tests/devicefactory_test.py -@@ -592,6 +592,8 @@ def _validate_factory_device(self, *args, **kwargs): - @patch("blivet.static_data.lvm_info.blockdev.lvm.lvs", return_value=[]) - @patch("blivet.devices.lvm.LVMVolumeGroupDevice.type_external_dependencies", return_value=set()) - @patch("blivet.devices.lvm.LVMLogicalVolumeBase.type_external_dependencies", return_value=set()) -+ @patch("blivet.devices.lvm.LVMVDOPoolMixin.type_external_dependencies", return_value=set()) -+ @patch("blivet.devices.lvm.LVMVDOLogicalVolumeMixin.type_external_dependencies", return_value=set()) - def test_device_factory(self, *args): # pylint: disable=unused-argument,arguments-differ - device_type = self.device_type - kwargs = {"disks": self.b.disks, -@@ -650,6 +652,36 @@ def test_device_factory(self, *args): # pylint: disable=unused-argument,argumen - # change fstype - kwargs["fstype"] = "xfs" - -+ @patch("blivet.formats.lvmpv.LVMPhysicalVolume.formattable", return_value=True) -+ @patch("blivet.formats.lvmpv.LVMPhysicalVolume.destroyable", return_value=True) -+ @patch("blivet.static_data.lvm_info.blockdev.lvm.lvs", return_value=[]) -+ @patch("blivet.devices.lvm.LVMVolumeGroupDevice.type_external_dependencies", return_value=set()) -+ @patch("blivet.devices.lvm.LVMLogicalVolumeBase.type_external_dependencies", return_value=set()) -+ @patch("blivet.devices.lvm.LVMVDOPoolMixin.type_external_dependencies", return_value=set()) -+ @patch("blivet.devices.lvm.LVMVDOLogicalVolumeMixin.type_external_dependencies", return_value=set()) -+ def test_factory_defaults(self, *args): # pylint: disable=unused-argument -+ super(LVMVDOFactoryTestCase, self).test_factory_defaults() -+ -+ @patch("blivet.formats.lvmpv.LVMPhysicalVolume.formattable", return_value=True) -+ @patch("blivet.formats.lvmpv.LVMPhysicalVolume.destroyable", return_value=True) -+ @patch("blivet.static_data.lvm_info.blockdev.lvm.lvs", return_value=[]) -+ @patch("blivet.devices.lvm.LVMVolumeGroupDevice.type_external_dependencies", return_value=set()) -+ @patch("blivet.devices.lvm.LVMLogicalVolumeBase.type_external_dependencies", return_value=set()) -+ @patch("blivet.devices.lvm.LVMVDOPoolMixin.type_external_dependencies", return_value=set()) -+ @patch("blivet.devices.lvm.LVMVDOLogicalVolumeMixin.type_external_dependencies", return_value=set()) -+ def test_get_free_disk_space(self, *args): -+ super(LVMVDOFactoryTestCase, self).test_get_free_disk_space() -+ -+ @patch("blivet.formats.lvmpv.LVMPhysicalVolume.formattable", return_value=True) -+ @patch("blivet.formats.lvmpv.LVMPhysicalVolume.destroyable", return_value=True) -+ @patch("blivet.static_data.lvm_info.blockdev.lvm.lvs", return_value=[]) -+ @patch("blivet.devices.lvm.LVMVolumeGroupDevice.type_external_dependencies", return_value=set()) -+ @patch("blivet.devices.lvm.LVMLogicalVolumeBase.type_external_dependencies", return_value=set()) -+ @patch("blivet.devices.lvm.LVMVDOPoolMixin.type_external_dependencies", return_value=set()) -+ @patch("blivet.devices.lvm.LVMVDOLogicalVolumeMixin.type_external_dependencies", return_value=set()) -+ def test_normalize_size(self, *args): # pylint: disable=unused-argument -+ super(LVMVDOFactoryTestCase, self).test_normalize_size() -+ - - class MDFactoryTestCase(DeviceFactoryTestCase): - device_type = devicefactory.DEVICE_TYPE_MD -diff --git a/tests/devices_test/lvm_test.py b/tests/devices_test/lvm_test.py -index 78b140ba..d938144d 100644 ---- a/tests/devices_test/lvm_test.py -+++ b/tests/devices_test/lvm_test.py -@@ -10,10 +10,13 @@ - from blivet.devices import StorageDevice - from blivet.devices import LVMLogicalVolumeDevice - from blivet.devices import LVMVolumeGroupDevice -+from blivet.devices.lvm import LVMVDOPoolMixin -+from blivet.devices.lvm import LVMVDOLogicalVolumeMixin - from blivet.devices.lvm import LVMCacheRequest - from blivet.devices.lvm import LVPVSpec, LVMInternalLVtype - from blivet.size import Size - from blivet.devicelibs import raid -+from blivet import devicefactory - from blivet import errors - - DEVICE_CLASSES = [ -@@ -690,6 +693,10 @@ def test_new_lv_from_non_existing_lvs(self): - pool.create() - self.assertTrue(lvm.thpool_convert.called) - -+ -+@unittest.skipUnless(not any(x.unavailable_type_dependencies() for x in DEVICE_CLASSES + [LVMVDOPoolMixin, LVMVDOLogicalVolumeMixin]), "some unsupported device classes required for this test") -+class BlivetNewLVMVDODeviceTest(unittest.TestCase): -+ - def test_new_vdo_pool(self): - b = blivet.Blivet() - pv = StorageDevice("pv1", fmt=blivet.formats.get_format("lvmpv"), -@@ -726,3 +733,102 @@ def test_new_vdo_pool(self): - self.assertEqual(vdopool.children[0], vdolv) - self.assertEqual(vdolv.parents[0], vdopool) - self.assertListEqual(vg.lvs, [vdopool, vdolv]) -+ -+ -+@unittest.skipUnless(not any(x.unavailable_type_dependencies() for x in DEVICE_CLASSES), "some unsupported device classes required for this test") -+class BlivetLVMVDODependenciesTest(unittest.TestCase): -+ def test_vdo_dependencies(self): -+ blivet.tasks.availability.CACHE_AVAILABILITY = False -+ -+ b = blivet.Blivet() -+ pv = StorageDevice("pv1", fmt=blivet.formats.get_format("lvmpv"), -+ size=Size("10 GiB"), exists=True) -+ vg = LVMVolumeGroupDevice("testvg", parents=[pv], exists=True) -+ -+ for dev in (pv, vg): -+ b.devicetree._add_device(dev) -+ -+ # check that all the above devices are in the expected places -+ self.assertEqual(set(b.devices), {pv, vg}) -+ self.assertEqual(set(b.vgs), {vg}) -+ -+ self.assertEqual(vg.size, Size("10236 MiB")) -+ -+ vdopool = b.new_lv(name="vdopool", vdo_pool=True, -+ parents=[vg], compression=True, -+ deduplication=True, -+ size=blivet.size.Size("8 GiB")) -+ -+ vdolv = b.new_lv(name="vdolv", vdo_lv=True, -+ parents=[vdopool], -+ size=blivet.size.Size("40 GiB")) -+ -+ # Dependencies check: for VDO types these should be combination of "normal" -+ # LVM dependencies (LVM libblockdev plugin + kpartx and DM plugin from DMDevice) -+ # and LVM VDO technology from the LVM plugin -+ lvm_vdo_dependencies = ["kpartx", -+ "libblockdev dm plugin", -+ "libblockdev lvm plugin", -+ "libblockdev lvm plugin (vdo technology)"] -+ pool_deps = [d.name for d in vdopool.external_dependencies] -+ six.assertCountEqual(self, pool_deps, lvm_vdo_dependencies) -+ -+ vdolv_deps = [d.name for d in vdolv.external_dependencies] -+ six.assertCountEqual(self, vdolv_deps, lvm_vdo_dependencies) -+ -+ # same dependencies should be returned when checking with class not instance -+ pool_type_deps = [d.name for d in LVMVDOPoolMixin.type_external_dependencies()] -+ six.assertCountEqual(self, pool_type_deps, lvm_vdo_dependencies) -+ -+ vdolv_type_deps = [d.name for d in LVMVDOLogicalVolumeMixin.type_external_dependencies()] -+ six.assertCountEqual(self, vdolv_type_deps, lvm_vdo_dependencies) -+ -+ # just to be sure LVM VDO specific code didn't break "normal" LVs -+ normallv = b.new_lv(name="lvol0", -+ parents=[vg], -+ size=blivet.size.Size("1 GiB")) -+ -+ normalvl_deps = [d.name for d in normallv.external_dependencies] -+ six.assertCountEqual(self, normalvl_deps, ["kpartx", -+ "libblockdev dm plugin", -+ "libblockdev lvm plugin"]) -+ -+ with patch("blivet.devices.lvm.LVMVDOPoolMixin._external_dependencies", -+ new=[blivet.tasks.availability.unavailable_resource("VDO unavailability test")]): -+ with patch("blivet.devices.lvm.LVMVDOLogicalVolumeMixin._external_dependencies", -+ new=[blivet.tasks.availability.unavailable_resource("VDO unavailability test")]): -+ -+ pool_deps = [d.name for d in vdopool.unavailable_dependencies] -+ self.assertEqual(pool_deps, ["VDO unavailability test"]) -+ -+ vdolv_deps = [d.name for d in vdolv.unavailable_dependencies] -+ self.assertEqual(vdolv_deps, ["VDO unavailability test"]) -+ -+ # same dependencies should be returned when checking with class not instance -+ pool_type_deps = [d.name for d in LVMVDOPoolMixin.unavailable_type_dependencies()] -+ six.assertCountEqual(self, pool_type_deps, ["VDO unavailability test"]) -+ -+ vdolv_type_deps = [d.name for d in LVMVDOLogicalVolumeMixin.unavailable_type_dependencies()] -+ six.assertCountEqual(self, vdolv_type_deps, ["VDO unavailability test"]) -+ -+ normallv_deps = [d.name for d in normallv.unavailable_dependencies] -+ self.assertEqual(normallv_deps, []) -+ -+ with self.assertRaises(errors.DependencyError): -+ b.create_device(vdopool) -+ b.create_device(vdolv) -+ -+ b.create_device(normallv) -+ -+ def test_vdo_dependencies_devicefactory(self): -+ with patch("blivet.devices.lvm.LVMVDOPoolMixin._external_dependencies", -+ new=[blivet.tasks.availability.unavailable_resource("VDO unavailability test")]): -+ with patch("blivet.devices.lvm.LVMVDOLogicalVolumeMixin._external_dependencies", -+ new=[blivet.tasks.availability.unavailable_resource("VDO unavailability test")]): -+ -+ # shouldn't affect "normal" LVM -+ lvm_supported = devicefactory.is_supported_device_type(devicefactory.DEVICE_TYPE_LVM) -+ self.assertTrue(lvm_supported) -+ -+ vdo_supported = devicefactory.is_supported_device_type(devicefactory.DEVICE_TYPE_LVM_VDO) -+ self.assertFalse(vdo_supported) - -From c7fb125ec552ee5070f8180f92fe5545709192ff Mon Sep 17 00:00:00 2001 -From: Vojtech Trefny -Date: Fri, 11 Dec 2020 15:02:05 +0100 -Subject: [PATCH 17/17] Bump required libblockdev version to 2.24 - -LVM VDO support was added in 2.24. ---- - python-blivet.spec | 2 +- - 1 file changed, 1 insertion(+), 1 deletion(-) - -diff --git a/python-blivet.spec b/python-blivet.spec -index ffd4210e..58cad0b2 100644 ---- a/python-blivet.spec -+++ b/python-blivet.spec -@@ -36,7 +36,7 @@ Source1: http://github.com/storaged-project/blivet/archive/%{realname}-%{realver - %global partedver 1.8.1 - %global pypartedver 3.10.4 - %global utillinuxver 2.15.1 --%global libblockdevver 2.19 -+%global libblockdevver 2.24 - %global libbytesizever 0.3 - %global pyudevver 0.18 - diff --git a/SOURCES/0020-apply-directory-s-SELinux-context-to-freshly-created.patch b/SOURCES/0020-apply-directory-s-SELinux-context-to-freshly-created.patch deleted file mode 100644 index bdae03b..0000000 --- a/SOURCES/0020-apply-directory-s-SELinux-context-to-freshly-created.patch +++ /dev/null @@ -1,83 +0,0 @@ -From dabc5f8a29f34aebd9ea61405d822b5d5bef1ec2 Mon Sep 17 00:00:00 2001 -From: =?UTF-8?q?Renaud=20M=C3=A9trich?= -Date: Tue, 2 Mar 2021 14:13:29 +0100 -Subject: [PATCH] apply directory's SELinux context to freshly created mount - points -MIME-Version: 1.0 -Content-Type: text/plain; charset=UTF-8 -Content-Transfer-Encoding: 8bit - -Signed-off-by: Renaud Métrich - -Resolves: rhbz#1934076 ---- - blivet/formats/fs.py | 3 ++- - blivet/util.py | 9 +++++---- - 2 files changed, 7 insertions(+), 5 deletions(-) - -diff --git a/blivet/formats/fs.py b/blivet/formats/fs.py -index e61e5b86..a92d3485 100644 ---- a/blivet/formats/fs.py -+++ b/blivet/formats/fs.py -@@ -27,6 +27,7 @@ import os - import tempfile - import uuid as uuid_mod - import random -+import stat - - from parted import fileSystemType, PARTITION_BOOT - -@@ -582,7 +583,7 @@ class FS(DeviceFormat): - mountpoint = kwargs.get("mountpoint") or self.mountpoint - - if self._selinux_supported and flags.selinux and "ro" not in self._mount.mount_options(options).split(",") and flags.selinux_reset_fcon: -- ret = util.reset_file_context(mountpoint, chroot) -+ ret = util.reset_file_context(mountpoint, chroot, stat.S_IFDIR) - if not ret: - log.warning("Failed to reset SElinux context for newly mounted filesystem root directory to default.") - -diff --git a/blivet/util.py b/blivet/util.py -index 48b7818f..f5e0cc1a 100644 ---- a/blivet/util.py -+++ b/blivet/util.py -@@ -448,11 +448,11 @@ def get_cow_sysfs_path(dev_path, dev_sysfsPath): - ## - - --def match_path_context(path): -+def match_path_context(path, mode=0): - """ Return the default SELinux context for the given path. """ - context = None - try: -- context = selinux.matchpathcon(os.path.normpath(path), 0)[1] -+ context = selinux.matchpathcon(os.path.normpath(path), mode)[1] - except OSError as e: - log.info("failed to get default SELinux context for %s: %s", path, e) - -@@ -491,7 +491,7 @@ def set_file_context(path, context, root=None): - return rc - - --def reset_file_context(path, root=None): -+def reset_file_context(path, root=None, mode=0): - """ Restore the SELinux context of a file to its default value. - - Arguments: -@@ -501,12 +501,13 @@ def reset_file_context(path, root=None): - Keyword Arguments: - - root an optional chroot string -+ mode an optional mode to use - - Return Value: - - If successful, returns the file's new/default context. - """ -- context = match_path_context(path) -+ context = match_path_context(path, mode) - if context: - if set_file_context(path, context, root=root): - return context --- -2.29.2 - diff --git a/SPECS/python-blivet.spec b/SPECS/python-blivet.spec index ed6240c..86dd5f8 100644 --- a/SPECS/python-blivet.spec +++ b/SPECS/python-blivet.spec @@ -19,45 +19,29 @@ Summary: A python module for system storage configuration Name: python-blivet Url: https://storageapis.wordpress.com/projects/blivet -Version: 3.2.2 +Version: 3.4.0 #%%global prerelease .b2 # prerelease, if defined, should be something like .a1, .b1, .b2.dev1, or .c2 -Release: 10%{?prerelease}%{?dist} +Release: 2%{?prerelease}%{?dist} Epoch: 1 License: LGPLv2+ -Group: System Environment/Libraries %global realname blivet %global realversion %{version}%{?prerelease} Source0: http://github.com/storaged-project/blivet/archive/%{realname}-%{realversion}.tar.gz Source1: http://github.com/storaged-project/blivet/archive/%{realname}-%{realversion}-tests.tar.gz Patch0: 0001-force-lvm-cli.plugin Patch1: 0002-remove-btrfs-plugin.patch -Patch2: 0003-Skip-test_mounting-for-filesystems-that-are-not-moun.patch -Patch3: 0004-Add-extra-sleep-after-pvremove-call.patch -Patch4: 0005-Round-down-to-nearest-MiB-value-when-writing-ks-parittion-info.ks -Patch5: 0006-Blivet-RHEL-8.3-localization-update.patch -Patch6: 0007-Do-not-use-FSAVAIL-and-FSUSE-options-when-running-lsblk.patch -Patch7: 0008-set-allowed-disk-labels-for-s390x-as-standard-ones-plus-dasd.patch -Patch8: 0009-Do-not-use-BlockDev-utils_have_kernel_module-to-check-for-modules.patch -Patch9: 0010-Fix-name-resolution-for-MD-devices-and-partitions-on.patch -Patch10: 0011-Fix-ignoring-disk-devices-with-parents-or-children.patch -Patch11: 0012-xfs-grow-support.patch -Patch12: 0013-Do-not-limit-swap-to-128-GiB.patch -Patch13: 0014-Use-UnusableConfigurationError-for-patially-hidden-multipath-devices.patch -Patch14: 0015-Fix-possible-UnicodeDecodeError-when-reading-model-f.patch -Patch15: 0016-Basic-LVM-VDO-support.patch -Patch16: 0017-Let-parted-fix-fixable-issues-with-partition-table.patch -Patch17: 0018-Fix-possible-UnicodeDecodeError-when-reading-sysfs-a.patch -Patch18: 0019-LVM-VDO-support.patch -Patch19: 0020-apply-directory-s-SELinux-context-to-freshly-created.patch +Patch2: 0003-Revert-More-consistent-lvm-errors.patch +Patch3: 0004-Revert-Terminology-cleanups.patch +Patch4: 0005-Fix-activating-old-style-LVM-snapshots.patch # Versions of required components (done so we make sure the buildrequires # match the requires versions of things). -%global partedver 1.8.1 +%global partedver 3.2 %global pypartedver 3.10.4 %global utillinuxver 2.15.1 -%global libblockdevver 2.19 +%global libblockdevver 2.24 %global libbytesizever 0.3 %global pyudevver 0.18 @@ -70,6 +54,7 @@ storage configuration. %package -n %{realname}-data Summary: Data for the %{realname} python module. +BuildRequires: make BuildRequires: systemd Conflicts: python-blivet < 1:2.0.0 @@ -200,21 +185,25 @@ configuration. %if %{with python2} %files -n python2-%{realname} %license COPYING -%doc README ChangeLog examples +%doc README.md ChangeLog examples %{python2_sitelib}/* %endif %if %{with python3} %files -n python3-%{realname} %license COPYING -%doc README ChangeLog examples +%doc README.md ChangeLog examples %{python3_sitelib}/* %endif %changelog -* Mon Mar 08 2021 Vojtech Trefny - 3.2.2-10 -- apply directory's SELinux context to freshly created mount points - Resolves: rhbz#1934076 +* Wed Jul 7 2021 Vojtech Trefny - 3.4.0-2 +- Fix activating old style LVM snapshots + Resolves: rhbz#1961739 + +* Wed May 5 2021 Vojtech Trefny - 3.4.0-1 +- Rebase to latest upstream release 3.4.0 + Resolves: rhbz#1918357 * Tue Feb 9 2021 Vojtech Trefny - 3.2.2-9 - LVM VDO support