Group DEVICE_TYPE_* constants in an Enum

For other code using blivet, it is useful to know all of the device types that blivet supports.
This is better accomplished by grouping all of the device type constants into an Enum type so that
the consuming code can import just the Enum and then retrieve all the values it needs from there.

This code makes the Enum the canonical source for that information but also recreates the variables
that have existed up to now from the new Enum.

Author: abadger

blivet/blivet.py

@@ -542,7 +542,7 @@ def new_mdarray(self, *args, **kwargs):
 
         name = kwargs.pop("name", None)
         if name:
-            safe_name = self.safe_device_name(name, devicefactory.DEVICE_TYPE_MD)
+            safe_name = self.safe_device_name(name, devicefactory.DeviceTypes.MD)
             if safe_name != name:
                 log.warning("using '%s' instead of specified name '%s'",
                             safe_name, name)
@@ -575,13 +575,13 @@ def new_vg(self, *args, **kwargs):
 
         name = kwargs.pop("name", None)
         if name:
-            safe_name = self.safe_device_name(name, devicefactory.DEVICE_TYPE_LVM)
+            safe_name = self.safe_device_name(name, devicefactory.DeviceTypes.LVM)
             if safe_name != name:
                 log.warning("using '%s' instead of specified name '%s'",
                             safe_name, name)
                 name = safe_name
         else:
-            name = self.suggest_container_name(container_type=devicefactory.DEVICE_TYPE_LVM)
+            name = self.suggest_container_name(container_type=devicefactory.DeviceTypes.LVM)
 
         if name in self.names:
             raise ValueError("name '%s' is already in use" % name)
@@ -659,9 +659,9 @@ def new_lv(self, *args, **kwargs):
         name = kwargs.pop("name", None)
         if name:
             # make sure the specified name is sensible
-            safe_vg_name = self.safe_device_name(vg.name, devicefactory.DEVICE_TYPE_LVM)
+            safe_vg_name = self.safe_device_name(vg.name, devicefactory.DeviceTypes.LVM)
             full_name = "%s-%s" % (safe_vg_name, name)
-            safe_name = self.safe_device_name(full_name, devicefactory.DEVICE_TYPE_LVM)
+            safe_name = self.safe_device_name(full_name, devicefactory.DeviceTypes.LVM)
             if safe_name != full_name:
                 new_name = safe_name[len(safe_vg_name) + 1:]
                 log.warning("using '%s' instead of specified name '%s'",
@@ -772,7 +772,7 @@ def new_btrfs(self, *args, **kwargs):
             dev_class = BTRFSVolumeDevice
             # set up the volume label, using hostname if necessary
             if not name:
-                name = self.suggest_container_name(container_type=devicefactory.DEVICE_TYPE_BTRFS)
+                name = self.suggest_container_name(container_type=devicefactory.DeviceTypes.BTRFS)
             if "label" not in fmt_args:
                 fmt_args["label"] = name
             fmt_args["subvolspec"] = MAIN_VOLUME_ID
@@ -823,13 +823,13 @@ def new_stratis_pool(self, *args, **kwargs):
 
         name = kwargs.pop("name", None)
         if name:
-            safe_name = self.safe_device_name(name, devicefactory.DEVICE_TYPE_STRATIS)
+            safe_name = self.safe_device_name(name, devicefactory.DeviceTypes.STRATIS)
             if safe_name != name:
                 log.warning("using '%s' instead of specified name '%s'",
                             safe_name, name)
                 name = safe_name
         else:
-            name = self.suggest_container_name(container_type=devicefactory.DEVICE_TYPE_STRATIS)
+            name = self.suggest_container_name(container_type=devicefactory.DeviceTypes.STRATIS)
 
         if name in self.names:
             raise ValueError("name '%s' is already in use" % name)
@@ -857,7 +857,7 @@ def new_stratis_filesystem(self, *args, **kwargs):
         if name:
             # make sure the specified name is sensible
             full_name = "%s/%s" % (pool.name, name)
-            safe_name = self.safe_device_name(full_name, devicefactory.DEVICE_TYPE_STRATIS)
+            safe_name = self.safe_device_name(full_name, devicefactory.DeviceTypes.STRATIS)
             if safe_name != full_name:
                 new_name = safe_name[len(pool.name) + 1:]
                 log.warning("using '%s' instead of specified name '%s'",
@@ -866,7 +866,7 @@ def new_stratis_filesystem(self, *args, **kwargs):
         else:
             name = self.suggest_device_name(parent=pool,
                                             mountpoint=mountpoint,
-                                            device_type=devicefactory.DEVICE_TYPE_STRATIS)
+                                            device_type=devicefactory.DeviceTypes.STRATIS)
 
         if "%s/%s" % (pool.name, name) in self.names:
             raise ValueError("name '%s' is already in use" % name)
@@ -1019,13 +1019,13 @@ def safe_device_name(self, name, device_type=None):
             device name limits.
         """
 
-        if device_type in (devicefactory.DEVICE_TYPE_LVM, devicefactory.DEVICE_TYPE_LVM_THINP):
+        if device_type in (devicefactory.DeviceTypes.LVM, devicefactory.DeviceTypes.LVM_THINP):
             allowed = devicelibs.lvm.safe_name_characters
-        elif device_type == devicefactory.DEVICE_TYPE_MD:
+        elif device_type == devicefactory.DeviceTypes.MD:
             allowed = devicelibs.mdraid.safe_name_characters
-        elif device_type == devicefactory.DEVICE_TYPE_BTRFS:
+        elif device_type == devicefactory.DeviceTypes.BTRFS:
             allowed = devicelibs.btrfs.safe_name_characters
-        elif device_type == devicefactory.DEVICE_TYPE_STRATIS:
+        elif device_type == devicefactory.DeviceTypes.STRATIS:
             allowed = devicelibs.stratis.safe_name_characters
         else:
             allowed = "0-9a-zA-Z._-"
@@ -1053,7 +1053,7 @@ def safe_device_name(self, name, device_type=None):
     def unique_device_name(self, name, parent=None, name_set=True, device_type=None):
         """ Turn given name into a unique one by adding numeric suffix to it """
 
-        if device_type == devicefactory.DEVICE_TYPE_STRATIS:
+        if device_type == devicefactory.DeviceTypes.STRATIS:
             parent_separator = "/"
         else:
             parent_separator = "-"
@@ -1127,7 +1127,7 @@ def suggest_device_name(self, parent=None, swap=None,
 
         name = self.safe_device_name(prefix + body, device_type)
 
-        if device_type == devicefactory.DEVICE_TYPE_STRATIS:
+        if device_type == devicefactory.DeviceTypes.STRATIS:
             parent_separator = "/"
         else:
             parent_separator = "-"
@@ -1281,11 +1281,11 @@ def get_fstype(self, mountpoint=None):
 
         return fstype
 
-    def factory_device(self, device_type=devicefactory.DEVICE_TYPE_LVM, **kwargs):
+    def factory_device(self, device_type=devicefactory.DeviceTypes.LVM, **kwargs):
         """ Schedule creation of a device based on a top-down specification.
 
             :param device_type: device type constant
-            :type device_type: int (:const:`~.devicefactory.DEVICE_TYPE_*`)
+            :type device_type: int (:const:`~.devicefactory.DeviceTypes.*`)
             :returns: the newly configured device
             :rtype: :class:`~.devices.StorageDevice`
 
@@ -1305,8 +1305,8 @@ def factory_device(self, device_type=devicefactory.DEVICE_TYPE_LVM, **kwargs):
                 kwargs["mountpoint"] = None
 
         if kwargs["fstype"] == "swap" and \
-           device_type == devicefactory.DEVICE_TYPE_BTRFS:
-            device_type = devicefactory.DEVICE_TYPE_PARTITION
+           device_type == devicefactory.DeviceTypes.BTRFS:
+            device_type = devicefactory.DeviceTypes.PARTITION
 
         factory = devicefactory.get_device_factory(self, device_type=device_type, **kwargs)
 

blivet/dbus/blivet.py

@@ -23,8 +23,7 @@
 
 from .. import Blivet
 from ..callbacks import callbacks
-from ..devicefactory import DEVICE_TYPE_PARTITION, DEVICE_TYPE_LVM, DEVICE_TYPE_LVM_THINP
-from ..devicefactory import DEVICE_TYPE_MD, DEVICE_TYPE_BTRFS
+from ..devicefactory import DeviceTypes
 from ..errors import StorageError
 from ..size import Size
 from ..util import ObjectID
@@ -79,11 +78,11 @@ def interface(self):
     @property
     def properties(self):
         props = {"Devices": self.ListDevices(),
-                 "DEVICE_TYPE_LVM": DEVICE_TYPE_LVM,
-                 "DEVICE_TYPE_LVM_THINP": DEVICE_TYPE_LVM_THINP,
-                 "DEVICE_TYPE_PARTITION": DEVICE_TYPE_PARTITION,
-                 "DEVICE_TYPE_MD": DEVICE_TYPE_MD,
-                 "DEVICE_TYPE_BTRFS": DEVICE_TYPE_BTRFS}
+                 "DEVICE_TYPE_LVM": DeviceTypes.LVM,
+                 "DEVICE_TYPE_LVM_THINP": DeviceTypes.LVM_THINP,
+                 "DEVICE_TYPE_PARTITION": DeviceTypes.PARTITION,
+                 "DEVICE_TYPE_MD": DeviceTypes.MD,
+                 "DEVICE_TYPE_BTRFS": DeviceTypes.BTRFS}
         return props
 
     def _device_removed(self, device, keep=True):

blivet/devicefactory.py

@@ -20,6 +20,8 @@
 # Red Hat Author(s): David Lehman <[email protected]>
 #
 
+from enum import IntEnum, unique
+
 from .storage_log import log_method_call
 from .errors import DeviceFactoryError, StorageError
 from .devices import BTRFSDevice, DiskDevice
@@ -52,14 +54,36 @@
 SIZE_POLICY_MAX = -1
 SIZE_POLICY_AUTO = 0
 
-DEVICE_TYPE_LVM = 0
-DEVICE_TYPE_MD = 1
-DEVICE_TYPE_PARTITION = 2
-DEVICE_TYPE_BTRFS = 3
-DEVICE_TYPE_DISK = 4
-DEVICE_TYPE_LVM_THINP = 5
-DEVICE_TYPE_LVM_VDO = 6
-DEVICE_TYPE_STRATIS = 7
+
+@unique
+class DeviceTypes(IntEnum):
+    """
+    Types of devices supported by `blivet.devicefactory`
+
+    .. note::
+        Subclasses IntEnum so that code which wants to work with blivet can create their own
+        Enum based on this and have the members be interoperable. (The members of IntEnums
+        compare based on the interger value of the member.  The members of normal Enums compare
+        based on the identity of the member so they are never equal to members of other Enums,
+        even when their values are the same.  The members of IntEnums compare based on the
+        integer `value` of the member so they can compare True with the member of a different
+        Enum's member when they have the same value.
+    """
+
+    LVM = 0
+    MD = 1
+    PARTITION = 2
+    BTRFS = 3
+    DISK = 4
+    LVM_THINP = 5
+    LVM_VDO = 6
+    STRATIS = 7
+
+
+# Backwards compat. Device types could only be accessed via these individual
+# variable names through 3.12.1
+for dt_pair in DeviceTypes:
+    globals()['DEVICE_TYPE_%s' % dt_pair.name] = dt_pair.value
 
 
 def is_supported_device_type(device_type):
@@ -72,19 +96,19 @@ def is_supported_device_type(device_type):
         :rtype: bool
     """
     devices = []
-    if device_type == DEVICE_TYPE_BTRFS:
+    if device_type == DeviceTypes.BTRFS:
         devices = [BTRFSDevice]
-    elif device_type == DEVICE_TYPE_DISK:
+    elif device_type == DeviceTypes.DISK:
         devices = [DiskDevice]
-    elif device_type in (DEVICE_TYPE_LVM, DEVICE_TYPE_LVM_THINP):
+    elif device_type in (DeviceTypes.LVM, DeviceTypes.LVM_THINP):
         devices = [LVMLogicalVolumeDevice]
-    elif device_type == DEVICE_TYPE_PARTITION:
+    elif device_type == DeviceTypes.PARTITION:
         devices = [PartitionDevice]
-    elif device_type == DEVICE_TYPE_MD:
+    elif device_type == DeviceTypes.MD:
         devices = [MDRaidArrayDevice]
-    elif device_type == DEVICE_TYPE_LVM_VDO:
+    elif device_type == DeviceTypes.LVM_VDO:
         devices = [LVMLogicalVolumeDevice, LVMVDOPoolMixin, LVMVDOLogicalVolumeMixin]
-    elif device_type == DEVICE_TYPE_STRATIS:
+    elif device_type == DeviceTypes.STRATIS:
         devices = [StratisFilesystemDevice, StratisPoolDevice]
 
     return not any(c.unavailable_type_dependencies() for c in devices)
@@ -100,11 +124,11 @@ def get_supported_raid_levels(device_type):
         :rtype: set of :class:`~.devicelibs.raid.RAIDLevel`
     """
     pkg = None
-    if device_type == DEVICE_TYPE_BTRFS:
+    if device_type == DeviceTypes.BTRFS:
         pkg = btrfs
-    elif device_type in (DEVICE_TYPE_LVM, DEVICE_TYPE_LVM_THINP, DEVICE_TYPE_LVM_VDO):
+    elif device_type in (DeviceTypes.LVM, DeviceTypes.LVM_THINP, DeviceTypes.LVM_VDO):
         pkg = lvm
-    elif device_type == DEVICE_TYPE_MD:
+    elif device_type == DeviceTypes.MD:
         pkg = mdraid
 
     if pkg and all(d.available for d in pkg.EXTERNAL_DEPENDENCIES):
@@ -118,36 +142,36 @@ def get_device_type(device):
     # an empty pool after removing the last thin lv, so the only thing we'll be
     # doing with the factory is adjusting the vg to account for the pool's
     # removal
-    device_types = {"partition": DEVICE_TYPE_PARTITION,
-                    "lvmlv": DEVICE_TYPE_LVM,
-                    "lvmthinlv": DEVICE_TYPE_LVM_THINP,
-                    "lvmthinpool": DEVICE_TYPE_LVM,
-                    "lvmvdolv": DEVICE_TYPE_LVM_VDO,
-                    "lvmvdopool": DEVICE_TYPE_LVM,
-                    "btrfs subvolume": DEVICE_TYPE_BTRFS,
-                    "btrfs volume": DEVICE_TYPE_BTRFS,
-                    "mdarray": DEVICE_TYPE_MD,
-                    "stratis filesystem": DEVICE_TYPE_STRATIS}
+    device_types = {"partition": DeviceTypes.PARTITION,
+                    "lvmlv": DeviceTypes.LVM,
+                    "lvmthinlv": DeviceTypes.LVM_THINP,
+                    "lvmthinpool": DeviceTypes.LVM,
+                    "lvmvdolv": DeviceTypes.LVM_VDO,
+                    "lvmvdopool": DeviceTypes.LVM,
+                    "btrfs subvolume": DeviceTypes.BTRFS,
+                    "btrfs volume": DeviceTypes.BTRFS,
+                    "mdarray": DeviceTypes.MD,
+                    "stratis filesystem": DeviceTypes.STRATIS}
 
     use_dev = device.raw_device
     if use_dev.is_disk:
-        device_type = DEVICE_TYPE_DISK
+        device_type = DeviceTypes.DISK
     else:
         device_type = device_types.get(use_dev.type)
 
     return device_type
 
 
-def get_device_factory(blivet, device_type=DEVICE_TYPE_LVM, **kwargs):
+def get_device_factory(blivet, device_type=DeviceTypes.LVM, **kwargs):
     """ Return a suitable DeviceFactory instance for device_type. """
-    class_table = {DEVICE_TYPE_LVM: LVMFactory,
-                   DEVICE_TYPE_BTRFS: BTRFSFactory,
-                   DEVICE_TYPE_PARTITION: PartitionFactory,
-                   DEVICE_TYPE_MD: MDFactory,
-                   DEVICE_TYPE_LVM_THINP: LVMThinPFactory,
-                   DEVICE_TYPE_LVM_VDO: LVMVDOFactory,
-                   DEVICE_TYPE_DISK: DeviceFactory,
-                   DEVICE_TYPE_STRATIS: StratisFactory}
+    class_table = {DeviceTypes.LVM: LVMFactory,
+                   DeviceTypes.BTRFS: BTRFSFactory,
+                   DeviceTypes.PARTITION: PartitionFactory,
+                   DeviceTypes.MD: MDFactory,
+                   DeviceTypes.LVM_THINP: LVMThinPFactory,
+                   DeviceTypes.LVM_VDO: LVMVDOFactory,
+                   DeviceTypes.DISK: DeviceFactory,
+                   DeviceTypes.STRATIS: StratisFactory}
 
     factory_class = class_table[device_type]
     log.debug("instantiating %s: %s, %s, %s", factory_class,
@@ -1526,7 +1550,7 @@ def _set_name(self):
                 mountpoint=self.mountpoint)
 
         lvname = "%s-%s" % (self.vg.name, self.device_name)
-        safe_new_name = self.storage.safe_device_name(lvname, DEVICE_TYPE_LVM)
+        safe_new_name = self.storage.safe_device_name(lvname, DeviceTypes.LVM)
         if self.device.name != safe_new_name:
             if safe_new_name in self.storage.names:
                 log.error("not renaming '%s' to in-use name '%s'",
@@ -2224,7 +2248,7 @@ def _set_name(self):
                 mountpoint=self.mountpoint)
 
         fsname = "%s/%s" % (self.pool.name, self.device_name)
-        safe_new_name = self.storage.safe_device_name(fsname, DEVICE_TYPE_STRATIS)
+        safe_new_name = self.storage.safe_device_name(fsname, DeviceTypes.STRATIS)
         if self.device.name != safe_new_name:
             if safe_new_name in self.storage.names:
                 log.error("not renaming '%s' to in-use name '%s'",

doc/api/blivet.rst

@@ -85,13 +85,13 @@ blivet
 
 * :mod:`blivet.devicefactory`
     * :meth:`~blivet.devicefactory.DeviceFactory.configure`
-    * :const:`~blivet.devicefactory.DEVICE_TYPE_MD`
-    * :const:`~blivet.devicefactory.DEVICE_TYPE_PARTITION`
-    * :const:`~blivet.devicefactory.DEVICE_TYPE_BTRFS`
-    * :const:`~blivet.devicefactory.DEVICE_TYPE_DISK`
-    * :const:`~blivet.devicefactory.DEVICE_TYPE_LVM_THINP`
-    * :const:`~blivet.devicefactory.DEVICE_TYPE_LVM_VDO`
-    * :const:`~blivet.devicefactory.DEVICE_TYPE_STRATIS`
+    * :const:`~blivet.devicefactory.DeviceTypes.MD`
+    * :const:`~blivet.devicefactory.DeviceTypes.PARTITION`
+    * :const:`~blivet.devicefactory.DeviceTypes.BTRFS`
+    * :const:`~blivet.devicefactory.DeviceTypes.DISK`
+    * :const:`~blivet.devicefactory.DeviceTypes.LVM_THINP`
+    * :const:`~blivet.devicefactory.DeviceTypes.LVM_VDO`
+    * :const:`~blivet.devicefactory.DeviceTypes.STRATIS`
     * :func:`~blivet.devicefactory.is_supported_device_type`
     * :func:`~blivet.devicefactory.get_device_factory`
     * :func:`~blivet.devicefactory.get_device_type`