[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