[f22-branch 1/1] Make use of the new libblockdev error reporting

vpodzime installerbot-noreply at redhat.com
Fri Apr 17 14:57:15 UTC 2015


From: Vratislav Podzimek <vpodzime at redhat.com>

As of version 0.10 libblockdev provides better error reporting if its ErrorProxy
instances are used (e.g. blockdev.lvm.lvcreate instead of lvm.lvm_lvcreate where
blockdev.lvm is an ErrorProxy instance). Let's make use of this feature and
catch native python exceptions defined in libblockdev's python GI overrides
instead of GLib.GError.
---
 blivet/devicefactory.py     | 29 +++++++++++----------
 blivet/devicelibs/lvm.py    |  2 +-
 blivet/devices/btrfs.py     | 25 +++++++++----------
 blivet/devices/disk.py      |  6 ++---
 blivet/devices/dm.py        | 13 +++++-----
 blivet/devices/loop.py      |  8 +++---
 blivet/devices/lvm.py       | 55 ++++++++++++++++++++--------------------
 blivet/devices/md.py        | 25 +++++++++----------
 blivet/devices/partition.py |  5 ++--
 blivet/devicetree.py        | 61 ++++++++++++++++++++++-----------------------
 blivet/formats/__init__.py  |  9 +++----
 blivet/formats/fs.py        |  4 +--
 blivet/formats/luks.py      | 14 +++++------
 blivet/formats/lvmpv.py     | 13 +++++-----
 blivet/formats/mdraid.py    |  2 +-
 blivet/formats/swap.py      |  8 +++---
 blivet/osinstall.py         |  7 +++---
 blivet/partitioning.py      |  4 +--
 blivet/util.py              |  2 +-
 python-blivet.spec          |  2 +-
 tests/devices_test.py       |  2 +-
 21 files changed, 143 insertions(+), 153 deletions(-)

diff --git a/blivet/devicefactory.py b/blivet/devicefactory.py
index e0e425f..553d011 100644
--- a/blivet/devicefactory.py
+++ b/blivet/devicefactory.py
@@ -33,7 +33,6 @@
 from .partitioning import doPartitioning
 from .size import Size
 
-from gi.repository import GLib
 from gi.repository import BlockDev as blockdev
 
 import logging
@@ -596,7 +595,7 @@ def _create_device(self):
         e = None
         try:
             self._post_create()
-        except (StorageError, GLib.GError) as e:
+        except (StorageError, blockdev.BlockDevError) as e:
             log.error("device post-create method failed: %s", e)
         else:
             if not device.size:
@@ -652,7 +651,7 @@ def _set_size(self):
 
         try:
             self._post_create()
-        except (StorageError, GLib.GError) as e:
+        except (StorageError, blockdev.BlockDevError) as e:
             log.error("device post-create method failed: %s", e)
             raise
         else:
@@ -901,7 +900,7 @@ def _set_name(self):
     def _post_create(self):
         try:
             doPartitioning(self.storage)
-        except (StorageError, GLib.GError) as e:
+        except (StorageError, blockdev.BlockDevError) as e:
             log.error("failed to allocate partitions: %s", e)
             raise
 
@@ -1057,7 +1056,7 @@ def configure(self):
                 member = self.storage.newPartition(parents=[disk], grow=True,
                                            size=base_size,
                                            fmt_type=member_format)
-            except (StorageError, GLib.GError) as e:
+            except (StorageError, blockdev.BlockDevError) as e:
                 log.error("failed to create new member partition: %s", e)
                 continue
 
@@ -1145,7 +1144,7 @@ def _handle_no_size(self):
 
     def _get_device_space(self):
         # XXX: should respect the real extent size
-        return blockdev.lvm_get_lv_physical_size(self.size, lvm.LVM_PE_SIZE)
+        return blockdev.lvm.get_lv_physical_size(self.size, lvm.LVM_PE_SIZE)
 
     def _get_device_size(self):
         size = self.size
@@ -1190,7 +1189,7 @@ def _get_total_space(self):
         else:
             # container_size is a request for a fixed size for the container
             # XXX: should respect the real extent size
-            size += blockdev.lvm_get_lv_physical_size(self.container_size, lvm.LVM_PE_SIZE)
+            size += blockdev.lvm.get_lv_physical_size(self.container_size, lvm.LVM_PE_SIZE)
 
         # this does not apply if a specific container size was requested
         if self.container_size in [SIZE_POLICY_AUTO, SIZE_POLICY_MAX]:
@@ -1201,7 +1200,7 @@ def _get_total_space(self):
                 # since that's the basis for the current device's disk space
                 # usage.
                 # XXX: should respect the real extent size
-                size -= blockdev.lvm_get_lv_physical_size(self.device.size, lvm.LVM_PE_SIZE)
+                size -= blockdev.lvm.get_lv_physical_size(self.device.size, lvm.LVM_PE_SIZE)
                 log.debug("size cut to %s to omit old device space", size)
 
         if self.container_raid_level:
@@ -1392,7 +1391,7 @@ def _get_device_space(self):
         """
         space = super(LVMThinPFactory, self)._get_device_space()
         log.debug("calculated total disk space prior to padding: %s", space)
-        space += Size(blockdev.lvm_get_thpool_padding(space, self._pesize))
+        space += Size(blockdev.lvm.get_thpool_padding(space, self._pesize))
         log.debug("total disk space needed: %s", space)
         return space
 
@@ -1410,7 +1409,7 @@ def _get_total_space(self):
                 size -= self.pool.freeSpace
                 log.debug("size cut to %s to omit pool free space", size)
 
-                pad = Size(blockdev.lvm_get_thpool_padding(self.pool.freeSpace, self._pesize))
+                pad = Size(blockdev.lvm.get_thpool_padding(self.pool.freeSpace, self._pesize))
                 size -= pad
                 log.debug("size cut to %s to omit pool padding from free "
                           "space", size)
@@ -1421,7 +1420,7 @@ def _get_total_space(self):
                 # The member count here uses the container's current member set
                 # since that's the basis for the current device's disk space
                 # usage.
-                pad = Size(blockdev.lvm_get_thpool_padding(self.device.size, self._pesize))
+                pad = Size(blockdev.lvm.get_thpool_padding(self.device.size, self._pesize))
                 log.debug("old device size: %s ; old pad: %s", self.device.size, pad)
                 size -= pad
                 log.debug("size cut to %s to omit old device padding", size)
@@ -1485,7 +1484,7 @@ def _get_pool_size(self):
                 size -= self.device.poolSpaceUsed   # don't count our device
 
             # increase vg free space by the size of the current pool's pad
-            pad = Size(blockdev.lvm_get_thpool_padding(self.pool.size, self._pesize))
+            pad = Size(blockdev.lvm.get_thpool_padding(self.pool.size, self._pesize))
             log.debug("increasing free by current pool pad size (%s)", pad)
             free += pad
 
@@ -1493,11 +1492,11 @@ def _get_pool_size(self):
         free = self.container.align(free + self.container.freeSpace)
         size = self.container.align(size, roundup=True)
 
-        pad = Size(blockdev.lvm_get_thpool_padding(size, self._pesize))
+        pad = Size(blockdev.lvm.get_thpool_padding(size, self._pesize))
 
         log.debug("size is %s ; pad is %s ; free is %s", size, pad, free)
         if free < (size + pad):
-            pad = Size(blockdev.lvm_get_thpool_padding(free, self._pesize, included=True))
+            pad = Size(blockdev.lvm.get_thpool_padding(free, self._pesize, included=True))
             free = self.container.align(free - pad) # round down
             log.info("adjusting pool size from %s to %s so it fits "
                      "in container %s", size, free, self.container.name)
@@ -1576,7 +1575,7 @@ def _get_device_space(self):
         return self.raid_level.get_space(self.size,
            len(self._get_member_devices()),
            None,
-           blockdev.md_get_superblock_size)
+           blockdev.md.get_superblock_size)
 
     def _get_total_space(self):
         return self._get_device_space()
diff --git a/blivet/devicelibs/lvm.py b/blivet/devicelibs/lvm.py
index f48743c..6366703 100644
--- a/blivet/devicelibs/lvm.py
+++ b/blivet/devicelibs/lvm.py
@@ -79,7 +79,7 @@ def _set_global_config():
     if not flags.lvm_metadata_backup:
         config_string += "backup {backup=0 archive=0} "
 
-    blockdev.lvm_set_global_config(config_string)
+    blockdev.lvm.set_global_config(config_string)
 
 def needs_config_refresh(fn):
     def fn_with_refresh(*args, **kwargs):
diff --git a/blivet/devices/btrfs.py b/blivet/devices/btrfs.py
index 674d3c4..39e5017 100644
--- a/blivet/devices/btrfs.py
+++ b/blivet/devices/btrfs.py
@@ -23,7 +23,6 @@
 import copy
 import tempfile
 from gi.repository import BlockDev as blockdev
-from gi.repository import GLib
 
 from ..devicelibs import btrfs
 from ..devicelibs import raid
@@ -328,9 +327,9 @@ def listSubVolumes(self, snapshotsOnly=False):
             return subvols
 
         try:
-            subvols = blockdev.btrfs_list_subvolumes(self.originalFormat._mountpoint,
+            subvols = blockdev.btrfs.list_subvolumes(self.originalFormat._mountpoint,
                                                      snapshots_only=snapshotsOnly)
-        except GLib.GError as e:
+        except blockdev.BtrfsError as e:
             log.debug("failed to list subvolumes: %s", e)
         else:
             self._getDefaultSubVolumeID()
@@ -355,8 +354,8 @@ def removeSubVolume(self, name):
     def _getDefaultSubVolumeID(self):
         subvolid = None
         try:
-            subvolid = blockdev.btrfs_get_default_subvolume_id(self.originalFormat._mountpoint)
-        except GLib.Error as e:
+            subvolid = blockdev.btrfs.get_default_subvolume_id(self.originalFormat._mountpoint)
+        except blockdev.BtrfsError as e:
             log.debug("failed to get default subvolume id: %s", e)
 
         self._defaultSubVolumeID = subvolid
@@ -367,8 +366,8 @@ def _setDefaultSubVolumeID(self, vol_id):
             This writes the change to the filesystem, which must be mounted.
         """
         try:
-            blockdev.btrfs_set_default_subvolume(self.originalFormat._mountpoint, vol_id)
-        except GLib.Error as e:
+            blockdev.btrfs.set_default_subvolume(self.originalFormat._mountpoint, vol_id)
+        except blockdev.BtrfsError as e:
             log.error("failed to set new default subvolume id (%s): %s",
                       vol_id, e)
             # The only time we set a new default subvolume is so we can remove
@@ -408,7 +407,7 @@ def _create(self):
             md_level = str(self.metaDataLevel)
         else:
             md_level = None
-        blockdev.btrfs_create_volume([d.path for d in self.parents],
+        blockdev.btrfs.create_volume([d.path for d in self.parents],
                                      label=self.format.label,
                                      data_level=data_level,
                                      md_level=md_level)
@@ -439,7 +438,7 @@ def _remove(self, member):
             raise
 
         try:
-            blockdev.btrfs_remove_device(self.originalFormat._mountpoint, member.path)
+            blockdev.btrfs.remove_device(self.originalFormat._mountpoint, member.path)
         finally:
             self._undo_temp_mount()
 
@@ -451,7 +450,7 @@ def _add(self, member):
             raise
 
         try:
-            blockdev.btrfs_add_device(self.originalFormat._mountpoint, member.path)
+            blockdev.btrfs.add_device(self.originalFormat._mountpoint, member.path)
         finally:
             self._undo_temp_mount()
 
@@ -541,7 +540,7 @@ def _create(self):
             raise RuntimeError("btrfs subvol create requires mounted volume")
 
         try:
-            blockdev.btrfs_create_subvolume(mountpoint, self.name)
+            blockdev.btrfs.create_subvolume(mountpoint, self.name)
         finally:
             self.volume._undo_temp_mount()
 
@@ -559,7 +558,7 @@ def _destroy(self):
         mountpoint = self.volume.originalFormat._mountpoint
         if not mountpoint:
             raise RuntimeError("btrfs subvol destroy requires mounted volume")
-        blockdev.btrfs_delete_subvolume(mountpoint, self.name)
+        blockdev.btrfs.delete_subvolume(mountpoint, self.name)
         self.volume._undo_temp_mount()
 
     def removeHook(self, modparent=True):
@@ -643,7 +642,7 @@ def _create(self):
 
         dest_path = "%s/%s" % (mountpoint, self.name)
         try:
-            blockdev.btrfs_create_snapshot(source_path, dest_path, ro=self.readOnly)
+            blockdev.btrfs.create_snapshot(source_path, dest_path, ro=self.readOnly)
         finally:
             self.volume._undo_temp_mount()
 
diff --git a/blivet/devices/disk.py b/blivet/devices/disk.py
index ec0ea7e..8192e04 100644
--- a/blivet/devices/disk.py
+++ b/blivet/devices/disk.py
@@ -204,13 +204,13 @@ def deactivate(self):
         """ Deactivate the raid set. """
         log_method_call(self, self.name, status=self.status)
         # This call already checks if the set is not active.
-        blockdev.dm_deactivate_raid_set(self.name)
+        blockdev.dm.deactivate_raid_set(self.name)
 
     def activate(self):
         """ Activate the raid set. """
         log_method_call(self, self.name, status=self.status)
         # This call already checks if the set is active.
-        blockdev.dm_activate_raid_set(self.name)
+        blockdev.dm.activate_raid_set(self.name)
         udev.settle()
 
     def _setup(self, orig=False):
@@ -236,7 +236,7 @@ def _remove(self, member):
 
     @property
     def description(self):
-        return "BIOS RAID set (%s)" % blockdev.dm_get_raid_set_type(self.name)
+        return "BIOS RAID set (%s)" % blockdev.dm.get_raid_set_type(self.name)
 
     @property
     def model(self):
diff --git a/blivet/devices/dm.py b/blivet/devices/dm.py
index 25e30cf..ca4dd15 100644
--- a/blivet/devices/dm.py
+++ b/blivet/devices/dm.py
@@ -22,7 +22,6 @@
 
 import os
 from gi.repository import BlockDev as blockdev
-from gi.repository import GLib
 
 from .. import errors
 from .. import util
@@ -97,8 +96,8 @@ def mapName(self):
     @property
     def status(self):
         try:
-            return blockdev.dm_map_exists(self.mapName, True, True)
-        except GLib.GError as e:
+            return blockdev.dm.map_exists(self.mapName, True, True)
+        except blockdev.DMError as e:
             if "Not running as root" in e.message:
                 return False
             else:
@@ -113,7 +112,7 @@ def getDMNode(self):
         if not self.exists:
             raise errors.DeviceError("device has not been created", self.name)
 
-        return blockdev.dm_node_from_name(self.name)
+        return blockdev.dm.node_from_name(self.name)
 
     def setupPartitions(self):
         log_method_call(self, name=self.name, kids=self.kids)
@@ -131,7 +130,7 @@ def teardownPartitions(self):
         for dev in os.listdir("/dev/mapper/"):
             prefix = self.name + "p"
             if dev.startswith(prefix) and dev[len(prefix):].isdigit():
-                blockdev.dm_remove(dev)
+                blockdev.dm.remove(dev)
 
     def _setName(self, value):
         """ Set the device's map name. """
@@ -186,7 +185,7 @@ def _setup(self, orig=False):
         log_method_call(self, self.name, orig=orig, status=self.status,
                         controllable=self.controllable)
         slave_length = self.slave.partedDevice.length
-        blockdev.dm_create_linear(self.name, self.slave.path, slave_length,
+        blockdev.dm.create_linear(self.name, self.slave.path, slave_length,
                                   self.dmUuid)
 
     def _postSetup(self):
@@ -197,7 +196,7 @@ def _postSetup(self):
     def _teardown(self, recursive=False):
         self.teardownPartitions()
         udev.settle()
-        blockdev.dm_remove(self.name)
+        blockdev.dm.remove(self.name)
         udev.settle()
 
     def deactivate(self, recursive=False):
diff --git a/blivet/devices/loop.py b/blivet/devices/loop.py
index 6410443..aca8d44 100644
--- a/blivet/devices/loop.py
+++ b/blivet/devices/loop.py
@@ -73,7 +73,7 @@ def updateName(self):
             # if our name is loopN we must already be active
             return self.name
 
-        name = blockdev.loop_get_loop_name(self.slave.path)
+        name = blockdev.loop.get_loop_name(self.slave.path)
         if name.startswith("loop"):
             self.name = name
 
@@ -83,7 +83,7 @@ def updateName(self):
     def status(self):
         return (self.slave.status and
                 self.name.startswith("loop") and
-                blockdev.loop_get_loop_name(self.slave.path) == self.name)
+                blockdev.loop.get_loop_name(self.slave.path) == self.name)
 
     @property
     def size(self):
@@ -98,7 +98,7 @@ def _setup(self, orig=False):
         """ Open, or set up, a device. """
         log_method_call(self, self.name, orig=orig, status=self.status,
                         controllable=self.controllable)
-        blockdev.loop_setup(self.slave.path)
+        blockdev.loop.setup(self.slave.path)
 
     def _postSetup(self):
         StorageDevice._postSetup(self)
@@ -109,7 +109,7 @@ def _teardown(self, recursive=False):
         """ Close, or tear down, a device. """
         log_method_call(self, self.name, status=self.status,
                         controllable=self.controllable)
-        blockdev.loop_teardown(self.path)
+        blockdev.loop.teardown(self.path)
 
     def _postTeardown(self, recursive=False):
         StorageDevice._postTeardown(self, recursive=recursive)
diff --git a/blivet/devices/lvm.py b/blivet/devices/lvm.py
index 2524c72..3aebd6f 100644
--- a/blivet/devices/lvm.py
+++ b/blivet/devices/lvm.py
@@ -25,7 +25,6 @@
 import pprint
 import re
 from gi.repository import BlockDev as blockdev
-from gi.repository import GLib
 
 # device backend modules
 from ..devicelibs import lvm
@@ -55,7 +54,7 @@ class LVMVolumeGroupDevice(ContainerDevice):
 
     @staticmethod
     def get_supported_pe_sizes():
-        return [Size(pe_size) for pe_size in blockdev.lvm_get_supported_pe_sizes()]
+        return [Size(pe_size) for pe_size in blockdev.lvm.get_supported_pe_sizes()]
 
     def __init__(self, name, parents=None, size=None, free=None,
                  peSize=None, peCount=None, peFree=None, pvCount=None,
@@ -200,13 +199,13 @@ def _teardown(self, recursive=None):
         """ Close, or tear down, a device. """
         log_method_call(self, self.name, status=self.status,
                         controllable=self.controllable)
-        blockdev.lvm_vgdeactivate(self.name)
+        blockdev.lvm.vgdeactivate(self.name)
 
     def _create(self):
         """ Create the device. """
         log_method_call(self, self.name, status=self.status)
         pv_list = [pv.path for pv in self.parents]
-        blockdev.lvm_vgcreate(self.name, pv_list, self.peSize)
+        blockdev.lvm.vgcreate(self.name, pv_list, self.peSize)
 
     def _postCreate(self):
         self._complete = True
@@ -229,9 +228,9 @@ def _destroy(self):
             # the same name that we want to keep/use.
             return
 
-        blockdev.lvm_vgreduce(self.name, None)
-        blockdev.lvm_vgdeactivate(self.name)
-        blockdev.lvm_vgremove(self.name)
+        blockdev.lvm.vgreduce(self.name, None)
+        blockdev.lvm.vgdeactivate(self.name)
+        blockdev.lvm.vgremove(self.name)
 
     def _remove(self, member):
         status = []
@@ -240,15 +239,15 @@ def _remove(self, member):
             if lv.exists:
                 lv.setup()
 
-        blockdev.lvm_pvmove(member.path)
-        blockdev.lvm_vgreduce(self.name, member.path)
+        blockdev.lvm.pvmove(member.path)
+        blockdev.lvm.vgreduce(self.name, member.path)
 
         for (lv, status) in zip(self.lvs, status):
             if lv.status and not status:
                 lv.teardown()
 
     def _add(self, member):
-        blockdev.lvm_vgextend(self.name, member.path)
+        blockdev.lvm.vgextend(self.name, member.path)
 
     def _addLogVol(self, lv):
         """ Add an LV to this VG. """
@@ -602,7 +601,7 @@ def getDMNode(self):
         if not self.exists:
             raise errors.DeviceError("device has not been created", self.name)
 
-        return blockdev.dm_node_from_name(self.mapName)
+        return blockdev.dm.node_from_name(self.mapName)
 
     def _getName(self):
         """ This device's name. """
@@ -626,13 +625,13 @@ def _setup(self, orig=False):
         """ Open, or set up, a device. """
         log_method_call(self, self.name, orig=orig, status=self.status,
                         controllable=self.controllable)
-        blockdev.lvm_lvactivate(self.vg.name, self._name)
+        blockdev.lvm.lvactivate(self.vg.name, self._name)
 
     def _teardown(self, recursive=None):
         """ Close, or tear down, a device. """
         log_method_call(self, self.name, status=self.status,
                         controllable=self.controllable)
-        blockdev.lvm_lvdeactivate(self.vg.name, self._name)
+        blockdev.lvm.lvdeactivate(self.vg.name, self._name)
 
     def _postTeardown(self, recursive=False):
         try:
@@ -650,8 +649,8 @@ def _preCreate(self):
         super(LVMLogicalVolumeDevice, self)._preCreate()
 
         try:
-            vg_info = blockdev.lvm_vginfo(self.vg.name)
-        except GLib.GError as lvmerr:
+            vg_info = blockdev.lvm.vginfo(self.vg.name)
+        except blockdev.LVMError as lvmerr:
             log.error("Failed to get free space for the %s VG: %s", self.vg.name, lvmerr)
             # nothing more can be done, we don't know the VG's free space
             return
@@ -670,7 +669,7 @@ def _create(self):
         """ Create the device. """
         log_method_call(self, self.name, status=self.status)
         # should we use --zero for safety's sake?
-        blockdev.lvm_lvcreate(self.vg.name, self._name, self.size)
+        blockdev.lvm.lvcreate(self.vg.name, self._name, self.size)
 
     def _preDestroy(self):
         StorageDevice._preDestroy(self)
@@ -680,7 +679,7 @@ def _preDestroy(self):
     def _destroy(self):
         """ Destroy the device. """
         log_method_call(self, self.name, status=self.status)
-        blockdev.lvm_lvremove(self.vg.name, self._name)
+        blockdev.lvm.lvremove(self.vg.name, self._name)
 
     def resize(self):
         log_method_call(self, self.name, status=self.status)
@@ -694,7 +693,7 @@ def resize(self):
             self.format.teardown()
 
         udev.settle()
-        blockdev.lvm_lvresize(self.vg.name, self._name, self.size)
+        blockdev.lvm.lvresize(self.vg.name, self._name, self.size)
 
     @property
     def isleaf(self):
@@ -883,7 +882,7 @@ def merge(self):
             pass
 
         udev.settle()
-        blockdev.lvm_lvsnapshotmerge(self.vg.name, self.lvname) # pylint: disable=no-member
+        blockdev.lvm.lvsnapshotmerge(self.vg.name, self.lvname) # pylint: disable=no-member
 
 
 class LVMSnapShotDevice(LVMSnapShotBase, LVMLogicalVolumeDevice):
@@ -948,7 +947,7 @@ def teardown(self, recursive=False):
     def _create(self):
         """ Create the device. """
         log_method_call(self, self.name, status=self.status)
-        blockdev.lvm_lvsnapshotcreate(self.vg.name, self.origin.lvname, self._name, self.size)
+        blockdev.lvm.lvsnapshotcreate(self.vg.name, self.origin.lvname, self._name, self.size)
 
     def _destroy(self):
         """ Destroy the device. """
@@ -956,7 +955,7 @@ def _destroy(self):
         # old-style snapshots' status is tied to the origin's so we never
         # explicitly activate or deactivate them and we have to tell lvremove
         # that it is okay to remove the active snapshot
-        blockdev.lvm_lvremove(self.vg.name, self._name, force=True)
+        blockdev.lvm.lvremove(self.vg.name, self._name, force=True)
 
     def _getPartedDevicePath(self):
         return "%s-cow" % self.path
@@ -1010,11 +1009,11 @@ def __init__(self, name, parents=None, size=None, uuid=None,
 
         """
         if metadatasize is not None and \
-           not blockdev.lvm_is_valid_thpool_md_size(metadatasize):
+           not blockdev.lvm.is_valid_thpool_md_size(metadatasize):
             raise ValueError("invalid metadatasize value")
 
         if chunksize is not None and \
-           not blockdev.lvm_is_valid_thpool_chunk_size(chunksize):
+           not blockdev.lvm.is_valid_thpool_chunk_size(chunksize):
             raise ValueError("invalid chunksize value")
 
         super(LVMThinPoolDevice, self).__init__(name, parents=parents,
@@ -1056,7 +1055,7 @@ def lvs(self):
     @property
     def vgSpaceUsed(self):
         space = super(LVMThinPoolDevice, self).vgSpaceUsed
-        space += Size(blockdev.lvm_get_thpool_padding(space, self.vg.peSize))
+        space += Size(blockdev.lvm.get_thpool_padding(space, self.vg.peSize))
         return space
 
     @property
@@ -1075,7 +1074,7 @@ def _create(self):
         else:
             profile_name = None
         # TODO: chunk size, data/metadata split --> profile
-        blockdev.lvm_thpoolcreate(self.vg.name, self.lvname, self.size,
+        blockdev.lvm.thpoolcreate(self.vg.name, self.lvname, self.size,
                                   md_size=self.metaDataSize,
                                   chunk_size=self.chunkSize,
                                   profile=profile_name)
@@ -1144,7 +1143,7 @@ def _preCreate(self):
     def _create(self):
         """ Create the device. """
         log_method_call(self, self.name, status=self.status)
-        blockdev.lvm_thlvcreate(self.vg.name, self.pool.lvname, self.lvname,
+        blockdev.lvm.thlvcreate(self.vg.name, self.pool.lvname, self.lvname,
                                 self.size)
 
     def removeHook(self, modparent=True):
@@ -1215,7 +1214,7 @@ def _setup(self, orig=False):
         """ Open, or set up, a device. """
         log_method_call(self, self.name, orig=orig, status=self.status,
                         controllable=self.controllable)
-        blockdev.lvm_lvactivate(self.vg.name, self._name, ignore_skip=True)
+        blockdev.lvm.lvactivate(self.vg.name, self._name, ignore_skip=True)
 
     def _create(self):
         """ Create the device. """
@@ -1226,7 +1225,7 @@ def _create(self):
             # to use
             pool_name = self.pool.lvname
 
-        blockdev.lvm_thsnapshotcreate(self.vg.name, self._name, self.origin.lvname,
+        blockdev.lvm.thsnapshotcreate(self.vg.name, self._name, self.origin.lvname,
                                       pool_name=pool_name)
 
     def dependsOn(self, dep):
diff --git a/blivet/devices/md.py b/blivet/devices/md.py
index 0e8813e..7e898dc 100644
--- a/blivet/devices/md.py
+++ b/blivet/devices/md.py
@@ -23,7 +23,6 @@
 import six
 
 from gi.repository import BlockDev as blockdev
-from gi.repository import GLib
 
 from ..devicelibs import mdraid, raid
 
@@ -133,8 +132,8 @@ def mdadmFormatUUID(self):
 
         if self.uuid is not None:
             try:
-                formatted_uuid = blockdev.md_get_md_uuid(self.uuid)
-            except GLib.GError:
+                formatted_uuid = blockdev.md.get_md_uuid(self.uuid)
+            except blockdev.MDRaidError:
                 pass
 
         return formatted_uuid
@@ -196,7 +195,7 @@ def getSuperBlockSize(self, raw_array_size):
            :returns: estimated superblock size
            :rtype: :class:`~.size.Size`
         """
-        return blockdev.md_get_superblock_size(raw_array_size,
+        return blockdev.md.get_superblock_size(raw_array_size,
                                                version=self.metadataVersion)
 
     @property
@@ -210,7 +209,7 @@ def size(self):
                     self.memberDevices,
                     self.chunkSize,
                     self.getSuperBlockSize)
-            except (GLib.GError, errors.RaidError) as e:
+            except (blockdev.MDRaidError, errors.RaidError) as e:
                 log.info("could not calculate size of device %s for raid level %s: %s", self.name, self.level, e)
                 size = Size(0)
             log.debug("non-existent RAID %s size == %s", self.level, size)
@@ -425,7 +424,7 @@ def _setup(self, orig=False):
             member.setup(orig=orig)
             disks.append(member.path)
 
-        blockdev.md_activate(self.path, members=disks, uuid=self.mdadmFormatUUID)
+        blockdev.md.activate(self.path, members=disks, uuid=self.mdadmFormatUUID)
 
     def _postTeardown(self, recursive=False):
         super(MDRaidArrayDevice, self)._postTeardown(recursive=recursive)
@@ -446,7 +445,7 @@ def teardown(self, recursive=None):
         # file exists, we want to deactivate it. mdraid has too many
         # states.
         if self.exists and os.path.exists(self.path):
-            blockdev.md_deactivate(self.path)
+            blockdev.md.deactivate(self.path)
 
         self._postTeardown(recursive=recursive)
 
@@ -474,7 +473,7 @@ def _postCreate(self):
 
         # update our uuid attribute with the new array's UUID
         # XXX this won't work for containers since no UUID is reported for them
-        info = blockdev.md_detail(self.path)
+        info = blockdev.md.detail(self.path)
         self.uuid = info.uuid
         for member in self.devices:
             member.format.mdUuid = self.uuid
@@ -487,7 +486,7 @@ def _create(self):
         level = None
         if self.level:
             level = str(self.level)
-        blockdev.md_create(self.path, level, disks, spares,
+        blockdev.md.create(self.path, level, disks, spares,
                            version=self.metadataVersion,
                            bitmap=self.createBitmap)
         udev.settle()
@@ -496,14 +495,14 @@ def _remove(self, member):
         self.setup()
         # see if the device must be marked as failed before it can be removed
         fail = (self.memberStatus(member) == "in_sync")
-        blockdev.md_remove(self.path, member.path, fail)
+        blockdev.md.remove(self.path, member.path, fail)
 
     def _add(self, member):
         """ Add a member device to an array.
 
            :param str member: the member's path
 
-           :raises: GLib.GError
+           :raises: blockdev.MDRaidError
         """
         self.setup()
 
@@ -511,11 +510,11 @@ def _add(self, member):
         try:
             if not self.level.has_redundancy():
                 if self.level is not raid.Linear:
-                    raid_devices = int(blockdev.md_detail(self.name).raid_devices) + 1
+                    raid_devices = int(blockdev.md.detail(self.name).raid_devices) + 1
         except errors.RaidError:
             pass
 
-        blockdev.md_add(self.path, member.path, raid_devs=raid_devices)
+        blockdev.md.add(self.path, member.path, raid_devs=raid_devices)
 
     @property
     def formatArgs(self):
diff --git a/blivet/devices/partition.py b/blivet/devices/partition.py
index 504d7e1..5e77fa4 100644
--- a/blivet/devices/partition.py
+++ b/blivet/devices/partition.py
@@ -23,7 +23,6 @@
 import parted
 import _ped
 from gi.repository import BlockDev as blockdev
-from gi.repository import GLib
 
 from .. import errors
 from .. import util
@@ -692,8 +691,8 @@ def _postDestroy(self):
             # self.exists has been unset, so don't use self.status
             if os.path.exists(self.path):
                 try:
-                    blockdev.dm_remove(self.name)
-                except GLib.GError:
+                    blockdev.dm.remove(self.name)
+                except blockdev.DMError:
                     pass
 
     def _getSize(self):
diff --git a/blivet/devicetree.py b/blivet/devicetree.py
index b1bb4d7..4c3f40a 100644
--- a/blivet/devicetree.py
+++ b/blivet/devicetree.py
@@ -27,7 +27,6 @@
 import copy
 
 from gi.repository import BlockDev as blockdev
-from gi.repository import GLib
 
 from .errors import DeviceError, DeviceTreeError, DiskLabelCommitError, DMError, FSError, InvalidDiskLabelError, LUKSError, StorageError, UnusableConfigurationError
 from .devices import BTRFSDevice, BTRFSSubVolumeDevice, BTRFSVolumeDevice, BTRFSSnapShotDevice
@@ -172,7 +171,7 @@ def addIgnoredDisk(self, disk):
     @property
     def pvInfo(self):
         if self._pvs_cache is None:
-            pvs = blockdev.lvm_pvs()
+            pvs = blockdev.lvm.pvs()
             self._pvs_cache = dict((pv.pv_name, pv) for pv in pvs) # pylint: disable=attribute-defined-outside-init
 
         return self._pvs_cache
@@ -180,7 +179,7 @@ def pvInfo(self):
     @property
     def lvInfo(self):
         if self._lvs_cache is None:
-            lvs = blockdev.lvm_lvs()
+            lvs = blockdev.lvm.lvs()
             self._lvs_cache = dict((lv.lv_name, lv) for lv in lvs) # pylint: disable=attribute-defined-outside-init
 
         return self._lvs_cache
@@ -643,7 +642,7 @@ def isIgnored(self, info):
 
         if name.startswith("loop"):
             # ignore loop devices unless they're backed by a file
-            return (not blockdev.loop_get_backing_file(name))
+            return (not blockdev.loop.get_backing_file(name))
 
         # FIXME: check for virtual devices whose slaves are on the ignore list
 
@@ -736,7 +735,7 @@ def addUdevDMDevice(self, info):
             for slave_name in slave_names:
                 # if it's a dm-X name, resolve it to a map name first
                 if slave_name.startswith("dm-"):
-                    dev_name = blockdev.dm_name_from_node(slave_name)
+                    dev_name = blockdev.dm.name_from_node(slave_name)
                 else:
                     dev_name = slave_name.replace("!", "/") # handles cciss
                 slave_dev = self.getDeviceByName(dev_name)
@@ -806,7 +805,7 @@ def addUdevMultiPathDevice(self, info):
         for slave_name in slave_names:
             # if it's a dm-X name, resolve it to a map name first
             if slave_name.startswith("dm-"):
-                dev_name = blockdev.dm_name_from_node(slave_name)
+                dev_name = blockdev.dm.name_from_node(slave_name)
             else:
                 dev_name = slave_name.replace("!", "/") # handles cciss
             slave_dev = self.getDeviceByName(dev_name)
@@ -849,7 +848,7 @@ def addUdevMDDevice(self, info):
         for slave_name in slave_names:
             # if it's a dm-X name, resolve it to a map name
             if slave_name.startswith("dm-"):
-                dev_name = blockdev.dm_name_from_node(slave_name)
+                dev_name = blockdev.dm.name_from_node(slave_name)
             else:
                 dev_name = slave_name
             slave_dev = self.getDeviceByName(dev_name)
@@ -894,8 +893,8 @@ def addUdevMDDevice(self, info):
 
             log.error("failed to scan md array %s", name)
             try:
-                blockdev.md_deactivate(path)
-            except GLib.GError:
+                blockdev.md.deactivate(path)
+            except blockdev.MDRaidError:
                 log.error("failed to stop broken md array %s", name)
 
         return device
@@ -906,7 +905,7 @@ def addUdevPartitionDevice(self, info, disk=None):
         sysfs_path = udev.device_get_sysfs_path(info)
 
         if name.startswith("md"):
-            name = blockdev.md_name_from_node(name)
+            name = blockdev.md.name_from_node(name)
             device = self.getDeviceByName(name)
             if device:
                 return device
@@ -915,7 +914,7 @@ def addUdevPartitionDevice(self, info, disk=None):
             disk_name = os.path.basename(os.path.dirname(sysfs_path))
             disk_name = disk_name.replace('!','/')
             if disk_name.startswith("md"):
-                disk_name = blockdev.md_name_from_node(disk_name)
+                disk_name = blockdev.md.name_from_node(disk_name)
 
             disk = self.getDeviceByName(disk_name)
 
@@ -1024,7 +1023,7 @@ def addUdevDiskDevice(self, info):
             parentName = devicePathToName(parentPath)
             container = self.getDeviceByName(parentName)
             if not container:
-                parentSysName = blockdev.md_node_from_name(parentName)
+                parentSysName = blockdev.md.node_from_name(parentName)
                 container_sysfs = "/sys/class/block/" + parentSysName
                 container_info = udev.get_device(container_sysfs)
                 if not container_info:
@@ -1155,8 +1154,8 @@ def addUdevDevice(self, info):
                 devname = udev.device_get_devname(info)
                 if devname:
                     try:
-                        blockdev.md_run(devname)
-                    except GLib.Error as e:
+                        blockdev.md.run(devname)
+                    except blockdev.MDRaidError as e:
                         log.warning("Failed to start possibly degraded md array: %s", e)
                     else:
                         udev.settle()
@@ -1175,7 +1174,7 @@ def addUdevDevice(self, info):
                 device = None
 
         if device and device.isDisk and \
-           blockdev.mpath_is_mpath_member(device.path):
+           blockdev.mpath.is_mpath_member(device.path):
             # newly added device (eg iSCSI) could make this one a multipath member
             if device.format and device.format.type != "multipath_member":
                 log.debug("%s newly detected as multipath member, dropping old format and removing kids", device.name)
@@ -1342,7 +1341,7 @@ def handleUdevLUKSFormat(self, info, device):
                     device.format.passphrase = passphrase
                     try:
                         device.format.setup()
-                    except GLib.GError:
+                    except blockdev.BlockDevError:
                         device.format.passphrase = None
                     else:
                         break
@@ -1352,7 +1351,7 @@ def handleUdevLUKSFormat(self, info, device):
                                      exists=True)
             try:
                 luks_device.setup()
-            except (LUKSError, GLib.GError, DeviceError) as e:
+            except (LUKSError, blockdev.CryptoError, DeviceError) as e:
                 log.info("setup of %s failed: %s", device.format.mapName, e)
                 device.removeChild()
             else:
@@ -1421,7 +1420,7 @@ def addLV(lv):
 
             if lv_attr[0] in 'Ss':
                 log.info("found lvm snapshot volume '%s'", name)
-                origin_name = blockdev.lvm_lvorigin(vg_name, lv_name)
+                origin_name = blockdev.lvm.lvorigin(vg_name, lv_name)
                 if not origin_name:
                     log.error("lvm snapshot '%s-%s' has unknown origin",
                                 vg_name, lv_name)
@@ -1471,11 +1470,11 @@ def addLV(lv):
                 lv_class = LVMThinPoolDevice
             elif lv_attr[0] == 'V':
                 # thin volume
-                pool_name = blockdev.lvm_thlvpoolname(vg_name, lv_name)
+                pool_name = blockdev.lvm.thlvpoolname(vg_name, lv_name)
                 pool_device_name = "%s-%s" % (vg_name, pool_name)
                 addRequiredLV(pool_device_name, "failed to look up thin pool")
 
-                origin_name = blockdev.lvm_lvorigin(vg_name, lv_name)
+                origin_name = blockdev.lvm.lvorigin(vg_name, lv_name)
                 if origin_name:
                     origin_device_name = "%s-%s" % (vg_name, origin_name)
                     addRequiredLV(origin_device_name, "failed to locate origin lv")
@@ -1592,7 +1591,7 @@ def handleUdevLVMPVFormat(self, info, device):
     def handleUdevMDMemberFormat(self, info, device):
         # pylint: disable=unused-argument
         log_method_call(self, name=device.name, type=device.format.type)
-        md_info = blockdev.md_examine(device.path)
+        md_info = blockdev.md.examine(device.path)
 
         # Use mdadm info if udev info is missing
         md_uuid = md_info.uuid
@@ -1672,7 +1671,7 @@ def handleUdevDMRaidMemberFormat(self, info, device):
         minor = udev.device_get_minor(info)
 
         # Have we already created the DMRaidArrayDevice?
-        rs_names = blockdev.dm_get_member_raid_sets(uuid, name, major, minor)
+        rs_names = blockdev.dm.get_member_raid_sets(uuid, name, major, minor)
         if len(rs_names) == 0:
             log.warning("dmraid member %s does not appear to belong to any "
                         "array", device.name)
@@ -1685,7 +1684,7 @@ def handleUdevDMRaidMemberFormat(self, info, device):
                 dm_array.parents.append(device)
             else:
                 # Activate the Raid set.
-                blockdev.dm_activate_raid_set(rs_name)
+                blockdev.dm.activate_raid_set(rs_name)
                 dm_array = DMRaidArrayDevice(rs_name,
                                              parents=[device])
 
@@ -1783,7 +1782,7 @@ def handleUdevDeviceFormat(self, info, device):
         format_type = udev.device_get_format(info)
         serial = udev.device_get_serial(info)
 
-        is_multipath_member = blockdev.mpath_is_mpath_member(device.path)
+        is_multipath_member = blockdev.mpath.is_mpath_member(device.path)
         if is_multipath_member:
             format_type = "multipath_member"
 
@@ -2040,7 +2039,7 @@ def setupDiskImages(self):
                 filedev.setup()
                 log.debug("%s", filedev)
 
-                loop_name = blockdev.loop_get_loop_name(filedev.path)
+                loop_name = blockdev.loop.get_loop_name(filedev.path)
                 loop_sysfs = None
                 if loop_name:
                     loop_sysfs = "/class/block/%s" % loop_name
@@ -2142,7 +2141,7 @@ def _populate(self):
         self.dropLVMCache()
 
         if flags.installer_mode and not flags.image_install:
-            blockdev.mpath_set_friendly_names(flags.multipath_friendly_names)
+            blockdev.mpath.set_friendly_names(flags.multipath_friendly_names)
 
         self.setupDiskImages()
 
@@ -2230,7 +2229,7 @@ def teardownAll(self):
 
             try:
                 device.teardown(recursive=True)
-            except (StorageError, GLib.GError) as e:
+            except (StorageError, blockdev.BlockDevError) as e:
                 log.info("teardown of %s failed: %s", device.name, e)
 
     def teardownDiskImages(self):
@@ -2566,8 +2565,8 @@ def resolveDevice(self, devspec, blkidTab=None, cryptTab=None, options=None):
 
                 if devspec.startswith("/dev/dm-"):
                     try:
-                        dm_name = blockdev.dm_name_from_node(devspec[5:])
-                    except GLib.GError as e:
+                        dm_name = blockdev.dm.name_from_node(devspec[5:])
+                    except blockdev.DMError as e:
                         log.info("failed to resolve %s: %s", devspec, e)
                         dm_name = None
 
@@ -2576,8 +2575,8 @@ def resolveDevice(self, devspec, blkidTab=None, cryptTab=None, options=None):
 
                 if re.match(r'/dev/md\d+(p\d+)?$', devspec):
                     try:
-                        md_name = blockdev.md_name_from_node(devspec[5:])
-                    except GLib.GError as e:
+                        md_name = blockdev.md.name_from_node(devspec[5:])
+                    except blockdev.MDRaidError as e:
                         log.info("failed to resolve %s: %s", devspec, e)
                         md_name = None
 
diff --git a/blivet/formats/__init__.py b/blivet/formats/__init__.py
index 6d5da47..0c8961a 100644
--- a/blivet/formats/__init__.py
+++ b/blivet/formats/__init__.py
@@ -23,7 +23,6 @@
 
 import os
 from gi.repository import BlockDev as blockdev
-from gi.repository import GLib
 
 from ..util import notify_kernel
 from ..util import get_sysfs_path_by_name
@@ -345,14 +344,14 @@ def notifyKernel(self):
 
         if self.device.startswith("/dev/mapper/"):
             try:
-                name = blockdev.dm_node_from_name(os.path.basename(self.device))
-            except GLib.GError:
+                name = blockdev.dm.node_from_name(os.path.basename(self.device))
+            except blockdev.DMError:
                 log.warning("failed to get dm node for %s", self.device)
                 return
         elif self.device.startswith("/dev/md/"):
             try:
-                name = blockdev.md_node_from_name(os.path.basename(self.device))
-            except GLib.GError:
+                name = blockdev.md.node_from_name(os.path.basename(self.device))
+            except blockdev.MDRaidError:
                 log.warning("failed to get md node for %s", self.device)
                 return
         else:
diff --git a/blivet/formats/fs.py b/blivet/formats/fs.py
index 491a4f2..681ff04 100644
--- a/blivet/formats/fs.py
+++ b/blivet/formats/fs.py
@@ -1125,11 +1125,11 @@ def __init__(self, **kwargs):
         self.volUUID = kwargs.pop("volUUID", None)
 
     def create(self, **kwargs):
-        # filesystem creation is done in blockdev.btrfs_create_volume
+        # filesystem creation is done in blockdev.btrfs.create_volume
         self.exists = True
 
     def destroy(self, **kwargs):
-        # filesystem deletion is done in blockdev.btrfs_delete_volume
+        # filesystem deletion is done in blockdev.btrfs.delete_volume
         self.exists = False
 
     def setup(self, **kwargs):
diff --git a/blivet/formats/luks.py b/blivet/formats/luks.py
index a5abc4d..8f43ddf 100644
--- a/blivet/formats/luks.py
+++ b/blivet/formats/luks.py
@@ -182,7 +182,7 @@ def setup(self, **kwargs):
             return
 
         DeviceFormat.setup(self, **kwargs)
-        blockdev.crypto_luks_open(self.device, self.mapName,
+        blockdev.crypto.luks_open(self.device, self.mapName,
                                   passphrase=self.__passphrase,
                                   key_file=self._key_file)
 
@@ -195,7 +195,7 @@ def teardown(self):
 
         if self.status:
             log.debug("unmapping %s", self.mapName)
-            blockdev.crypto_luks_close(self.mapName)
+            blockdev.crypto.luks_close(self.mapName)
 
     def create(self, **kwargs):
         """ Write the formatting to the specified block device.
@@ -217,7 +217,7 @@ def create(self, **kwargs):
 
         try:
             DeviceFormat.create(self, **kwargs)
-            blockdev.crypto_luks_format(self.device,
+            blockdev.crypto.luks_format(self.device,
                                         passphrase=self.__passphrase,
                                         key_file=self._key_file,
                                         cipher=self.cipher,
@@ -227,7 +227,7 @@ def create(self, **kwargs):
         except Exception:
             raise
         else:
-            self.uuid = blockdev.crypto_luks_uuid(self.device)
+            self.uuid = blockdev.crypto.luks_uuid(self.device)
             self.exists = True
             if flags.installer_mode:
                 self.mapName = "luks-%s" % self.uuid
@@ -261,7 +261,7 @@ def addPassphrase(self, passphrase):
         if not self.exists:
             raise LUKSError("format has not been created")
 
-        blockdev.crypto_luks_add_key(self.device,
+        blockdev.crypto.luks_add_key(self.device,
                                      pass_=self.__passphrase,
                                      key_file=self._key_file,
                                      new_passphrase=passphrase)
@@ -278,13 +278,13 @@ def removePassphrase(self):
         if not self.exists:
             raise LUKSError("format has not been created")
 
-        blockdev.crypto_luks_remove_key(self.device,
+        blockdev.crypto.luks_remove_key(self.device,
                                         passphrase=self.__passphrase,
                                         key_file=self._key_file)
 
     def escrow(self, directory, backupPassphrase):
         log.debug("escrow: escrowVolume start for %s", self.device)
-        blockdev.crypto_escrow_device(self.device, self.__passphrase, self.escrow_cert,
+        blockdev.crypto.escrow_device(self.device, self.__passphrase, self.escrow_cert,
                                       directory, backupPassphrase)
         log.debug("escrow: escrowVolume done for %s", repr(self.device))
 
diff --git a/blivet/formats/lvmpv.py b/blivet/formats/lvmpv.py
index 069cccf..ca66cfc 100644
--- a/blivet/formats/lvmpv.py
+++ b/blivet/formats/lvmpv.py
@@ -22,7 +22,6 @@
 
 import os
 from gi.repository import BlockDev as blockdev
-from gi.repository import GLib
 
 from ..storage_log import log_method_call
 from parted import PARTITION_LVM
@@ -120,12 +119,12 @@ def create(self, **kwargs):
             # lvm has issues with persistence of metadata, so here comes the
             # hammer...
             DeviceFormat.destroy(self, **kwargs)
-            blockdev.lvm_pvscan(self.device)
-            blockdev.lvm_pvcreate(self.device, data_alignment=self.dataAlignment)
+            blockdev.lvm.pvscan(self.device)
+            blockdev.lvm.pvcreate(self.device, data_alignment=self.dataAlignment)
         except Exception:
             raise
         finally:
-            blockdev.lvm_pvscan(self.device)
+            blockdev.lvm.pvscan(self.device)
 
         self.exists = True
         self.notifyKernel()
@@ -146,11 +145,11 @@ def destroy(self, **kwargs):
 
         # FIXME: verify path exists?
         try:
-            blockdev.lvm_pvremove(self.device)
-        except GLib.GError:
+            blockdev.lvm.pvremove(self.device)
+        except blockdev.LVMError:
             DeviceFormat.destroy(self, **kwargs)
         finally:
-            blockdev.lvm_pvscan(self.device)
+            blockdev.lvm.pvscan(self.device)
 
         self.exists = False
         self.notifyKernel()
diff --git a/blivet/formats/mdraid.py b/blivet/formats/mdraid.py
index 61e0971..5910528 100644
--- a/blivet/formats/mdraid.py
+++ b/blivet/formats/mdraid.py
@@ -89,7 +89,7 @@ def destroy(self, **kwargs):
         if not os.access(self.device, os.W_OK):
             raise MDMemberError("device path does not exist")
 
-        blockdev.md_destroy(self.device)
+        blockdev.md.destroy(self.device)
         self.exists = False
 
     @property
diff --git a/blivet/formats/swap.py b/blivet/formats/swap.py
index e355505..471ff47 100644
--- a/blivet/formats/swap.py
+++ b/blivet/formats/swap.py
@@ -135,7 +135,7 @@ def _setOptions(self, opts):
     @property
     def status(self):
         """ Device status. """
-        return self.exists and blockdev.swap_swapstatus(self.device)
+        return self.exists and blockdev.swap.swapstatus(self.device)
 
     def setup(self, **kwargs):
         """ Activate the formatting.
@@ -159,7 +159,7 @@ def setup(self, **kwargs):
             return
 
         DeviceFormat.setup(self, **kwargs)
-        blockdev.swap_swapon(self.device, priority=self.priority)
+        blockdev.swap.swapon(self.device, priority=self.priority)
 
     def teardown(self):
         """ Close, or tear down, a device. """
@@ -169,7 +169,7 @@ def teardown(self):
             raise SwapSpaceError("format has not been created")
 
         if self.status:
-            blockdev.swap_swapoff(self.device)
+            blockdev.swap.swapoff(self.device)
 
     def create(self, **kwargs):
         """ Write the formatting to the specified block device.
@@ -191,7 +191,7 @@ def create(self, **kwargs):
 
         try:
             DeviceFormat.create(self, **kwargs)
-            blockdev.swap_mkswap(self.device, label=self.label)
+            blockdev.swap.mkswap(self.device, label=self.label)
         except Exception:
             raise
         else:
diff --git a/blivet/osinstall.py b/blivet/osinstall.py
index 83e321d..a2b1895 100644
--- a/blivet/osinstall.py
+++ b/blivet/osinstall.py
@@ -24,7 +24,6 @@
 import os
 import stat
 import time
-from gi.repository import GLib
 from gi.repository import BlockDev as blockdev
 
 from . import util
@@ -529,7 +528,7 @@ def turnOnSwap(self, rootPath=""):
                 try:
                     device.setup()
                     device.format.setup()
-                except (StorageError, GLib.GError) as e:
+                except (StorageError, blockdev.BlockDevError) as e:
                     if errorHandler.cb(e) == ERROR_RAISE:
                         raise
                 else:
@@ -1031,7 +1030,7 @@ def get_containing_device(path, devicetree):
 
     if device_name.startswith("dm-"):
         # have I told you lately that I love you, device-mapper?
-        device_name = blockdev.dm_name_from_node(device_name)
+        device_name = blockdev.dm.name_from_node(device_name)
 
     return devicetree.getDeviceByName(device_name)
 
@@ -1078,7 +1077,7 @@ def writeEscrowPackets(storage):
 
     log.debug("escrow: writeEscrowPackets start")
 
-    backupPassphrase = blockdev.crypto_generate_backup_passphrase()
+    backupPassphrase = blockdev.crypto.generate_backup_passphrase()
 
     try:
         escrowDir = getSysroot() + "/root"
diff --git a/blivet/partitioning.py b/blivet/partitioning.py
index 9c3f47d..16c4ae0 100644
--- a/blivet/partitioning.py
+++ b/blivet/partitioning.py
@@ -1789,7 +1789,7 @@ def _apply_chunk_growth(chunk):
 
         # reduce the size of thin pools by the pad size
         if hasattr(req.device, "lvs"):
-            size -= Size(blockdev.lvm_get_thpool_padding(size, req.device.vg.peSize, included=True))
+            size -= Size(blockdev.lvm.get_thpool_padding(size, req.device.vg.peSize, included=True))
 
         # Base is pe, which means potentially rounded up by as much as
         # pesize-1. As a result, you can't just add the growth to the
@@ -1829,7 +1829,7 @@ def growLVM(storage):
                 lv.req_size = max(lv.req_size, lv.usedSpace)
 
                 # add the required padding to the requested pool size
-                lv.req_size += Size(blockdev.lvm_get_thpool_padding(lv.req_size, vg.peSize))
+                lv.req_size += Size(blockdev.lvm.get_thpool_padding(lv.req_size, vg.peSize))
 
         # establish sizes for the percentage-based requests (which are fixed)
         percentage_based_lvs = [lv for lv in vg.lvs if lv.req_percent]
diff --git a/blivet/util.py b/blivet/util.py
index ecd3693..e614a6a 100644
--- a/blivet/util.py
+++ b/blivet/util.py
@@ -139,7 +139,7 @@ def get_mount_device(mountpoint):
 
     if mount_device and re.match(r'/dev/loop\d+$', mount_device):
         loop_name = os.path.basename(mount_device)
-        mount_device = blockdev.loop_get_backing_file(loop_name)
+        mount_device = blockdev.loop.get_backing_file(loop_name)
         log.debug("found backing file %s for loop device %s", mount_device,
                                                               loop_name)
 
diff --git a/python-blivet.spec b/python-blivet.spec
index 479520b..24efbe3 100644
--- a/python-blivet.spec
+++ b/python-blivet.spec
@@ -16,7 +16,7 @@ Source0: http://github.com/dwlehman/blivet/archive/%{realname}-%{version}.tar.gz
 %define pypartedver 2.5-2
 %define e2fsver 1.41.0
 %define utillinuxver 2.15.1
-%define libblockdevver 0.6
+%define libblockdevver 0.10
 
 BuildArch: noarch
 BuildRequires: gettext
diff --git a/tests/devices_test.py b/tests/devices_test.py
index 4bb065e..2f8f7c2 100644
--- a/tests/devices_test.py
+++ b/tests/devices_test.py
@@ -520,7 +520,7 @@ def testMDRaidArrayDeviceInit(self):
         self.stateCheck(self.dev19,
                         devices=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
                         level=xform(lambda x, m: self.assertEqual(x.number, 1, m)),
-                        mdadmFormatUUID=xform(lambda x, m: self.assertEqual(x, blockdev.md_get_md_uuid(self.dev19.uuid), m)),
+                        mdadmFormatUUID=xform(lambda x, m: self.assertEqual(x, blockdev.md.get_md_uuid(self.dev19.uuid), m)),
                         parents=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
                         uuid=xform(lambda x, m: self.assertEqual(x, self.dev19.uuid, m)))
 


-- 
To view this commit on github, visit https://github.com/rhinstaller/blivet/commit/d960d95635d0e78f7998e3e257420b5c6a87cedb


More information about the anaconda-patches mailing list