From 66ecf7e795943c39b7cfc58db20d5638859d8351 Mon Sep 17 00:00:00 2001 From: Vojtech Trefny Date: Jun 17 2021 11:37:14 +0000 Subject: Rebase to latest upstream release 3.4.0 Resolves: rhbz#1964341 --- diff --git a/.gitignore b/.gitignore index 25d5fff..70cb3ef 100644 --- a/.gitignore +++ b/.gitignore @@ -133,3 +133,5 @@ /blivet-3.3.2.tar.gz /blivet-3.3.3-tests.tar.gz /blivet-3.3.3.tar.gz +/blivet-3.4.0-tests.tar.gz +/blivet-3.4.0.tar.gz diff --git a/0001-force-lvm-cli-plugin.patch b/0001-force-lvm-cli-plugin.patch new file mode 100644 index 0000000..2a15b22 --- /dev/null +++ b/0001-force-lvm-cli-plugin.patch @@ -0,0 +1,35 @@ +From 2f90040ff66eacc9715e370cd49ffb72d8d1f36f Mon Sep 17 00:00:00 2001 +From: Vojtech Trefny +Date: Wed, 11 Jul 2018 15:36:24 +0200 +Subject: [PATCH] Force command line based libblockdev LVM plugin + +--- + blivet/__init__.py | 9 +++++++-- + 1 file changed, 7 insertions(+), 2 deletions(-) + +diff --git a/blivet/__init__.py b/blivet/__init__.py +index c5a75bb..cb75917 100644 +--- a/blivet/__init__.py ++++ b/blivet/__init__.py +@@ -63,11 +63,16 @@ gi.require_version("BlockDev", "2.0") + from gi.repository import GLib + from gi.repository import BlockDev as blockdev + if arch.is_s390(): +- _REQUESTED_PLUGIN_NAMES = set(("lvm", "btrfs", "swap", "crypto", "loop", "mdraid", "mpath", "dm", "s390", "nvdimm")) ++ _REQUESTED_PLUGIN_NAMES = set(("btrfs", "swap", "crypto", "loop", "mdraid", "mpath", "dm", "s390", "nvdimm")) + else: +- _REQUESTED_PLUGIN_NAMES = set(("lvm", "btrfs", "swap", "crypto", "loop", "mdraid", "mpath", "dm", "nvdimm")) ++ _REQUESTED_PLUGIN_NAMES = set(("btrfs", "swap", "crypto", "loop", "mdraid", "mpath", "dm", "nvdimm")) + + _requested_plugins = blockdev.plugin_specs_from_names(_REQUESTED_PLUGIN_NAMES) ++# XXX force non-dbus LVM plugin ++lvm_plugin = blockdev.PluginSpec() ++lvm_plugin.name = blockdev.Plugin.LVM ++lvm_plugin.so_name = "libbd_lvm.so.2" ++_requested_plugins.append(lvm_plugin) + try: + # do not check for dependencies during libblockdev initializtion, do runtime + # checks instead +-- +1.8.3.1 + diff --git a/0002-remove-btrfs-plugin.patch b/0002-remove-btrfs-plugin.patch new file mode 100644 index 0000000..5755e9e --- /dev/null +++ b/0002-remove-btrfs-plugin.patch @@ -0,0 +1,28 @@ +From 6bf3378d3d2a1b6a4338df0c4dd36a783a641633 Mon Sep 17 00:00:00 2001 +From: Vojtech Trefny +Date: Mon, 16 Jul 2018 14:26:11 +0200 +Subject: [PATCH] Remove btrfs from requested libblockdev plugins + +--- + blivet/__init__.py | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +diff --git a/blivet/__init__.py b/blivet/__init__.py +index cb75917..09f8b1c 100644 +--- a/blivet/__init__.py ++++ b/blivet/__init__.py +@@ -63,9 +63,9 @@ gi.require_version("BlockDev", "2.0") + from gi.repository import GLib + from gi.repository import BlockDev as blockdev + if arch.is_s390(): +- _REQUESTED_PLUGIN_NAMES = set(("btrfs", "swap", "crypto", "loop", "mdraid", "mpath", "dm", "s390", "nvdimm")) ++ _REQUESTED_PLUGIN_NAMES = set(("swap", "crypto", "loop", "mdraid", "mpath", "dm", "s390", "nvdimm")) + else: +- _REQUESTED_PLUGIN_NAMES = set(("btrfs", "swap", "crypto", "loop", "mdraid", "mpath", "dm", "nvdimm")) ++ _REQUESTED_PLUGIN_NAMES = set(("swap", "crypto", "loop", "mdraid", "mpath", "dm", "nvdimm")) + + _requested_plugins = blockdev.plugin_specs_from_names(_REQUESTED_PLUGIN_NAMES) + # XXX force non-dbus LVM plugin +-- +1.8.3.1 + diff --git a/0003-Revert-More-consistent-lvm-errors.patch b/0003-Revert-More-consistent-lvm-errors.patch new file mode 100644 index 0000000..69306a8 --- /dev/null +++ b/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/0004-Revert-Terminology-cleanups.patch b/0004-Revert-Terminology-cleanups.patch new file mode 100644 index 0000000..0db4494 --- /dev/null +++ b/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/0005-Fix-unify-importing-mock-module-in-tests.patch b/0005-Fix-unify-importing-mock-module-in-tests.patch new file mode 100644 index 0000000..cb050e4 --- /dev/null +++ b/0005-Fix-unify-importing-mock-module-in-tests.patch @@ -0,0 +1,538 @@ +From ad34dfa2f983bb3159af8b5780193e0427b505e9 Mon Sep 17 00:00:00 2001 +From: Vojtech Trefny +Date: Thu, 10 Jun 2021 15:01:26 +0200 +Subject: [PATCH] Fix/unify importing mock module in tests + +mock is available in the unittest module since Python 3.3, we need +to use the old mock module not only with Python 2 but also with +the early versions of Python 3. +--- + tests/action_test.py | 5 ++- + tests/dbus_test.py | 9 +++-- + tests/devicefactory_test.py | 6 ++-- + tests/devicelibs_test/disk_test.py | 6 ++-- + tests/devicelibs_test/edd_test.py | 6 +++- + tests/devices_test/dependencies_test.py | 6 ++-- + tests/devices_test/device_methods_test.py | 8 +++-- + tests/devices_test/device_names_test.py | 6 ++-- + tests/devices_test/device_properties_test.py | 8 ++--- + tests/devices_test/disk_test.py | 7 ++-- + tests/devices_test/lvm_test.py | 7 ++-- + tests/devices_test/partition_test.py | 6 ++-- + tests/devices_test/tags_test.py | 6 ++-- + tests/devicetree_test.py | 6 ++-- + tests/events_test.py | 6 ++-- + tests/formats_test/disklabel_test.py | 6 ++-- + tests/formats_test/luks_test.py | 6 ++-- + tests/formats_test/lvmpv_test.py | 2 -- + tests/formats_test/methods_test.py | 6 ++-- + tests/formats_test/selinux_test.py | 6 ++-- + tests/formats_test/swap_test.py | 2 -- + tests/misc_test.py | 6 ++-- + tests/partitioning_test.py | 6 ++-- + tests/populator_test.py | 6 ++-- + tests/storagetestcase.py | 5 ++- + tests/test_compat.py | 38 -------------------- + tests/udev_test.py | 6 +++- + tests/unsupported_disklabel_test.py | 7 ++-- + tests/util_test.py | 6 ++-- + 29 files changed, 104 insertions(+), 102 deletions(-) + delete mode 100644 tests/test_compat.py + +diff --git a/tests/action_test.py b/tests/action_test.py +index 38a2e872..f60cf5d7 100644 +--- a/tests/action_test.py ++++ b/tests/action_test.py +@@ -1,9 +1,8 @@ +-from six import PY3 + import unittest + +-if PY3: ++try: + from unittest.mock import Mock +-else: ++except ImportError: + from mock import Mock + + from tests.storagetestcase import StorageTestCase +diff --git a/tests/dbus_test.py b/tests/dbus_test.py +index 293ac073..9bb9102a 100644 +--- a/tests/dbus_test.py ++++ b/tests/dbus_test.py +@@ -1,7 +1,10 @@ +-import test_compat # pylint: disable=unused-import +- + import random +-from six.moves.mock import Mock, patch # pylint: disable=no-name-in-module,import-error ++ ++try: ++ from unittest.mock import patch, Mock ++except ImportError: ++ from mock import patch, Mock ++ + from unittest import TestCase + + import dbus +diff --git a/tests/devicefactory_test.py b/tests/devicefactory_test.py +index dc0d6408..93c8bdb7 100644 +--- a/tests/devicefactory_test.py ++++ b/tests/devicefactory_test.py +@@ -4,8 +4,10 @@ import unittest + 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 ++try: ++ from unittest.mock import patch ++except ImportError: ++ from mock import patch + + import blivet + +diff --git a/tests/devicelibs_test/disk_test.py b/tests/devicelibs_test/disk_test.py +index e67ef5b1..9cb39951 100644 +--- a/tests/devicelibs_test/disk_test.py ++++ b/tests/devicelibs_test/disk_test.py +@@ -1,8 +1,10 @@ + # pylint: skip-file +-import test_compat ++try: ++ from unittest.mock import Mock, patch, sentinel ++except ImportError: ++ from mock import Mock, patch, sentinel + + import six +-from six.moves.mock import Mock, patch, sentinel + import unittest + + from blivet.devicelibs import disk as disklib +diff --git a/tests/devicelibs_test/edd_test.py b/tests/devicelibs_test/edd_test.py +index 23d736f4..21bbcffc 100644 +--- a/tests/devicelibs_test/edd_test.py ++++ b/tests/devicelibs_test/edd_test.py +@@ -1,5 +1,9 @@ ++try: ++ from unittest import mock ++except ImportError: ++ import mock ++ + import unittest +-import mock + import os + import inspect + import logging +diff --git a/tests/devices_test/dependencies_test.py b/tests/devices_test/dependencies_test.py +index c012751d..493d1c9f 100644 +--- a/tests/devices_test/dependencies_test.py ++++ b/tests/devices_test/dependencies_test.py +@@ -1,8 +1,6 @@ +-# vim:set fileencoding=utf-8 +-from six import PY3 +-if PY3: ++try: + from unittest.mock import patch, PropertyMock +-else: ++except ImportError: + from mock import patch, PropertyMock + + import unittest +diff --git a/tests/devices_test/device_methods_test.py b/tests/devices_test/device_methods_test.py +index f00509be..8a70b5bb 100644 +--- a/tests/devices_test/device_methods_test.py ++++ b/tests/devices_test/device_methods_test.py +@@ -1,9 +1,11 @@ +-import test_compat # pylint: disable=unused-import +- + import six +-from six.moves.mock import patch, Mock, PropertyMock # pylint: disable=no-name-in-module,import-error + import unittest + ++try: ++ from unittest.mock import patch, Mock, PropertyMock ++except ImportError: ++ from mock import patch, PropertyMock ++ + from blivet.devices import StorageDevice + from blivet.devices import DiskDevice, PartitionDevice + from blivet.devices import LVMVolumeGroupDevice, LVMLogicalVolumeDevice +diff --git a/tests/devices_test/device_names_test.py b/tests/devices_test/device_names_test.py +index 2a66f983..ca44d38c 100644 +--- a/tests/devices_test/device_names_test.py ++++ b/tests/devices_test/device_names_test.py +@@ -1,7 +1,9 @@ + # vim:set fileencoding=utf-8 +-import test_compat # pylint: disable=unused-import ++try: ++ from unittest.mock import patch ++except ImportError: ++ from mock import patch + +-from six.moves.mock import patch # pylint: disable=no-name-in-module,import-error + import six + import unittest + +diff --git a/tests/devices_test/device_properties_test.py b/tests/devices_test/device_properties_test.py +index 240ac088..8928707f 100644 +--- a/tests/devices_test/device_properties_test.py ++++ b/tests/devices_test/device_properties_test.py +@@ -1,6 +1,3 @@ +-# vim:set fileencoding=utf-8 +-import test_compat # pylint: disable=unused-import +- + import six + import unittest + +@@ -9,7 +6,10 @@ gi.require_version("BlockDev", "2.0") + + from gi.repository import BlockDev as blockdev + +-from six.moves.mock import Mock, patch # pylint: disable=no-name-in-module,import-error ++try: ++ from unittest.mock import patch, Mock ++except ImportError: ++ from mock import patch, Mock + + import blivet + +diff --git a/tests/devices_test/disk_test.py b/tests/devices_test/disk_test.py +index e9852303..cc8454e1 100644 +--- a/tests/devices_test/disk_test.py ++++ b/tests/devices_test/disk_test.py +@@ -1,7 +1,8 @@ + # pylint: skip-file +-import test_compat +- +-from six.moves.mock import patch ++try: ++ from unittest.mock import patch ++except ImportError: ++ from mock import patch + import unittest + + from blivet.devices import DiskDevice +diff --git a/tests/devices_test/lvm_test.py b/tests/devices_test/lvm_test.py +index 670c91c9..f50933c4 100644 +--- a/tests/devices_test/lvm_test.py ++++ b/tests/devices_test/lvm_test.py +@@ -1,8 +1,9 @@ +-# vim:set fileencoding=utf-8 +-import test_compat # pylint: disable=unused-import ++try: ++ from unittest.mock import patch, PropertyMock ++except ImportError: ++ from mock import patch, PropertyMock + + import six +-from six.moves.mock import patch, PropertyMock # pylint: disable=no-name-in-module,import-error + import unittest + + import blivet +diff --git a/tests/devices_test/partition_test.py b/tests/devices_test/partition_test.py +index 0abd88df..4748dafe 100644 +--- a/tests/devices_test/partition_test.py ++++ b/tests/devices_test/partition_test.py +@@ -1,5 +1,4 @@ + # vim:set fileencoding=utf-8 +-import test_compat # pylint: disable=unused-import + + from collections import namedtuple + import os +@@ -7,7 +6,10 @@ import six + import unittest + import parted + +-from six.moves.mock import Mock, patch # pylint: disable=no-name-in-module,import-error ++try: ++ from unittest.mock import patch, Mock ++except ImportError: ++ from mock import patch, Mock + + from blivet.devices import DiskFile + from blivet.devices import PartitionDevice +diff --git a/tests/devices_test/tags_test.py b/tests/devices_test/tags_test.py +index 1edc37f6..49a2d72e 100644 +--- a/tests/devices_test/tags_test.py ++++ b/tests/devices_test/tags_test.py +@@ -1,6 +1,8 @@ +-import test_compat # pylint: disable=unused-import ++try: ++ from unittest.mock import patch ++except ImportError: ++ from mock import patch + +-from six.moves.mock import patch # pylint: disable=no-name-in-module,import-error + import unittest + + from blivet.devices import DiskDevice, FcoeDiskDevice, iScsiDiskDevice, MultipathDevice, StorageDevice, ZFCPDiskDevice +diff --git a/tests/devicetree_test.py b/tests/devicetree_test.py +index 11f8469d..fbf31c77 100644 +--- a/tests/devicetree_test.py ++++ b/tests/devicetree_test.py +@@ -1,6 +1,8 @@ +-import test_compat # pylint: disable=unused-import ++try: ++ from unittest.mock import patch, Mock, PropertyMock, sentinel ++except ImportError: ++ from mock import patch, Mock, PropertyMock, sentinel + +-from six.moves.mock import Mock, patch, PropertyMock, sentinel # pylint: disable=no-name-in-module,import-error + import os + import six + import unittest +diff --git a/tests/events_test.py b/tests/events_test.py +index 5906b4e2..22666f6d 100644 +--- a/tests/events_test.py ++++ b/tests/events_test.py +@@ -1,6 +1,8 @@ +-import test_compat # pylint: disable=unused-import ++try: ++ from unittest.mock import patch, Mock ++except ImportError: ++ from mock import patch, Mock + +-from six.moves.mock import Mock, patch # pylint: disable=no-name-in-module,import-error + import time + from unittest import TestCase + +diff --git a/tests/formats_test/disklabel_test.py b/tests/formats_test/disklabel_test.py +index 0cfa736d..f514a778 100644 +--- a/tests/formats_test/disklabel_test.py ++++ b/tests/formats_test/disklabel_test.py +@@ -1,7 +1,9 @@ +-import test_compat # pylint: disable=unused-import ++try: ++ from unittest import mock ++except ImportError: ++ import mock + + import parted +-from six.moves import mock # pylint: disable=no-name-in-module,import-error + import unittest + + import blivet +diff --git a/tests/formats_test/luks_test.py b/tests/formats_test/luks_test.py +index be0d50b0..1edbdcb2 100644 +--- a/tests/formats_test/luks_test.py ++++ b/tests/formats_test/luks_test.py +@@ -1,6 +1,8 @@ +-import test_compat # pylint: disable=unused-import ++try: ++ from unittest.mock import patch ++except ImportError: ++ from mock import patch + +-from six.moves.mock import patch # pylint: disable=no-name-in-module,import-error + import unittest + + from blivet.formats.luks import LUKS +diff --git a/tests/formats_test/lvmpv_test.py b/tests/formats_test/lvmpv_test.py +index 792a2f1d..cbd2c419 100644 +--- a/tests/formats_test/lvmpv_test.py ++++ b/tests/formats_test/lvmpv_test.py +@@ -1,5 +1,3 @@ +-import test_compat # pylint: disable=unused-import +- + from blivet.formats.lvmpv import LVMPhysicalVolume + + from blivet.size import Size +diff --git a/tests/formats_test/methods_test.py b/tests/formats_test/methods_test.py +index b2674ea7..2743b7db 100644 +--- a/tests/formats_test/methods_test.py ++++ b/tests/formats_test/methods_test.py +@@ -1,7 +1,9 @@ +-import test_compat # pylint: disable=unused-import ++try: ++ from unittest.mock import patch, sentinel, PropertyMock ++except ImportError: ++ from mock import patch, sentinel, PropertyMock + + import six +-from six.moves.mock import patch, sentinel, PropertyMock # pylint: disable=no-name-in-module,import-error + import unittest + + from blivet.errors import DeviceFormatError +diff --git a/tests/formats_test/selinux_test.py b/tests/formats_test/selinux_test.py +index 02e39011..26df5fe9 100644 +--- a/tests/formats_test/selinux_test.py ++++ b/tests/formats_test/selinux_test.py +@@ -1,9 +1,9 @@ + # pylint: disable=unused-import + import os +-from six import PY3 +-if PY3: ++ ++try: + from unittest.mock import patch, ANY +-else: ++except ImportError: + from mock import patch, ANY + + import unittest +diff --git a/tests/formats_test/swap_test.py b/tests/formats_test/swap_test.py +index 56356144..8968ca15 100644 +--- a/tests/formats_test/swap_test.py ++++ b/tests/formats_test/swap_test.py +@@ -1,5 +1,3 @@ +-import test_compat # pylint: disable=unused-import +- + import six + import unittest + +diff --git a/tests/misc_test.py b/tests/misc_test.py +index 3c8cf344..10ea1320 100644 +--- a/tests/misc_test.py ++++ b/tests/misc_test.py +@@ -1,7 +1,9 @@ + import unittest + +-import test_compat # pylint: disable=unused-import +-from six.moves.mock import patch # pylint: disable=no-name-in-module,import-error ++try: ++ from unittest.mock import patch ++except ImportError: ++ from mock import patch + + import blivet + +diff --git a/tests/partitioning_test.py b/tests/partitioning_test.py +index b7aa5045..9b27f0c0 100644 +--- a/tests/partitioning_test.py ++++ b/tests/partitioning_test.py +@@ -1,6 +1,8 @@ +-import test_compat # pylint: disable=unused-import ++try: ++ from unittest.mock import patch, Mock ++except ImportError: ++ from mock import patch, Mock + +-from six.moves.mock import Mock, patch # pylint: disable=no-name-in-module,import-error + import six + import unittest + +diff --git a/tests/populator_test.py b/tests/populator_test.py +index a7748a9d..2a8532f0 100644 +--- a/tests/populator_test.py ++++ b/tests/populator_test.py +@@ -1,7 +1,9 @@ +-import test_compat # pylint: disable=unused-import ++try: ++ from unittest.mock import call, patch, sentinel, Mock, PropertyMock ++except ImportError: ++ from mock import call, patch, sentinel, Mock, PropertyMock + + import gi +-from six.moves.mock import call, patch, sentinel, Mock, PropertyMock # pylint: disable=no-name-in-module,import-error + import six + import unittest + +diff --git a/tests/storagetestcase.py b/tests/storagetestcase.py +index 1844dec5..1b856914 100644 +--- a/tests/storagetestcase.py ++++ b/tests/storagetestcase.py +@@ -1,6 +1,9 @@ + + import unittest +-from mock import Mock ++try: ++ from unittest.mock import Mock ++except ImportError: ++ from mock import Mock + + import parted + +diff --git a/tests/test_compat.py b/tests/test_compat.py +deleted file mode 100644 +index d0859e24..00000000 +--- a/tests/test_compat.py ++++ /dev/null +@@ -1,38 +0,0 @@ +-# test_compat.py +-# Python (2 -v- 3) compatibility functions. +-# +-# Copyright (C) 2017 Red Hat, Inc. +-# +-# This copyrighted material is made available to anyone wishing to use, +-# modify, copy, or redistribute it subject to the terms and conditions of +-# the GNU Lesser General Public License v.2, or (at your option) any later +-# version. This program is distributed in the hope that it will be useful, +-# but WITHOUT ANY WARRANTY expressed or implied, including the implied +-# warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See +-# the GNU Lesser General Public License for more details. You should have +-# received a copy of the GNU Lesser General Public License along with this +-# program; if not, write to the Free Software Foundation, Inc., 51 Franklin +-# Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat trademarks +-# that are incorporated in the source code or documentation are not subject +-# to the GNU Lesser General Public License and may only be used or +-# replicated with the express permission of Red Hat, Inc. +-# +-# Red Hat Author(s): David Lehman +-# +- +-import six as _six +- +-mock_move = _six.MovedModule('mock', 'mock', 'unittest.mock') +- +- +-def add_move(mod): +- _six.add_move(mod) +- # https://bitbucket.org/gutworth/six/issues/116/enable-importing-from-within-custom +- _six._importer._add_module(mod, "moves." + mod.name) +- +- +-def setup(): +- add_move(mock_move) +- +- +-setup() +diff --git a/tests/udev_test.py b/tests/udev_test.py +index f9b10620..569a144e 100644 +--- a/tests/udev_test.py ++++ b/tests/udev_test.py +@@ -1,6 +1,10 @@ + + import unittest +-import mock ++ ++try: ++ from unittest import mock ++except ImportError: ++ import mock + + from udev_data import raid_data + +diff --git a/tests/unsupported_disklabel_test.py b/tests/unsupported_disklabel_test.py +index f5b24779..38055333 100644 +--- a/tests/unsupported_disklabel_test.py ++++ b/tests/unsupported_disklabel_test.py +@@ -1,7 +1,8 @@ +-# vim:set fileencoding=utf-8 +-import test_compat # pylint: disable=unused-import ++try: ++ from unittest.mock import patch, sentinel, DEFAULT ++except ImportError: ++ from mock import patch, sentinel, DEFAULT + +-from six.moves.mock import patch, sentinel, DEFAULT # pylint: disable=no-name-in-module,import-error + import six + import unittest + +diff --git a/tests/util_test.py b/tests/util_test.py +index 853b6166..b4f82c1b 100644 +--- a/tests/util_test.py ++++ b/tests/util_test.py +@@ -1,7 +1,9 @@ + # pylint: skip-file +-import test_compat ++try: ++ from unittest import mock ++except ImportError: ++ import mock + +-from six.moves import mock + import os + import six + import tempfile +-- +2.31.1 + diff --git a/0006-Fix-util.virt_detect-on-Xen.patch b/0006-Fix-util.virt_detect-on-Xen.patch new file mode 100644 index 0000000..4c1399a --- /dev/null +++ b/0006-Fix-util.virt_detect-on-Xen.patch @@ -0,0 +1,23 @@ +From d609cebba48744c97ac7e0461f8827ab63198026 Mon Sep 17 00:00:00 2001 +From: Vojtech Trefny +Date: Thu, 10 Jun 2021 16:58:42 +0200 +Subject: [PATCH] Fix util.virt_detect on Xen + +Xen is apparently still alive so we should return True for it too. +--- + blivet/util.py | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/blivet/util.py b/blivet/util.py +index 3bebb003..af60210b 100644 +--- a/blivet/util.py ++++ b/blivet/util.py +@@ -1130,4 +1130,4 @@ def detect_virt(): + except (safe_dbus.DBusCallError, safe_dbus.DBusPropertyError): + return False + else: +- return vm[0] in ('qemu', 'kvm') ++ return vm[0] in ('qemu', 'kvm', 'xen') +-- +2.31.1 + diff --git a/python-blivet.spec b/python-blivet.spec index f174194..873d560 100644 --- a/python-blivet.spec +++ b/python-blivet.spec @@ -19,28 +19,30 @@ Summary: A python module for system storage configuration Name: python-blivet Url: https://storageapis.wordpress.com/projects/blivet -Version: 3.3.3 +Version: 3.4.0 #%%global prerelease .b2 # prerelease, if defined, should be something like .a1, .b1, .b2.dev1, or .c2 -Release: 2%{?prerelease}%{?dist} +Release: 1%{?prerelease}%{?dist} Epoch: 1 License: LGPLv2+ %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 - -%if 0%{?rhel} >= 9 -Patch0: 0001-remove-btrfs-plugin.patch -%endif +Patch0: 0001-force-lvm-cli-plugin.patch +Patch1: 0002-remove-btrfs-plugin.patch +Patch2: 0003-Revert-More-consistent-lvm-errors.patch +Patch3: 0004-Revert-Terminology-cleanups.patch +Patch4: 0005-Fix-unify-importing-mock-module-in-tests.patch +Patch5: 0006-Fix-util.virt_detect-on-Xen.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 @@ -73,7 +75,7 @@ BuildRequires: gettext BuildRequires: python3-devel BuildRequires: python3-setuptools -Requires: python3 +%{?__python3:Requires: %{__python3}} Requires: python3-six Requires: python3-pyudev >= %{pyudevver} Requires: parted >= %{partedver} @@ -196,6 +198,10 @@ configuration. %endif %changelog +* Wed Jun 9 2021 Vojtech Trefny - 3.4.0-1 +- Rebase to latest upstream release 3.4.0 + Resolves: rhbz#1964341 + * Fri Apr 16 2021 Mohan Boddu - 1:3.3.3-2 - Rebuilt for RHEL 9 BETA on Apr 15th 2021. Related: rhbz#1947937 diff --git a/sources b/sources index 7491483..4cec5b7 100644 --- a/sources +++ b/sources @@ -1,2 +1,2 @@ -SHA512 (blivet-3.3.3-tests.tar.gz) = d884db3699762563d8ec9968f127a694a29f089eb783cd74adcadc41b9eccc25416cb1a32d81c9534e20b206c060d0b117fb2846778f879611fc2e511ef4cc59 -SHA512 (blivet-3.3.3.tar.gz) = c4eb96f6856a6dc7c6cd78bda064f5dd890951714a627b231488327b8790f16160a088842c9c3627ecb8551b25379402a4af9e777e8c610e7d5810baf5a0a41a +SHA512 (blivet-3.4.0-tests.tar.gz) = 98351de3a3121d777b644537fedd24596843e609b9e8d9fa6f61729d6bf726bc343c2bb7712ba41138f82738235654756122a290645293df6c2a22944e0a08f7 +SHA512 (blivet-3.4.0.tar.gz) = c6797765b82313c55157169489be3e52d03f7656978c6c75bb87c6f1715ceb2447f9fe79cbc3d1d2d00c56329fabca524e1ab7ab074877f6edc8daf62f524038 diff --git a/tests/tests.yml b/tests/tests.yml index 64d4c3f..f159642 100644 --- a/tests/tests.yml +++ b/tests/tests.yml @@ -1,16 +1,21 @@ --- +# - hosts: localhost - hosts: all roles: + - role: standard-test-source + tags: + - always + - role: standard-test-basic tags: + - atomic - classic + required_packages: + - python3 + - python3-dbus + - libblockdev-plugins-all tests: - - list-devices-1: - dir: . - run: python3 /usr/share/doc/python3-blivet/examples/list_devices.py - - lvm-factory: - dir: . - run: python3 ./lvm_factory.py --disks=vdb,vdc - - list-devices-2: + - unit-tests: dir: . - run: python3 /usr/share/doc/python3-blivet/examples/list_devices.py + run: ./unit_testing.sh + diff --git a/tests/unit_testing.sh b/tests/unit_testing.sh new file mode 100644 index 0000000..be4630a --- /dev/null +++ b/tests/unit_testing.sh @@ -0,0 +1,12 @@ +#!/bin/bash + +# Bail out if anything goes wrong +set -e + +# Get path to blivet +blivet_path=$(find /usr/ -path */site-packages/) + +# Run upstream unit tests +cd ./source/ +PYTHONPATH=$PYTHONPATH:$blivet_path python3 -m unittest discover -v -s ./tests/ -p '*_test.py' +