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