The only reason to import udev in blivet.formats.__init__.py is for the methods that are removed in "Remove all references". Importing udev, rather than names from udev, causes pylint errors that cannot be dismissed with the disable= annotations. Trying to figure out what was going on caused me to notice that these methods should probably just go away. I still dunno what was up w/ pylint.
mulhern (2): Remove all references to DeviceFormat.majorminor Remove udev_ prefix from udev methods.
blivet/__init__.py | 2 +- blivet/deviceaction.py | 10 +- blivet/devices.py | 57 +++++---- blivet/devicetree.py | 298 ++++++++++++++++++++++---------------------- blivet/fcoe.py | 4 +- blivet/formats/__init__.py | 44 ------- blivet/formats/disklabel.py | 4 +- blivet/formats/fs.py | 4 +- blivet/iscsi.py | 4 +- blivet/udev.py | 274 ++++++++++++++++++++-------------------- blivet/zfcp.py | 8 +- tests/devicetree_test.py | 4 +- tests/udev_test.py | 36 +++--- 13 files changed, 352 insertions(+), 397 deletions(-)
And remove a bit of related code as well. Last uses of majorminor were removed in anaconda commit d819bb940717270f4c5747e894ef0c5ac509dfe2. majorminor was originally added in commit 2875d2009f30f52b79f6f7d15916f73b490bc635.
Signed-off-by: mulhern amulhern@redhat.com --- blivet/devices.py | 1 - blivet/formats/__init__.py | 44 -------------------------------------------- 2 files changed, 45 deletions(-)
diff --git a/blivet/devices.py b/blivet/devices.py index 4a485e8..7db3c95 100644 --- a/blivet/devices.py +++ b/blivet/devices.py @@ -859,7 +859,6 @@ class StorageDevice(Device):
if self.originalFormat.exists: self.originalFormat.teardown() - self.format.cacheMajorminor() if self.format.exists: self.format.teardown() udev.udev_settle() diff --git a/blivet/formats/__init__.py b/blivet/formats/__init__.py index 154f305..8b1d2fa 100644 --- a/blivet/formats/__init__.py +++ b/blivet/formats/__init__.py @@ -22,7 +22,6 @@
import os
-from ..udev import udev_get_device from ..util import notify_kernel from ..util import get_sysfs_path_by_name from ..util import run_program @@ -31,7 +30,6 @@ from ..storage_log import log_method_call from ..errors import DeviceFormatError, DMError, FormatCreateError, FormatDestroyError, FormatSetupError, MDRaidError, StorageError from ..devicelibs.dm import dm_node_from_name from ..devicelibs.mdraid import md_node_from_name -from ..udev import udev_device_get_major, udev_device_get_minor from ..i18n import _, N_ from ..size import Size
@@ -185,7 +183,6 @@ class DeviceFormat(ObjectID): self.uuid = kwargs.get("uuid") self.exists = kwargs.get("exists") self.options = kwargs.get("options") - self._majorminor = None
# don't worry about existence if this is a DeviceFormat instance #if self.__class__ is DeviceFormat: @@ -349,25 +346,6 @@ class DeviceFormat(ObjectID): except (ValueError, IOError) as e: log.warning("failed to notify kernel of change: %s", e)
- def cacheMajorminor(self): - """ Cache the value of self.majorminor. - - Once a device node of this format's device disappears (for instance - after a teardown), it is no longer possible to figure out the value - of self.majorminor pseudo-unique string. Call this method before - that happens for caching this. - """ - self._majorminor = None - try: - self.majorminor # this does the caching - except StorageError: - # entirely possible there's no majorminor, for instance an - # LVMVolumeGroup has got no device node and no sysfs path. In this - # case obviously, calling majorminor of this object later raises an - # exception. - pass - return self._majorminor - def create(self, **kwargs): """ Write the formatting to the specified block device.
@@ -519,28 +497,6 @@ class DeviceFormat(ObjectID): return self._hidden
@property - def majorminor(self): - """A string suitable for using as a pseudo-unique ID in kickstart.""" - if not self._majorminor: - # If this is a device-mapper device, we have to get the DM node and - # build the sysfs path from that. - try: - device = dm_node_from_name(os.path.basename(self.device)) - except DMError: - device = self.device - - try: - sysfs_path = get_sysfs_path_by_name(device) - except RuntimeError: - raise StorageError("DeviceFormat.majorminor: " - "can not get majorminor for '%s'" % device) - dev = udev_get_device(sysfs_path[4:]) - - self._majorminor = "%03d%03d" %\ - (udev_device_get_major(dev), udev_device_get_minor(dev)) - return self._majorminor - - @property def ksMountpoint(self): return (self._ksMountpoint or self.type or "")
The udev namespace identifies the methods adequately. Update method calls appropriately.
Signed-off-by: mulhern amulhern@redhat.com --- blivet/__init__.py | 2 +- blivet/deviceaction.py | 10 +- blivet/devices.py | 56 ++++----- blivet/devicetree.py | 298 ++++++++++++++++++++++---------------------- blivet/fcoe.py | 4 +- blivet/formats/disklabel.py | 4 +- blivet/formats/fs.py | 4 +- blivet/iscsi.py | 4 +- blivet/udev.py | 274 ++++++++++++++++++++-------------------- blivet/zfcp.py | 8 +- tests/devicetree_test.py | 4 +- tests/udev_test.py | 36 +++--- 12 files changed, 352 insertions(+), 352 deletions(-)
diff --git a/blivet/__init__.py b/blivet/__init__.py index 38fa5c2..e094b7a 100644 --- a/blivet/__init__.py +++ b/blivet/__init__.py @@ -83,7 +83,7 @@ from .devicelibs.dm import name_from_dm_node from .devicelibs.crypto import generateBackupPassphrase from .devicelibs.edd import get_edd_dict from .devicelibs.dasd import make_dasd_list, write_dasd_conf -from .udev import udev_trigger +from . import udev from . import iscsi from . import fcoe from . import zfcp diff --git a/blivet/deviceaction.py b/blivet/deviceaction.py index 9ffcc5a..db4c7a7 100644 --- a/blivet/deviceaction.py +++ b/blivet/deviceaction.py @@ -553,16 +553,16 @@ class ActionCreateFormat(DeviceAction): self.device.format.create(device=self.device.path, options=self.device.formatArgs) # Get the UUID now that the format is created - udev.udev_settle() + udev.settle() self.device.updateSysfsPath() - info = udev.udev_get_block_device(self.device.sysfsPath) + info = udev.get_block_device(self.device.sysfsPath) # only do this if the format has a device known to udev # (the format might not have a normal device at all) if info: if self.device.format.type != "btrfs": - self.device.format.uuid = udev.udev_device_get_uuid(info) + self.device.format.uuid = udev.device_get_uuid(info)
- self.device.deviceLinks = udev.udev_device_get_symlinks(info) + self.device.deviceLinks = udev.device_get_symlinks(info) elif self.device.format.type != "tmpfs": # udev lookup failing is a serious issue for anything other than tmpfs log.error("udev lookup failed for device: %s", self.device) @@ -632,7 +632,7 @@ class ActionDestroyFormat(DeviceAction): status = self.device.status self.device.setup(orig=True) self.format.destroy() - udev.udev_settle() + udev.settle() if not status: self.device.teardown()
diff --git a/blivet/devices.py b/blivet/devices.py index 7db3c95..c44be88 100644 --- a/blivet/devices.py +++ b/blivet/devices.py @@ -105,9 +105,9 @@ def deviceNameToDiskByPath(deviceName=None): return ""
ret = None - for dev in udev.udev_get_block_devices(): - if udev.udev_device_get_name(dev) == deviceName: - ret = udev.udev_device_get_by_path(dev) + for dev in udev.get_block_devices(): + if udev.device_get_name(dev) == deviceName: + ret = udev.device_get_by_path(dev) break
if ret: @@ -838,7 +838,7 @@ class StorageDevice(Device):
def _postSetup(self): """ Perform post-setup operations. """ - udev.udev_settle() + udev.settle() # we always probe since the device may not be set up when we want # information about it self._size = self.currentSize @@ -861,7 +861,7 @@ class StorageDevice(Device): self.originalFormat.teardown() if self.format.exists: self.format.teardown() - udev.udev_settle() + udev.settle() return True
def _teardown(self, recursive=None): @@ -913,7 +913,7 @@ class StorageDevice(Device): self.exists = True self.setup() self.updateSysfsPath() - udev.udev_settle() + udev.settle()
# make sure that targetSize is updated to reflect the actual size if self.resizable: @@ -1696,7 +1696,7 @@ class PartitionDevice(StorageDevice): # If a udev device is created with the watch option, then # a change uevent is synthesized and we need to wait for # things to settle. - udev.udev_settle() + udev.settle()
def _create(self): """ Create the device. """ @@ -1810,7 +1810,7 @@ class PartitionDevice(StorageDevice): def _postDestroy(self): super(PartitionDevice, self)._postDestroy() if isinstance(self.disk, DMDevice): - udev.udev_settle() + udev.settle() if self.status: try: dm.dm_remove(self.name) @@ -1830,7 +1830,7 @@ class PartitionDevice(StorageDevice): block.removeDeviceMap(devmap) except Exception as e: raise errors.DeviceTeardownError("failed to tear down device-mapper partition %s: %s" % (self.name, e)) - udev.udev_settle() + udev.settle()
def _getSize(self): """ Get the device's size. """ @@ -2058,14 +2058,14 @@ class DMDevice(StorageDevice): rc = util.run_program(["kpartx", "-a", "-s", self.path]) if rc: raise errors.DMError("partition activation failed for '%s'" % self.name) - udev.udev_settle() + udev.settle()
def teardownPartitions(self): log_method_call(self, name=self.name, kids=self.kids) rc = util.run_program(["kpartx", "-d", "-s", self.path]) if rc: raise errors.DMError("partition deactivation failed for '%s'" % self.name) - udev.udev_settle() + udev.settle() for dev in os.listdir("/dev/mapper/"): prefix = self.name + "p" if dev.startswith(prefix) and dev[len(prefix):].isdigit(): @@ -2130,13 +2130,13 @@ class DMLinearDevice(DMDevice): def _postSetup(self): StorageDevice._postSetup(self) self.setupPartitions() - udev.udev_settle() + udev.settle()
def _teardown(self, recursive=False): self.teardownPartitions() - udev.udev_settle() + udev.settle() dm.dm_remove(self.name) - udev.udev_settle() + udev.settle()
def deactivate(self, recursive=False): StorageDevice.teardown(self, recursive=recursive) @@ -3043,7 +3043,7 @@ class LVMLogicalVolumeDevice(DMDevice): if self.format.exists: self.format.teardown()
- udev.udev_settle() + udev.settle() lvm.lvresize(self.vg.name, self._name, self.size)
@property @@ -3218,7 +3218,7 @@ class LVMSnapShotBase(object): except errors.FSError: pass
- udev.udev_settle() + udev.settle() lvm.lvsnapshotmerge(self.vg.name, self.lvname) # pylint: disable=no-member
class LVMSnapShotDevice(LVMSnapShotBase, LVMLogicalVolumeDevice): @@ -3806,13 +3806,13 @@ class MDRaidArrayDevice(ContainerDevice): ## XXX TODO: remove this whole block of activation code if self.exists and member.format.exists and flags.installer_mode: member.setup() - udev.udev_settle() + udev.settle()
if self.spares <= 0: try: mdraid.mdadd(None, member.path, incremental=True) # mdadd causes udev events - udev.udev_settle() + udev.settle() except errors.MDRaidError as e: log.warning("failed to add member %s to md array %s: %s", member.path, self.path, e) @@ -3860,8 +3860,8 @@ class MDRaidArrayDevice(ContainerDevice): self.updateSysfsPath()
# make sure the active array is the one we expect - info = udev.udev_get_block_device(self.sysfsPath) - uuid = udev.udev_device_get_md_uuid(info) + info = udev.get_block_device(self.sysfsPath) + uuid = udev.device_get_md_uuid(info) if uuid and uuid != self.uuid: log.warning("md array %s is active, but has UUID %s -- not %s", self.path, uuid, self.uuid) @@ -4005,8 +4005,8 @@ class MDRaidArrayDevice(ContainerDevice): StorageDevice._postCreate(self)
# update our uuid attribute with the new array's UUID - info = udev.udev_get_block_device(self.sysfsPath) - self.uuid = udev.udev_device_get_md_uuid(info) + info = udev.get_block_device(self.sysfsPath) + self.uuid = udev.device_get_md_uuid(info) for member in self.devices: member.format.mdUuid = self.uuid
@@ -4021,7 +4021,7 @@ class MDRaidArrayDevice(ContainerDevice): spares, metadataVer=self.metadataVersion, bitmap=self.createBitmap) - udev.udev_settle() + udev.settle()
def _remove(self, member): self.setup() @@ -4141,7 +4141,7 @@ class DMRaidArrayDevice(DMDevice, ContainerDevice): log_method_call(self, self.name, status=self.status) # This call already checks if the set is active. self._raidSet.activate(mknod=True) - udev.udev_settle() + udev.settle()
def _setup(self, orig=False): """ Open, or set up, a device. """ @@ -4277,7 +4277,7 @@ class MultipathDevice(DMDevice): """ Open, or set up, a device. """ log_method_call(self, self.name, orig=orig, status=self.status, controllable=self.controllable) - udev.udev_settle() + udev.settle() rc = util.run_program(["multipath", self.name]) if rc: raise errors.MPathError("multipath activation failed for '%s'" % @@ -4286,7 +4286,7 @@ class MultipathDevice(DMDevice): def _postSetup(self): StorageDevice._postSetup(self) self.setupPartitions() - udev.udev_settle() + udev.settle()
class NoDevice(StorageDevice): """ A nodev device for nodev filesystems like tmpfs. """ @@ -5226,11 +5226,11 @@ class BTRFSVolumeDevice(BTRFSDevice, ContainerDevice):
def _postCreate(self): super(BTRFSVolumeDevice, self)._postCreate() - info = udev.udev_get_block_device(self.sysfsPath) + info = udev.get_block_device(self.sysfsPath) if not info: log.error("failed to get updated udev info for new btrfs volume") else: - self.format.volUUID = udev.udev_device_get_uuid(info) + self.format.volUUID = udev.device_get_uuid(info)
self.format.exists = True self.originalFormat.exists = True diff --git a/blivet/devicetree.py b/blivet/devicetree.py index 9403fc3..b6dee52 100644 --- a/blivet/devicetree.py +++ b/blivet/devicetree.py @@ -363,7 +363,7 @@ class DeviceTree(object):
action.execute()
- udev.udev_settle() + udev.settle() for device in self._devices: # make sure we catch any renumbering parted does if device.exists and isinstance(device, PartitionDevice): @@ -608,8 +608,8 @@ class DeviceTree(object): :rtype: bool
""" - sysfs_path = udev.udev_device_get_sysfs_path(info) - name = udev.udev_device_get_name(info) + sysfs_path = udev.device_get_sysfs_path(info) + name = udev.device_get_name(info) if not sysfs_path: return None
@@ -619,14 +619,14 @@ class DeviceTree(object): # 2) Sets get added to exclusive disks with their dmraid set name by # the filter ui. Note that making the ui use md names instead is not # possible as the md names are simpy md# and we cannot predict the # - if udev.udev_device_is_md(info) and \ - udev.udev_device_get_md_level(info) == "container": + if udev.device_is_md(info) and \ + udev.device_get_md_level(info) == "container": return False
- if udev.udev_device_get_md_container(info) and \ - udev.udev_device_is_md(info) and \ - udev.udev_device_get_md_name(info): - md_name = udev.udev_device_get_md_name(info) + if udev.device_get_md_container(info) and \ + udev.device_is_md(info) and \ + udev.device_get_md_name(info): + md_name = udev.device_get_md_name(info) # mdadm may have appended _<digit>+ if the current hostname # does not match the one in the array metadata alt_name = re.sub(r"_\d+$", "", md_name) @@ -640,7 +640,7 @@ class DeviceTree(object):
# never ignore mapped disk images. if you don't want to use them, # don't specify them in the first place - if udev.udev_device_is_dm_anaconda(info) or udev.udev_device_is_dm_livecd(info): + if udev.device_is_dm_anaconda(info) or udev.device_is_dm_livecd(info): return False
# Ignore loop and ram devices, we normally already skip these in @@ -683,21 +683,21 @@ class DeviceTree(object): udev/sysfs, we have to define what is a disk in terms of what is not a disk. """ - return (udev.udev_device_is_disk(info) and - not (udev.udev_device_is_cdrom(info) or - udev.udev_device_is_partition(info) or - udev.udev_device_is_dm_partition(info) or - udev.udev_device_is_dm_lvm(info) or - udev.udev_device_is_dm_crypt(info) or - (udev.udev_device_is_md(info) and - not udev.udev_device_get_md_container(info)))) + return (udev.device_is_disk(info) and + not (udev.device_is_cdrom(info) or + udev.device_is_partition(info) or + udev.device_is_dm_partition(info) or + udev.device_is_dm_lvm(info) or + udev.device_is_dm_crypt(info) or + (udev.device_is_md(info) and + not udev.device_get_md_container(info))))
def addUdevLVDevice(self, info): - name = udev.udev_device_get_name(info) + name = udev.device_get_name(info) log_method_call(self, name=name) - sysfs_path = udev.udev_device_get_sysfs_path(info) + sysfs_path = udev.device_get_sysfs_path(info)
- vg_name = udev.udev_device_get_lv_vg_name(info) + vg_name = udev.device_get_lv_vg_name(info) device = self.getDeviceByName(vg_name, hidden=True) if device and not isinstance(device, LVMVolumeGroupDevice): log.warning("found non-vg device with name %s", vg_name) @@ -709,10 +709,10 @@ class DeviceTree(object): for pv_name in os.listdir("/sys" + sysfs_path + "/slaves"): link = os.readlink("/sys" + sysfs_path + "/slaves/" + pv_name) pv_sysfs_path = os.path.normpath(sysfs_path + '/slaves/' + link) - pv_info = udev.udev_get_block_device(pv_sysfs_path) + pv_info = udev.get_block_device(pv_sysfs_path) self.addUdevDevice(pv_info)
- vg_name = udev.udev_device_get_lv_vg_name(info) + vg_name = udev.device_get_lv_vg_name(info) device = self.getDeviceByName(vg_name) if not device: log.error("failed to find vg '%s' after scanning pvs", vg_name) @@ -721,9 +721,9 @@ class DeviceTree(object): # methods. The device we have here is a vg, not an lv.
def addUdevDMDevice(self, info): - name = udev.udev_device_get_name(info) + name = udev.device_get_name(info) log_method_call(self, name=name) - sysfs_path = udev.udev_device_get_sysfs_path(info) + sysfs_path = udev.device_get_sysfs_path(info) device = None
for dmdev in self.devices: @@ -745,7 +745,7 @@ class DeviceTree(object): log.debug("failed to find dm node for %s", dmdev.name) continue
- handle_luks = (udev.udev_device_is_dm_luks(info) and + handle_luks = (udev.device_is_dm_luks(info) and (self._cleanup or not flags.installer_mode)) slave_dev = None slave_info = None @@ -762,7 +762,7 @@ class DeviceTree(object): dev_name = slave_name.replace("!", "/") # handles cciss slave_dev = self.getDeviceByName(dev_name) path = os.path.normpath("%s/%s" % (slave_dir, slave_name)) - new_info = udev.udev_get_block_device(os.path.realpath(path)[4:]) + new_info = udev.get_block_device(os.path.realpath(path)[4:]) if not slave_dev: # we haven't scanned the slave yet, so do it now if new_info: @@ -780,8 +780,8 @@ class DeviceTree(object): # try to get the device again now that we've got all the slaves device = self.getDeviceByName(name)
- if device is None and udev.udev_device_is_dm_partition(info): - diskname = udev.udev_device_get_dm_partition_disk(info) + if device is None and udev.device_is_dm_partition(info): + diskname = udev.device_get_dm_partition_disk(info) disk = self.getDeviceByName(diskname) return self.addUdevPartitionDevice(info, disk=disk)
@@ -795,7 +795,7 @@ class DeviceTree(object): device = self.getDeviceByName(name)
# create a device for the livecd OS image(s) - if device is None and udev.udev_device_is_dm_livecd(info): + if device is None and udev.device_is_dm_livecd(info): device = DMDevice(name, dmUuid=info.get('DM_UUID'), sysfsPath=sysfs_path, exists=True, parents=[slave_dev]) @@ -813,9 +813,9 @@ class DeviceTree(object): return device
def addUdevMultiPathDevice(self, info): - name = udev.udev_device_get_name(info) + name = udev.device_get_name(info) log_method_call(self, name=name) - sysfs_path = udev.udev_device_get_sysfs_path(info) + sysfs_path = udev.device_get_sysfs_path(info)
slave_devs = []
@@ -832,7 +832,7 @@ class DeviceTree(object): dev_name = slave_name.replace("!", "/") # handles cciss slave_dev = self.getDeviceByName(dev_name) path = os.path.normpath("%s/%s" % (slave_dir, slave_name)) - new_info = udev.udev_get_block_device(os.path.realpath(path)[4:]) + new_info = udev.get_block_device(os.path.realpath(path)[4:]) if not slave_dev: # we haven't scanned the slave yet, so do it now if new_info: @@ -861,9 +861,9 @@ class DeviceTree(object): return device
def addUdevMDDevice(self, info): - name = udev.udev_device_get_md_name(info) + name = udev.device_get_md_name(info) log_method_call(self, name=name) - sysfs_path = udev.udev_device_get_sysfs_path(info) + sysfs_path = udev.device_get_sysfs_path(info)
slave_dir = os.path.normpath("/sys/%s/slaves" % sysfs_path) slave_names = os.listdir(slave_dir) @@ -877,7 +877,7 @@ class DeviceTree(object): if not slave_dev: # we haven't scanned the slave yet, so do it now path = os.path.normpath("%s/%s" % (slave_dir, slave_name)) - new_info = udev.udev_get_block_device(os.path.realpath(path)[4:]) + new_info = udev.get_block_device(os.path.realpath(path)[4:]) if new_info: self.addUdevDevice(new_info) if self.getDeviceByName(dev_name) is None: @@ -891,7 +891,7 @@ class DeviceTree(object):
if device is None: try: - uuid = udev.udev_device_get_md_uuid(info) + uuid = udev.device_get_md_uuid(info) except KeyError: log.warning("failed to obtain uuid for mdraid device") else: @@ -902,7 +902,7 @@ class DeviceTree(object): # the tree, this device should be as well if device is None: if name is None: - name = udev.udev_device_get_name(info) + name = udev.device_get_name(info) path = "/dev/" + name else: path = "/dev/md/" + name @@ -916,9 +916,9 @@ class DeviceTree(object): return device
def addUdevPartitionDevice(self, info, disk=None): - name = udev.udev_device_get_name(info) + name = udev.device_get_name(info) log_method_call(self, name=name) - sysfs_path = udev.udev_device_get_sysfs_path(info) + sysfs_path = udev.device_get_sysfs_path(info)
if name.startswith("md"): name = mdraid.name_from_md_node(name) @@ -936,7 +936,7 @@ class DeviceTree(object):
if disk is None: # create a device instance for the disk - new_info = udev.udev_get_block_device(os.path.dirname(sysfs_path)) + new_info = udev.get_block_device(os.path.dirname(sysfs_path)) if new_info: self.addUdevDevice(new_info) disk = self.getDeviceByName(disk_name) @@ -966,8 +966,8 @@ class DeviceTree(object): device = None try: device = PartitionDevice(name, sysfsPath=sysfs_path, - major=udev.udev_device_get_major(info), - minor=udev.udev_device_get_minor(info), + major=udev.device_get_major(info), + minor=udev.device_get_minor(info), exists=True, parents=[disk]) except DeviceError as e: # corner case sometime the kernel accepts a partition table @@ -982,25 +982,25 @@ class DeviceTree(object): return device
def addUdevDiskDevice(self, info): - name = udev.udev_device_get_name(info) + name = udev.device_get_name(info) log_method_call(self, name=name) - sysfs_path = udev.udev_device_get_sysfs_path(info) - serial = udev.udev_device_get_serial(info) - bus = udev.udev_device_get_bus(info) + sysfs_path = udev.device_get_sysfs_path(info) + serial = udev.device_get_serial(info) + bus = udev.device_get_bus(info)
# udev doesn't always provide a vendor. - vendor = udev.udev_device_get_vendor(info) + vendor = udev.device_get_vendor(info) if not vendor: vendor = ""
kwargs = { "serial": serial, "vendor": vendor, "bus": bus } - if udev.udev_device_is_iscsi(info): + if udev.device_is_iscsi(info): diskType = iScsiDiskDevice - initiator = udev.udev_device_get_iscsi_initiator(info) - target = udev.udev_device_get_iscsi_name(info) - address = udev.udev_device_get_iscsi_address(info) - port = udev.udev_device_get_iscsi_port(info) - nic = udev.udev_device_get_iscsi_nic(info) + initiator = udev.device_get_iscsi_initiator(info) + target = udev.device_get_iscsi_name(info) + address = udev.device_get_iscsi_address(info) + port = udev.device_get_iscsi_port(info) + nic = udev.device_get_iscsi_nic(info) kwargs["initiator"] = initiator if initiator == self.iscsi.initiator: node = self.iscsi.getNode(target, address, port, nic) @@ -1016,21 +1016,21 @@ class DeviceTree(object): kwargs["fw_address"] = address kwargs["fw_port"] = port kwargs["fw_name"] = name - elif udev.udev_device_is_fcoe(info): + elif udev.device_is_fcoe(info): diskType = FcoeDiskDevice - kwargs["nic"] = udev.udev_device_get_fcoe_nic(info) - kwargs["identifier"] = udev.udev_device_get_fcoe_identifier(info) + kwargs["nic"] = udev.device_get_fcoe_nic(info) + kwargs["identifier"] = udev.device_get_fcoe_identifier(info) log.info("%s is an fcoe disk", name) - elif udev.udev_device_get_md_container(info): - name = udev.udev_device_get_md_name(info) + elif udev.device_get_md_container(info): + name = udev.device_get_md_name(info) diskType = MDRaidArrayDevice - parentPath = udev.udev_device_get_md_container(info) + parentPath = udev.device_get_md_container(info) parentName = devicePathToName(parentPath) container = self.getDeviceByName(parentName) if not container: parentSysName = mdraid.md_node_from_name(parentName) container_sysfs = "/class/block/" + parentSysName - container_info = udev.udev_get_block_device(container_sysfs) + container_info = udev.get_block_device(container_sysfs) if not container_info: log.error("failed to find md container %s at %s", parentName, container_sysfs) @@ -1043,27 +1043,27 @@ class DeviceTree(object): return
kwargs["parents"] = [container] - kwargs["level"] = udev.udev_device_get_md_level(info) - kwargs["memberDevices"] = int(udev.udev_device_get_md_devices(info)) - kwargs["uuid"] = udev.udev_device_get_md_uuid(info) + kwargs["level"] = udev.device_get_md_level(info) + kwargs["memberDevices"] = int(udev.device_get_md_devices(info)) + kwargs["uuid"] = udev.device_get_md_uuid(info) kwargs["exists"] = True del kwargs["serial"] del kwargs["vendor"] del kwargs["bus"] - elif udev.udev_device_is_dasd(info): + elif udev.device_is_dasd(info): diskType = DASDDevice - kwargs["busid"] = udev.udev_device_get_dasd_bus_id(info) + kwargs["busid"] = udev.device_get_dasd_bus_id(info) kwargs["opts"] = {}
for attr in ['readonly', 'use_diag', 'erplog', 'failfast']: - kwargs["opts"][attr] = udev.udev_device_get_dasd_flag(info, attr) + kwargs["opts"][attr] = udev.device_get_dasd_flag(info, attr)
log.info("%s is a dasd device", name) - elif udev.udev_device_is_zfcp(info): + elif udev.device_is_zfcp(info): diskType = ZFCPDiskDevice
for attr in ['hba_id', 'wwpn', 'fcp_lun']: - kwargs[attr] = udev.udev_device_get_zfcp_attribute(info, attr=attr) + kwargs[attr] = udev.device_get_zfcp_attribute(info, attr=attr)
log.info("%s is a zfcp device", name) else: @@ -1071,8 +1071,8 @@ class DeviceTree(object): log.info("%s is a disk", name)
device = diskType(name, - major=udev.udev_device_get_major(info), - minor=udev.udev_device_get_minor(info), + major=udev.device_get_major(info), + minor=udev.device_get_minor(info), sysfsPath=sysfs_path, **kwargs)
if mpath.is_multipath_member(device.path): @@ -1089,19 +1089,19 @@ class DeviceTree(object): # XXX should this be RemovableDevice instead? # # Looks like if it has ID_INSTANCE=0:1 we can ignore it. - device = OpticalDevice(udev.udev_device_get_name(info), - major=udev.udev_device_get_major(info), - minor=udev.udev_device_get_minor(info), - sysfsPath=udev.udev_device_get_sysfs_path(info), - vendor=udev.udev_device_get_vendor(info), - model=udev.udev_device_get_model(info)) + device = OpticalDevice(udev.device_get_name(info), + major=udev.device_get_major(info), + minor=udev.device_get_minor(info), + sysfsPath=udev.device_get_sysfs_path(info), + vendor=udev.device_get_vendor(info), + model=udev.device_get_model(info)) self._addDevice(device) return device
def addUdevLoopDevice(self, info): - name = udev.udev_device_get_name(info) + name = udev.device_get_name(info) log_method_call(self, name=name) - sysfs_path = udev.udev_device_get_sysfs_path(info) + sysfs_path = udev.device_get_sysfs_path(info) sys_file = "/sys/%s/loop/backing_file" % sysfs_path backing_file = open(sys_file).read().strip() file_device = self.getDeviceByName(backing_file) @@ -1121,10 +1121,10 @@ class DeviceTree(object): return device
def addUdevDevice(self, info): - name = udev.udev_device_get_name(info) + name = udev.device_get_name(info) log_method_call(self, name=name, info=pprint.pformat(info)) - uuid = udev.udev_device_get_uuid(info) - sysfs_path = udev.udev_device_get_sysfs_path(info) + uuid = udev.device_get_uuid(info) + sysfs_path = udev.device_get_sysfs_path(info)
# make sure this device was not scheduled for removal and also has not # been hidden @@ -1153,9 +1153,9 @@ class DeviceTree(object):
log.info("scanning %s (%s)...", name, sysfs_path) device = self.getDeviceByName(name) - if device is None and udev.udev_device_is_md(info): + if device is None and udev.device_is_md(info): device = self.getDeviceByName( - udev.udev_device_get_md_name(info), + udev.device_get_md_name(info), incomplete=flags.allow_degraded_mdraid) if device and not isinstance(device, MDRaidArrayDevice): # make sure any device we found is an md device @@ -1179,35 +1179,35 @@ class DeviceTree(object): # we successfully looked up the device. skip to format handling. # first, grab the parted.Device while it's active _unused = device.partedDevice - elif udev.udev_device_is_loop(info): + elif udev.device_is_loop(info): log.info("%s is a loop device", name) device = self.addUdevLoopDevice(info) - elif udev.udev_device_is_dm_mpath(info) and \ - not udev.udev_device_is_dm_partition(info): + elif udev.device_is_dm_mpath(info) and \ + not udev.device_is_dm_partition(info): log.info("%s is a multipath device", name) device = self.addUdevMultiPathDevice(info) - elif udev.udev_device_is_dm_lvm(info): + elif udev.device_is_dm_lvm(info): log.info("%s is an lvm logical volume", name) device = self.addUdevLVDevice(info) - elif udev.udev_device_is_dm(info): + elif udev.device_is_dm(info): log.info("%s is a device-mapper device", name) device = self.addUdevDMDevice(info) - elif udev.udev_device_is_md(info) and not udev.udev_device_get_md_container(info): + elif udev.device_is_md(info) and not udev.device_get_md_container(info): log.info("%s is an md device", name) device = self.addUdevMDDevice(info) - elif udev.udev_device_is_cdrom(info): + elif udev.device_is_cdrom(info): log.info("%s is a cdrom", name) device = self.addUdevOpticalDevice(info) - elif udev.udev_device_is_biosraid_member(info) and udev.udev_device_is_disk(info): + elif udev.device_is_biosraid_member(info) and udev.device_is_disk(info): log.info("%s is part of a biosraid", name) device = DiskDevice(name, - major=udev.udev_device_get_major(info), - minor=udev.udev_device_get_minor(info), + major=udev.device_get_major(info), + minor=udev.device_get_minor(info), sysfsPath=sysfs_path, exists=True) self._addDevice(device) - elif udev.udev_device_is_disk(info): + elif udev.device_is_disk(info): device = self.addUdevDiskDevice(info) - elif udev.udev_device_is_partition(info): + elif udev.device_is_partition(info): log.info("%s is a partition", name) device = self.addUdevPartitionDevice(info) else: @@ -1243,10 +1243,10 @@ class DeviceTree(object): # now handle the device's formatting self.handleUdevDeviceFormat(info, device) device.originalFormat = copy.copy(device.format) - device.deviceLinks = udev.udev_device_get_symlinks(info) + device.deviceLinks = udev.device_get_symlinks(info)
def handleUdevDiskLabelFormat(self, info, device): - disklabel_type = udev.udev_device_get_disklabel_type(info) + disklabel_type = udev.device_get_disklabel_type(info) log_method_call(self, device=device.name, label_type=disklabel_type) # if there is no disklabel on the device if disklabel_type is None: @@ -1345,7 +1345,7 @@ class DeviceTree(object): """ Handle setup of the LV's in the vg_device. """ vg_name = vg_device.name lv_info = dict((k, v) for (k, v) in self.lvInfo.iteritems() - if udev.udev_device_get_vg_name(v) == vg_name) + if udev.device_get_vg_name(v) == vg_name)
self.names.extend(n for n in lv_info.keys() if n not in self.names)
@@ -1382,11 +1382,11 @@ class DeviceTree(object):
def addLV(lv): """ Instantiate and add an LV based on data from the VG. """ - lv_name = udev.udev_device_get_lv_name(lv) - lv_uuid = udev.udev_device_get_lv_uuid(lv) - lv_attr = udev.udev_device_get_lv_attr(lv) - lv_size = udev.udev_device_get_lv_size(lv) - lv_type = udev.udev_device_get_lv_type(lv) + lv_name = udev.device_get_lv_name(lv) + lv_uuid = udev.device_get_lv_uuid(lv) + lv_attr = udev.device_get_lv_attr(lv) + lv_size = udev.device_get_lv_size(lv) + lv_type = udev.device_get_lv_type(lv)
lv_class = LVMLogicalVolumeDevice lv_parents = [vg_device] @@ -1490,7 +1490,7 @@ class DeviceTree(object):
if lv_device.status: lv_device.updateSysfsPath() - lv_info = udev.udev_get_block_device(lv_device.sysfsPath) + lv_info = udev.get_block_device(lv_device.sysfsPath) if not lv_info: log.error("failed to get udev data for lv %s", lv_device.name) return @@ -1522,8 +1522,8 @@ class DeviceTree(object): log_method_call(self, name=device.name, type=device.format.type) # lookup/create the VG and LVs try: - vg_name = udev.udev_device_get_vg_name(info) - vg_uuid = udev.udev_device_get_vg_uuid(info) + vg_name = udev.device_get_vg_name(info) + vg_uuid = udev.device_get_vg_uuid(info) except KeyError: # no vg name means no vg -- we're done with this pv return @@ -1537,12 +1537,12 @@ class DeviceTree(object): vg_device.parents.append(device) else: try: - vg_size = udev.udev_device_get_vg_size(info) - vg_free = udev.udev_device_get_vg_free(info) - pe_size = udev.udev_device_get_vg_extent_size(info) - pe_count = udev.udev_device_get_vg_extent_count(info) - pe_free = udev.udev_device_get_vg_free_extents(info) - pv_count = udev.udev_device_get_vg_pv_count(info) + vg_size = udev.device_get_vg_size(info) + vg_free = udev.device_get_vg_free(info) + pe_size = udev.device_get_vg_extent_size(info) + pe_count = udev.device_get_vg_extent_count(info) + pe_free = udev.device_get_vg_free_extents(info) + pv_count = udev.device_get_vg_pv_count(info) except (KeyError, ValueError) as e: log.warning("invalid data for %s: %s", device.name, e) return @@ -1571,9 +1571,9 @@ class DeviceTree(object): # create the array with just this one member try: # level is reported as, eg: "raid1" - md_level = udev.udev_device_get_md_level(info) - md_devices = int(udev.udev_device_get_md_devices(info)) - md_uuid = udev.udev_device_get_md_uuid(info) + md_level = udev.device_get_md_level(info) + md_devices = int(udev.device_get_md_devices(info)) + md_uuid = udev.device_get_md_uuid(info) except (KeyError, ValueError) as e: log.warning("invalid data for %s: %s", device.name, e) return @@ -1583,13 +1583,13 @@ class DeviceTree(object):
# check the list of devices udev knows about to see if the array # this device belongs to is already active - for dev in udev.udev_get_block_devices(): - if not udev.udev_device_is_md(dev): + for dev in udev.get_block_devices(): + if not udev.device_is_md(dev): continue
try: - dev_uuid = udev.udev_device_get_md_uuid(dev) - dev_level = udev.udev_device_get_md_level(dev) + dev_uuid = udev.device_get_md_uuid(dev) + dev_level = udev.device_get_md_level(dev) except KeyError: continue
@@ -1597,12 +1597,12 @@ class DeviceTree(object): continue
if dev_uuid == md_uuid and dev_level == md_level: - md_name = udev.udev_device_get_md_name(dev) + md_name = udev.device_get_md_name(dev) md_metadata = dev.get("MD_METADATA") if not md_name: # containers don't typically have names and they also # don't have a symlink in /dev/md - md_name = udev.udev_device_get_name(dev) + md_name = udev.device_get_name(dev) if md_level != "container" and \ re.match(r'md\d+$', md_name): # md0 -> 0 @@ -1649,10 +1649,10 @@ class DeviceTree(object): return
log_method_call(self, name=device.name, type=device.format.type) - name = udev.udev_device_get_name(info) - uuid = udev.udev_device_get_uuid(info) - major = udev.udev_device_get_major(info) - minor = udev.udev_device_get_minor(info) + name = udev.device_get_name(info) + uuid = udev.device_get_uuid(info) + major = udev.device_get_major(info) + minor = udev.device_get_minor(info)
def _all_ignored(rss): retval = True @@ -1685,13 +1685,13 @@ class DeviceTree(object): self._addDevice(dm_array)
# Wait for udev to scan the just created nodes, to avoid a race - # with the udev.udev_get_block_device() call below. - udev.udev_settle() + # with the udev.get_block_device() call below. + udev.settle()
# Get the DMRaidArrayDevice a DiskLabel format *now*, in case # its partitions get scanned before it does. dm_array.updateSysfsPath() - dm_array_info = udev.udev_get_block_device(dm_array.sysfsPath) + dm_array_info = udev.get_block_device(dm_array.sysfsPath) self.handleUdevDiskLabelFormat(dm_array_info, dm_array)
# Use the rs's object on the device. @@ -1704,7 +1704,7 @@ class DeviceTree(object):
def handleBTRFSFormat(self, info, device): log_method_call(self, name=device.name) - uuid = udev.udev_device_get_uuid(info) + uuid = udev.device_get_uuid(info)
btrfs_dev = None for d in self.devices: @@ -1716,7 +1716,7 @@ class DeviceTree(object): log.info("found btrfs volume %s", btrfs_dev.name) btrfs_dev.parents.append(device) else: - label = udev.udev_device_get_label(info) + label = udev.device_get_label(info) log.info("creating btrfs volume btrfs.%s", label) btrfs_dev = BTRFSVolumeDevice(label, parents=[device], uuid=uuid, exists=True) @@ -1770,17 +1770,17 @@ class DeviceTree(object): log.debug("no media present for device %s", device.name) return
- name = udev.udev_device_get_name(info) - uuid = udev.udev_device_get_uuid(info) - label = udev.udev_device_get_label(info) - format_type = udev.udev_device_get_format(info) - serial = udev.udev_device_get_serial(info) + name = udev.device_get_name(info) + uuid = udev.device_get_uuid(info) + label = udev.device_get_label(info) + format_type = udev.device_get_format(info) + serial = udev.device_get_serial(info)
# Now, if the device is a disk, see if there is a usable disklabel. # If not, see if the user would like to create one. # XXX ignore disklabels on multipath or biosraid member disks - if not udev.udev_device_is_biosraid_member(info) and \ - not udev.udev_device_is_multipath_member(info) and \ + if not udev.device_is_biosraid_member(info) and \ + not udev.device_is_multipath_member(info) and \ format_type != "iso9660": self.handleUdevDiskLabelFormat(info, device) if device.partitioned or self.isIgnored(info) or \ @@ -1815,24 +1815,24 @@ class DeviceTree(object):
# mdraid try: - kwargs["mdUuid"] = udev.udev_device_get_md_uuid(info) + kwargs["mdUuid"] = udev.device_get_md_uuid(info) except KeyError: log.warning("mdraid member %s has no md uuid", name) - kwargs["biosraid"] = udev.udev_device_is_biosraid_member(info) + kwargs["biosraid"] = udev.device_is_biosraid_member(info) elif format_type == "LVM2_member": # lvm info.update(self.pvInfo.get(device.path, {}))
try: - kwargs["vgName"] = udev.udev_device_get_vg_name(info) + kwargs["vgName"] = udev.device_get_vg_name(info) except KeyError: log.warning("PV %s has no vg_name", name) try: - kwargs["vgUuid"] = udev.udev_device_get_vg_uuid(info) + kwargs["vgUuid"] = udev.device_get_vg_uuid(info) except KeyError: log.warning("PV %s has no vg_uuid", name) try: - kwargs["peStart"] = udev.udev_device_get_pv_pe_start(info) + kwargs["peStart"] = udev.device_get_pv_pe_start(info) except KeyError: log.warning("PV %s has no pe_start", name) elif format_type == "vfat": @@ -1891,8 +1891,8 @@ class DeviceTree(object): except (ValueError, IOError) as e: log.warning("failed to notify kernel of change: %s", e)
- udev.udev_settle() - info = udev.udev_get_device(device.sysfsPath) + udev.settle() + info = udev.get_device(device.sysfsPath)
self.handleUdevDeviceFormat(info, device)
@@ -2030,7 +2030,7 @@ class DeviceTree(object): self._addDevice(filedev) self._addDevice(loopdev) self._addDevice(dmdev) - info = udev.udev_get_block_device(dmdev.sysfsPath) + info = udev.get_block_device(dmdev.sysfsPath) self.addUdevDevice(info)
def backupConfigs(self, restore=False): @@ -2104,7 +2104,7 @@ class DeviceTree(object): self.ignoredDisks, self.exclusiveDisks)
# this has proven useful when populating after opening a LUKS device - udev.udev_settle() + udev.settle()
self.dropLVMCache()
@@ -2119,7 +2119,7 @@ class DeviceTree(object):
# resolve the protected device specs to device names for spec in self.protectedDevSpecs: - name = udev.udev_resolve_devspec(spec) + name = udev.resolve_devspec(spec) log.debug("protected device spec %s resolved to %s", spec, name) if name: self.protectedDevNames.append(name) @@ -2144,7 +2144,7 @@ class DeviceTree(object): # blocks or since previous iterations. while True: devices = [] - new_devices = udev.udev_get_block_devices() + new_devices = udev.get_block_devices()
for new_device in new_devices: if not old_devices.has_key(new_device['name']): diff --git a/blivet/fcoe.py b/blivet/fcoe.py index 5e8a3a6..102be6a 100644 --- a/blivet/fcoe.py +++ b/blivet/fcoe.py @@ -18,8 +18,8 @@ #
import os +from . import udev from . import util -from .udev import udev_settle #from pyanaconda import isys import logging import time @@ -65,7 +65,7 @@ class fcoe(object): def _stabilize(self): # I have no clue how long we need to wait, this ought to do the trick time.sleep(10) - udev_settle() + udev.settle()
def _startEDD(self): try: diff --git a/blivet/formats/disklabel.py b/blivet/formats/disklabel.py index 9dc0b5d..71c9a25 100644 --- a/blivet/formats/disklabel.py +++ b/blivet/formats/disklabel.py @@ -27,9 +27,9 @@ import parted import _ped from ..errors import DeviceFormatError, DiskLabelCommitError, InvalidDiskLabelError from .. import arch +from .. import udev from .. import util from ..flags import flags -from ..udev import udev_settle from ..i18n import _, N_ from . import DeviceFormat, register_device_format from ..size import Size @@ -272,7 +272,7 @@ class DiskLabel(DeviceFormat): raise DiskLabelCommitError(msg) else: self.updateOrigPartedDisk() - udev_settle() + udev.settle()
def commitToDisk(self): """ Commit the current partition table to disk. """ diff --git a/blivet/formats/fs.py b/blivet/formats/fs.py index 9bdde4c..988b428 100644 --- a/blivet/formats/fs.py +++ b/blivet/formats/fs.py @@ -37,7 +37,7 @@ from ..storage_log import log_exception_info, log_method_call from .. import arch from ..size import Size from ..i18n import _, N_ -from ..udev import udev_settle +from .. import udev
import logging log = logging.getLogger("blivet") @@ -609,7 +609,7 @@ class FS(DeviceFormat): if not os.path.exists(self._mountpoint): raise FSError("mountpoint does not exist")
- udev_settle() + udev.settle() rc = util.umount(self._mountpoint) if rc: # try and catch whatever is causing the umount problem diff --git a/blivet/iscsi.py b/blivet/iscsi.py index 0e44b35..51316ca 100644 --- a/blivet/iscsi.py +++ b/blivet/iscsi.py @@ -18,7 +18,7 @@ # along with this program. If not, see http://www.gnu.org/licenses/. #
-from .udev import udev_settle +from . import udev from . import util from .flags import flags from .i18n import _ @@ -172,7 +172,7 @@ class iscsi(object): # It is possible when we get here the events for the new devices # are not send yet, so sleep to make sure the events are fired time.sleep(2) - udev_settle() + udev.settle()
def create_interfaces(self, ifaces): for iface in ifaces: diff --git a/blivet/udev.py b/blivet/udev.py index 09001e4..98195b6 100644 --- a/blivet/udev.py +++ b/blivet/udev.py @@ -33,11 +33,11 @@ global_udev = pyudev.Udev() import logging log = logging.getLogger("blivet")
-def udev_enumerate_devices(deviceClass="block"): +def enumerate_devices(deviceClass="block"): devices = global_udev.enumerate_devices(subsystem=deviceClass) return [path[4:] for path in devices]
-def udev_get_device(sysfs_path): +def get_device(sysfs_path): if not os.path.exists("/sys%s" % sysfs_path): log.debug("%s does not exist", sysfs_path) return None @@ -51,20 +51,20 @@ def udev_get_device(sysfs_path): dev["sysfs_path"] = sysfs_path
# now add in the contents of the uevent file since they're handy - dev = udev_parse_uevent_file(dev) + dev = parse_uevent_file(dev)
return dev
-def udev_get_devices(deviceClass="block"): - udev_settle() +def get_devices(deviceClass="block"): + settle() entries = [] - for path in udev_enumerate_devices(deviceClass): - entry = udev_get_device(path) + for path in enumerate_devices(deviceClass): + entry = get_device(path) if entry: entries.append(entry) return entries
-def udev_parse_uevent_file(dev): +def parse_uevent_file(dev): path = os.path.normpath("/sys/%s/uevent" % dev['sysfs_path']) if not os.access(path, os.R_OK): return dev @@ -79,13 +79,13 @@ def udev_parse_uevent_file(dev):
return dev
-def udev_settle(): +def settle(): # wait maximal 300 seconds for udev to be done running blkid, lvm, # mdadm etc. This large timeout is needed when running on machines with # lots of disks, or with slow disks util.run_program(["udevadm", "settle", "--timeout=300"])
-def udev_trigger(subsystem=None, action="add", name=None): +def trigger(subsystem=None, action="add", name=None): argv = ["trigger", "--action=%s" % action] if subsystem: argv.append("--subsystem-match=%s" % subsystem) @@ -93,9 +93,9 @@ def udev_trigger(subsystem=None, action="add", name=None): argv.append("--sysname-match=%s" % name)
util.run_program(["udevadm"] + argv) - udev_settle() + settle()
-def udev_resolve_devspec(devspec): +def resolve_devspec(devspec): if not devspec: return None
@@ -103,16 +103,16 @@ def udev_resolve_devspec(devspec): from . import devices
ret = None - for dev in udev_get_block_devices(): + for dev in get_block_devices(): if devspec.startswith("LABEL="): - if udev_device_get_label(dev) == devspec[6:]: + if device_get_label(dev) == devspec[6:]: ret = dev break elif devspec.startswith("UUID="): - if udev_device_get_uuid(dev) == devspec[5:]: + if device_get_uuid(dev) == devspec[5:]: ret = dev break - elif udev_device_get_name(dev) == devices.devicePathToName(devspec): + elif device_get_name(dev) == devices.devicePathToName(devspec): ret = dev break else: @@ -126,17 +126,17 @@ def udev_resolve_devspec(devspec): break
if ret: - return udev_device_get_name(ret) + return device_get_name(ret)
-def udev_resolve_glob(glob): +def resolve_glob(glob): import fnmatch ret = []
if not glob: return ret
- for dev in udev_get_block_devices(): - name = udev_device_get_name(dev) + for dev in get_block_devices(): + name = device_get_name(dev)
if fnmatch.fnmatch(name, glob): ret.append(name) @@ -147,11 +147,11 @@ def udev_resolve_glob(glob):
return ret
-def udev_get_block_devices(): - udev_settle() +def get_block_devices(): + settle() entries = [] - for path in udev_enumerate_block_devices(): - entry = udev_get_block_device(path) + for path in enumerate_block_devices(): + entry = get_block_device(path) if entry: if entry["name"].startswith("md"): # mdraid is really braindead, when a device is stopped @@ -180,12 +180,12 @@ def __is_blacklisted_blockdev(dev_name):
return False
-def udev_enumerate_block_devices(): +def enumerate_block_devices(): return filter(lambda d: not __is_blacklisted_blockdev(os.path.basename(d)), - udev_enumerate_devices(deviceClass="block")) + enumerate_devices(deviceClass="block"))
-def udev_get_block_device(sysfs_path): - dev = udev_get_device(sysfs_path) +def get_block_device(sysfs_path): + dev = get_device(sysfs_path) if not dev or not dev.has_key("name"): return None else: @@ -194,7 +194,7 @@ def udev_get_block_device(sysfs_path):
# These are functions for retrieving specific pieces of information from # udev database entries. -def udev_device_get_name(udev_info): +def device_get_name(udev_info): """ Return the best name for a device based on the udev db data. """ if "DM_NAME" in udev_info: name = udev_info["DM_NAME"] @@ -203,11 +203,11 @@ def udev_device_get_name(udev_info):
return name
-def udev_device_get_format(udev_info): +def device_get_format(udev_info): """ Return a device's format type as reported by udev. """ return udev_info.get("ID_FS_TYPE")
-def udev_device_get_uuid(udev_info): +def device_get_uuid(udev_info): """ Get the UUID from the device's format as reported by udev. """ md_uuid = udev_info.get("MD_UUID", '') uuid = udev_info.get("ID_FS_UUID", '') @@ -216,30 +216,30 @@ def udev_device_get_uuid(udev_info): re.sub(r'\W', '', md_uuid) != re.sub(r'\W', '', uuid): return udev_info.get("ID_FS_UUID")
-def udev_device_get_label(udev_info): +def device_get_label(udev_info): """ Get the label from the device's format as reported by udev. """ return udev_info.get("ID_FS_LABEL")
-def udev_device_is_dm(info): +def device_is_dm(info): """ Return True if the device is a device-mapper device. """ return info.has_key("DM_NAME")
-def udev_device_is_md(info): +def device_is_md(info): """ Return True if the device is a mdraid array device. """ # Don't identify partitions on mdraid arrays as raid arrays - if udev_device_is_partition(info): + if device_is_partition(info): return False
# The udev information keeps shifting around. Only md arrays have a # /sys/class/block/<name>/md/ subdirectory. - md_dir = "/sys" + udev_device_get_sysfs_path(info) + "/md" + md_dir = "/sys" + device_get_sysfs_path(info) + "/md" return os.path.exists(md_dir)
-def udev_device_is_cciss(info): +def device_is_cciss(info): """ Return True if the device is a CCISS device. """ - return udev_device_get_name(info).startswith("cciss") + return device_get_name(info).startswith("cciss")
-def udev_device_is_dasd(info): +def device_is_dasd(info): """ Return True if the device is a dasd device. """ devname = info.get("DEVNAME") if devname: @@ -247,7 +247,7 @@ def udev_device_is_dasd(info): else: return False
-def udev_device_is_zfcp(info): +def device_is_zfcp(info): """ Return True if the device is a zfcp device. """ if info.get("DEVTYPE") != "disk": return False @@ -274,10 +274,10 @@ def udev_device_is_zfcp(info):
return False
-def udev_device_get_zfcp_attribute(info, attr=None): +def device_get_zfcp_attribute(info, attr=None): """ Return the value of the specified attribute of the zfcp device. """ if not attr: - log.debug("udev_device_get_zfcp_attribute() called with attr=None") + log.debug("device_get_zfcp_attribute() called with attr=None") return None
attribute = "/sys%s/device/%s" % (info.get("sysfs_path"), attr,) @@ -289,11 +289,11 @@ def udev_device_get_zfcp_attribute(info, attr=None):
return open(attribute, "r").read().strip()
-def udev_device_get_dasd_bus_id(info): +def device_get_dasd_bus_id(info): """ Return the CCW bus ID of the dasd device. """ return info.get("sysfs_path").split("/")[-3]
-def udev_device_get_dasd_flag(info, flag=None): +def device_get_dasd_flag(info, flag=None): """ Return the specified flag for the dasd device. """ if flag is None: return None @@ -304,137 +304,137 @@ def udev_device_get_dasd_flag(info, flag=None):
return open(path, 'r').read().strip()
-def udev_device_is_cdrom(info): +def device_is_cdrom(info): """ Return True if the device is an optical drive. """ # FIXME: how can we differentiate USB drives from CD-ROM drives? # -- USB drives also generate a sdX device. return info.get("ID_CDROM") == "1"
-def udev_device_is_disk(info): +def device_is_disk(info): """ Return True is the device is a disk. """ - if udev_device_is_cdrom(info): + if device_is_cdrom(info): return False has_range = os.path.exists("/sys/%s/range" % info['sysfs_path']) return info.get("DEVTYPE") == "disk" or has_range
-def udev_device_is_partition(info): +def device_is_partition(info): has_start = os.path.exists("/sys/%s/start" % info['sysfs_path']) return info.get("DEVTYPE") == "partition" or has_start
-def udev_device_is_loop(info): +def device_is_loop(info): """ Return True if the device is a configured loop device. """ - return (udev_device_get_name(info).startswith("loop") and + return (device_get_name(info).startswith("loop") and os.path.isdir("/sys/%s/loop" % info['sysfs_path']))
-def udev_device_get_serial(udev_info): +def device_get_serial(udev_info): """ Get the serial number/UUID from the device as reported by udev. """ return udev_info.get("ID_SERIAL_RAW", udev_info.get("ID_SERIAL_SHORT", udev_info.get("ID_SERIAL")))
-def udev_device_get_wwid(udev_info): +def device_get_wwid(udev_info): """ The WWID of a device is typically just its serial number, but with colons in the name to make it more readable. """ - serial = udev_device_get_serial(udev_info) + serial = device_get_serial(udev_info) return util.insert_colons(serial) if serial else ""
-def udev_device_get_vendor(udev_info): +def device_get_vendor(udev_info): """ Get the vendor of the device as reported by udev. """ return udev_info.get("ID_VENDOR_FROM_DATABASE", udev_info.get("ID_VENDOR"))
-def udev_device_get_model(udev_info): +def device_get_model(udev_info): """ Get the model of the device as reported by udev. """ return udev_info.get("ID_MODEL_FROM_DATABASE", udev_info.get("ID_MODEL"))
-def udev_device_get_bus(udev_info): +def device_get_bus(udev_info): """ Get the bus a device is connected to the system by. """ return udev_info.get("ID_BUS", "").upper()
-def udev_device_get_path(info): +def device_get_path(info): return info["ID_PATH"]
-def udev_device_get_symlinks(info): +def device_get_symlinks(info): return info.get("symlinks", [])
-def udev_device_get_by_path(info): - for link in udev_device_get_symlinks(info): +def device_get_by_path(info): + for link in device_get_symlinks(info): if link.startswith('/dev/disk/by-path/'): return link
- return udev_device_get_name(info) + return device_get_name(info)
-def udev_device_get_sysfs_path(info): +def device_get_sysfs_path(info): return info['sysfs_path']
-def udev_device_get_major(info): +def device_get_major(info): return int(info["MAJOR"])
-def udev_device_get_minor(info): +def device_get_minor(info): return int(info["MINOR"])
-def udev_device_get_md_level(info): +def device_get_md_level(info): return info.get("MD_LEVEL")
-def udev_device_get_md_devices(info): +def device_get_md_devices(info): return int(info["MD_DEVICES"])
-def udev_device_get_md_uuid(info): +def device_get_md_uuid(info): return info["MD_UUID"]
-def udev_device_get_md_container(info): +def device_get_md_container(info): return info.get("MD_CONTAINER")
-def udev_device_get_md_name(info): +def device_get_md_name(info): return info.get("MD_DEVNAME")
-def udev_device_get_vg_name(info): +def device_get_vg_name(info): return info['LVM2_VG_NAME']
-def udev_device_get_lv_vg_name(info): +def device_get_lv_vg_name(info): return info['DM_VG_NAME']
-def udev_device_get_vg_uuid(info): +def device_get_vg_uuid(info): return info['LVM2_VG_UUID']
-def udev_device_get_vg_size(info): +def device_get_vg_size(info): # lvm's decmial precision is not configurable, so we tell it to use # KB. return Size("%s KiB" % info['LVM2_VG_SIZE'])
-def udev_device_get_vg_free(info): +def device_get_vg_free(info): # lvm's decmial precision is not configurable, so we tell it to use # KB. return Size("%s KiB" % info['LVM2_VG_FREE'])
-def udev_device_get_vg_extent_size(info): +def device_get_vg_extent_size(info): return Size("%s KiB" % info['LVM2_VG_EXTENT_SIZE'])
-def udev_device_get_vg_extent_count(info): +def device_get_vg_extent_count(info): return int(info['LVM2_VG_EXTENT_COUNT'])
-def udev_device_get_vg_free_extents(info): +def device_get_vg_free_extents(info): return int(info['LVM2_VG_FREE_COUNT'])
-def udev_device_get_vg_pv_count(info): +def device_get_vg_pv_count(info): return int(info['LVM2_PV_COUNT'])
-def udev_device_get_pv_pe_start(info): +def device_get_pv_pe_start(info): return Size("%s KiB" % info['LVM2_PE_START'])
-def udev_device_get_lv_name(info): +def device_get_lv_name(info): return info['LVM2_LV_NAME']
-def udev_device_get_lv_uuid(info): +def device_get_lv_uuid(info): return info['LVM2_LV_UUID']
-def udev_device_get_lv_size(info): +def device_get_lv_size(info): return Size("%s KiB" % info['LVM2_LV_SIZE'])
-def udev_device_get_lv_attr(info): +def device_get_lv_attr(info): return info['LVM2_LV_ATTR']
-def udev_device_get_lv_type(info): +def device_get_lv_type(info): return info['LVM2_SEGTYPE']
-def udev_device_dm_subsystem_match(info, subsystem): +def device_dm_subsystem_match(info, subsystem): """ Return True if the device matches a given device-mapper subsystem. """ uuid = info.get("DM_UUID", "") uuid_fields = uuid.split("-") @@ -449,17 +449,17 @@ def udev_device_dm_subsystem_match(info, subsystem):
return _subsystem.lower() == subsystem.lower()
-def udev_device_is_dm_lvm(info): +def device_is_dm_lvm(info): """ Return True if the device is an LVM logical volume. """ - return udev_device_dm_subsystem_match(info, "lvm") + return device_dm_subsystem_match(info, "lvm")
-def udev_device_is_dm_crypt(info): +def device_is_dm_crypt(info): """ Return True if the device is a mapped dm-crypt device. """ - return udev_device_dm_subsystem_match(info, "crypt") + return device_dm_subsystem_match(info, "crypt")
-def udev_device_is_dm_luks(info): +def device_is_dm_luks(info): """ Return True if the device is a mapped LUKS device. """ - is_crypt = udev_device_dm_subsystem_match(info, "crypt") + is_crypt = device_dm_subsystem_match(info, "crypt") try: _type = info.get("DM_UUID", "").split("-")[1].lower() except IndexError: @@ -467,25 +467,25 @@ def udev_device_is_dm_luks(info):
return is_crypt and _type.startswith("luks")
-def udev_device_is_dm_raid(info): +def device_is_dm_raid(info): """ Return True if the device is a dmraid array device. """ - return udev_device_dm_subsystem_match(info, "dmraid") + return device_dm_subsystem_match(info, "dmraid")
-def udev_device_is_dm_mpath(info): +def device_is_dm_mpath(info): """ Return True if the device is a multipath device. """ - return udev_device_dm_subsystem_match(info, "mpath") + return device_dm_subsystem_match(info, "mpath")
-def udev_device_is_dm_anaconda(info): +def device_is_dm_anaconda(info): """ Return True if the device is an anaconda disk image. """ - return udev_device_dm_subsystem_match(info, "anaconda") + return device_dm_subsystem_match(info, "anaconda")
-def udev_device_is_dm_livecd(info): +def device_is_dm_livecd(info): """ Return True if the device is a livecd OS image. """ - # return udev_device_dm_subsystem_match(info, "livecd") - return (udev_device_is_dm(info) and - udev_device_get_name(info).startswith("live")) + # return device_dm_subsystem_match(info, "livecd") + return (device_is_dm(info) and + device_get_name(info).startswith("live"))
-def udev_device_is_biosraid_member(info): +def device_is_biosraid_member(info): # Note that this function does *not* identify raid sets. # Tests to see if device is part of a dmraid set. # dmraid and mdraid have the same ID_FS_USAGE string, ID_FS_TYPE has a @@ -502,26 +502,26 @@ def udev_device_is_biosraid_member(info):
return False
-def udev_device_get_dm_partition_disk(info): - return re.sub(r'p?\d*$', '', udev_device_get_name(info)) +def device_get_dm_partition_disk(info): + return re.sub(r'p?\d*$', '', device_get_name(info))
-def udev_device_is_dm_partition(info): - return (udev_device_is_dm(info) and +def device_is_dm_partition(info): + return (device_is_dm(info) and info.get("DM_UUID", "").split("-")[0].startswith("part"))
-def udev_device_is_multipath_member(info): +def device_is_multipath_member(info): """ Return True if the device is part of a multipath. """ return info.get("ID_FS_TYPE") == "multipath_member"
-def udev_device_get_multipath_name(info): +def device_get_multipath_name(info): """ Return the name of the multipath that the device is a member of. """ - if udev_device_is_multipath_member(info): + if device_is_multipath_member(info): return info['ID_MPATH_NAME'] return None
-def udev_device_get_disklabel_type(info): +def device_get_disklabel_type(info): """ Return the type of disklabel on the device or None. """ - if udev_device_is_partition(info) or udev_device_is_dm_partition(info): + if device_is_partition(info) or device_is_dm_partition(info): # For partitions, ID_PART_TABLE_TYPE is the disklabel type for the # partition's disk. It does not mean the partition contains a disklabel. return None @@ -536,10 +536,10 @@ def udev_device_get_disklabel_type(info): # Note that in the case of IPV6 iscsi_address itself can contain : # too, but iscsi_port never contains :
-def udev_device_is_sw_iscsi(info): +def device_is_sw_iscsi(info): # software iscsi try: - path_components = udev_device_get_path(info).split("-") + path_components = device_get_path(info).split("-")
if info["ID_BUS"] == "scsi" and len(path_components) >= 6 and \ path_components[0] == "ip" and path_components[2] == "iscsi": @@ -549,10 +549,10 @@ def udev_device_is_sw_iscsi(info):
return False
-def udev_device_is_partoff_iscsi(info): +def device_is_partoff_iscsi(info): # partial offload iscsi try: - path_components = udev_device_get_path(info).split("-") + path_components = device_get_path(info).split("-")
if info["ID_BUS"] == "scsi" and len(path_components) >= 8 and \ path_components[2] == "ip" and path_components[4] == "iscsi": @@ -562,41 +562,41 @@ def udev_device_is_partoff_iscsi(info):
return False
-def udev_device_is_iscsi(info): - return udev_device_is_sw_iscsi(info) or udev_device_is_partoff_iscsi(info) +def device_is_iscsi(info): + return device_is_sw_iscsi(info) or device_is_partoff_iscsi(info)
-def udev_device_get_iscsi_name(info): +def device_get_iscsi_name(info): name_field = 3 - if udev_device_is_partoff_iscsi(info): + if device_is_partoff_iscsi(info): name_field = 5
- path_components = udev_device_get_path(info).split("-") + path_components = device_get_path(info).split("-")
# Tricky, the name itself contains atleast 1 - char return "-".join(path_components[name_field:len(path_components)-2])
-def udev_device_get_iscsi_address(info): +def device_get_iscsi_address(info): address_field = 1 - if udev_device_is_partoff_iscsi(info): + if device_is_partoff_iscsi(info): address_field = 3
- path_components = udev_device_get_path(info).split("-") + path_components = device_get_path(info).split("-")
# IPV6 addresses contain : within the address, so take everything # before the last : as address return ":".join(path_components[address_field].split(":")[:-1])
-def udev_device_get_iscsi_port(info): +def device_get_iscsi_port(info): address_field = 1 - if udev_device_is_partoff_iscsi(info): + if device_is_partoff_iscsi(info): address_field = 3
- path_components = udev_device_get_path(info).split("-") + path_components = device_get_path(info).split("-")
# IPV6 contains : within the address, the part after the last : is the port return path_components[address_field].split(":")[-1]
-def udev_device_get_iscsi_session(info): +def device_get_iscsi_session(info): # '/devices/pci0000:00/0000:00:02.0/0000:09:00.0/0000:0a:01.0/0000:0e:00.2/host3/session1/target3:0:0/3:0:0:0/block/sda' # The position of sessionX part depends on device # (e.g. offload vs. sw; also varies for different offload devs) @@ -605,21 +605,21 @@ def udev_device_get_iscsi_session(info): if match: session = match.groups()[0] else: - log.error("udev_device_get_iscsi_session: session not found in %s", info) + log.error("device_get_iscsi_session: session not found in %s", info) return session
-def udev_device_get_iscsi_nic(info): +def device_get_iscsi_nic(info): iface = None - session = udev_device_get_iscsi_session(info) + session = device_get_iscsi_session(info) if session: iface = open("/sys/class/iscsi_session/%s/ifacename" % session).read().strip() return iface
-def udev_device_get_iscsi_initiator(info): +def device_get_iscsi_initiator(info): initiator = None - if udev_device_is_partoff_iscsi(info): + if device_is_partoff_iscsi(info): host = re.match(r'.*/(host\d+)', info["sysfs_path"]).groups()[0] if host: initiator_file = "/sys/class/iscsi_host/%s/initiatorname" % host @@ -630,7 +630,7 @@ def udev_device_get_iscsi_initiator(info): if initiator.lstrip("(").rstrip(")").lower() == "null": initiator = None if initiator is None: - session = udev_device_get_iscsi_session(info) + session = device_get_iscsi_session(info) if session: initiator = open("/sys/class/iscsi_session/%s/initiatorname" % session).read().strip() @@ -672,7 +672,7 @@ def _detect_broadcom_fcoe(info): return (sysfs_pci, host) return (None, None)
-def udev_device_is_fcoe(info): +def device_is_fcoe(info): if info.get("ID_BUS") != "scsi": return False
@@ -691,7 +691,7 @@ def udev_device_is_fcoe(info):
return False
-def udev_device_get_fcoe_nic(info): +def device_get_fcoe_nic(info): path = info.get("ID_PATH", "") path_components = path.split("-")
@@ -713,7 +713,7 @@ def udev_device_get_fcoe_nic(info): else: return iface
-def udev_device_get_fcoe_identifier(info): +def device_get_fcoe_identifier(info): path = info.get("ID_PATH", "") path_components = path.split("-")
@@ -724,6 +724,6 @@ def udev_device_get_fcoe_identifier(info): if path.startswith("fc-") and "fcoe" in info["sysfs_path"]: return path_components[1]
- if udev_device_is_fcoe(info) and len(path_components) >= 4 and \ + if device_is_fcoe(info) and len(path_components) >= 4 and \ path_components[2] == 'fc': return path_components[3] diff --git a/blivet/zfcp.py b/blivet/zfcp.py index ccacf34..a1440ac 100644 --- a/blivet/zfcp.py +++ b/blivet/zfcp.py @@ -21,7 +21,7 @@
import string import os -from .udev import udev_settle +from . import udev from . import util from .i18n import _
@@ -144,7 +144,7 @@ class ZFCPDevice: # older zfcp sysfs interface try: loggedWriteLineToFile(portadd, self.wwpn) - udev_settle() + udev.settle() except IOError as e: raise ValueError(_("Could not add WWPN %(wwpn)s to zFCP " "device %(devnum)s (%(e)s).") \ @@ -166,7 +166,7 @@ class ZFCPDevice: if not os.path.exists(unitdir): try: loggedWriteLineToFile(unitadd, self.fcplun) - udev_settle() + udev.settle() except IOError as e: raise ValueError(_("Could not add LUN %(fcplun)s to WWPN " "%(wwpn)s on zFCP device %(devnum)s " @@ -235,7 +235,7 @@ class ZFCPDevice: and fcpwwpnsysfs == self.wwpn \ and fcplunsysfs == self.fcplun: loggedWriteLineToFile(scsidel, "1") - udev_settle() + udev.settle() return
log.warn("no scsi device found to delete for zfcp %s %s %s", diff --git a/tests/devicetree_test.py b/tests/devicetree_test.py index 6153acd..64c2410 100644 --- a/tests/devicetree_test.py +++ b/tests/devicetree_test.py @@ -6,7 +6,7 @@ from blivet.size import Size from blivet import devicelibs from blivet import devicefactory from blivet import util -from blivet.udev import udev_trigger +from blivet.udev import trigger from blivet.devices import LVMSnapShotDevice, LVMThinSnapShotDevice
""" @@ -60,7 +60,7 @@ class BlivetResetTestCase(ImageBackedTestCase): def setUp(self): super(BlivetResetTestCase, self).setUp()
- udev_trigger(subsystem="block", action="change") + trigger(subsystem="block", action="change")
self.device_attr_dicts = [] self.collect_expected_data() diff --git a/tests/udev_test.py b/tests/udev_test.py index 4bac44f..a7b09ab 100644 --- a/tests/udev_test.py +++ b/tests/udev_test.py @@ -22,7 +22,7 @@ class UdevTest(unittest.TestCase): '/sys/devices/virtual/block/dm-0', ] blivet.udev.global_udev.enumerate_devices = mock.Mock(return_value=ENUMERATE_LIST) - ret = blivet.udev.udev_enumerate_devices() + ret = blivet.udev.enumerate_devices() self.assertEqual(set(ret), set(['/devices/pci0000:00/0000:00:1f.2/host0/target0:0:0/0:0:0:0/block/sda', '/devices/virtual/block/loop0', '/devices/virtual/block/loop1', @@ -60,21 +60,21 @@ class UdevTest(unittest.TestCase): blivet.udev.global_udev = mock.Mock() blivet.udev.global_udev.create_device.return_value = dev
- saved = blivet.udev.udev_parse_uevent_file - blivet.udev.udev_parse_uevent_file = mock.Mock(return_value=dev) + saved = blivet.udev.parse_uevent_file + blivet.udev.parse_uevent_file = mock.Mock(return_value=dev)
- ret = blivet.udev.udev_get_device(DEV_PATH) + ret = blivet.udev.get_device(DEV_PATH) self.assertTrue(isinstance(ret, Device)) self.assertEqual(ret['name'], ret.sysname) self.assertEqual(ret['sysfs_path'], DEV_PATH) - self.assertTrue(blivet.udev.udev_parse_uevent_file.called) + self.assertTrue(blivet.udev.parse_uevent_file.called)
- blivet.udev.udev_parse_uevent_file = saved + blivet.udev.parse_uevent_file = saved
def test_udev_get_device_2(self): import blivet.udev blivet.udev.os.path.exists.return_value = False - ret = blivet.udev.udev_get_device('') + ret = blivet.udev.get_device('') self.assertEqual(ret, None)
def test_udev_get_device_3(self): @@ -82,23 +82,23 @@ class UdevTest(unittest.TestCase): blivet.udev.os.path.exists.return_value = True blivet.udev.global_udev = mock.Mock() blivet.udev.global_udev.create_device.return_value = None - ret = blivet.udev.udev_get_device('') + ret = blivet.udev.get_device('') self.assertEqual(ret, None)
def test_udev_get_devices(self): import blivet.udev - saved = blivet.udev.udev_settle - blivet.udev.udev_settle = mock.Mock() + saved = blivet.udev.settle + blivet.udev.settle = mock.Mock() DEVS = \ ['/devices/pci0000:00/0000:00:1f.2/host0/target0:0:0/0:0:0:0/block/sda', '/devices/virtual/block/loop0', '/devices/virtual/block/loop1', '/devices/virtual/block/ram0', '/devices/virtual/block/ram1', '/devices/virtual/block/dm-0'] - blivet.udev.udev_enumerate_devices = mock.Mock(return_value=DEVS) - blivet.udev.udev_get_device = lambda x: x - ret = blivet.udev.udev_get_devices() + blivet.udev.enumerate_devices = mock.Mock(return_value=DEVS) + blivet.udev.get_device = lambda x: x + ret = blivet.udev.get_devices() self.assertEqual(ret, DEVS) - blivet.udev.udev_settle = saved + blivet.udev.settle = saved
def test_udev_parse_uevent_file_1(self): import blivet.udev @@ -119,7 +119,7 @@ class UdevTest(unittest.TestCase): blivet.udev.os.path.normpath = os.path.normpath blivet.udev.os.access = os.access blivet.udev.os.R_OK = os.R_OK - ret = blivet.udev.udev_parse_uevent_file(dev) + ret = blivet.udev.parse_uevent_file(dev) self.assertEqual(ret, info) blivet.udev.os.path.normpath = mock.Mock() blivet.udev.os.access = mock.Mock() @@ -135,19 +135,19 @@ class UdevTest(unittest.TestCase):
dev = {'sysfs_path': path}
- ret = blivet.udev.udev_parse_uevent_file(dev) + ret = blivet.udev.parse_uevent_file(dev) self.assertEqual(ret, {'sysfs_path': '/devices/virtual/block/loop1'})
def udev_settle_test(self): import blivet.udev blivet.udev.util = mock.Mock() - blivet.udev.udev_settle() + blivet.udev.settle() self.assertTrue(blivet.udev.util.run_program.called)
def udev_trigger_test(self): import blivet.udev blivet.udev.util = mock.Mock() - blivet.udev.udev_trigger() + blivet.udev.trigger() self.assertTrue(blivet.udev.util.run_program.called)
On Mon, 2014-07-07 at 18:15 -0400, mulhern wrote:
The only reason to import udev in blivet.formats.__init__.py is for the methods that are removed in "Remove all references". Importing udev, rather than names from udev, causes pylint errors that cannot be dismissed with the disable= annotations. Trying to figure out what was going on caused me to notice that these methods should probably just go away. I still dunno what was up w/ pylint.
mulhern (2): Remove all references to DeviceFormat.majorminor Remove udev_ prefix from udev methods.
blivet/__init__.py | 2 +- blivet/deviceaction.py | 10 +- blivet/devices.py | 57 +++++---- blivet/devicetree.py | 298 ++++++++++++++++++++++---------------------- blivet/fcoe.py | 4 +- blivet/formats/__init__.py | 44 ------- blivet/formats/disklabel.py | 4 +- blivet/formats/fs.py | 4 +- blivet/iscsi.py | 4 +- blivet/udev.py | 274 ++++++++++++++++++++-------------------- blivet/zfcp.py | 8 +- tests/devicetree_test.py | 4 +- tests/udev_test.py | 36 +++--- 13 files changed, 352 insertions(+), 397 deletions(-)
Both of these look good to me.
anaconda-patches@lists.fedorahosted.org