[blivet:master 2/2] Remove udev_ prefix from udev methods.
mulhern
amulhern at redhat.com
Mon Jul 7 22:15:48 UTC 2014
The udev namespace identifies the methods adequately.
Update method calls appropriately.
Signed-off-by: mulhern <amulhern at 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)
--
1.9.3
More information about the anaconda-patches
mailing list