Merge branch '3.9-devel'

blivet/blivet.py

@@ -419,7 +419,7 @@ def remove_empty_extended_partitions(self):
             if extended and not logical_parts:
                 log.debug("removing empty extended partition from %s", disk.name)
                 extended_name = device_path_to_name(extended.getDeviceNodeName())
-                extended = self.devicetree.get_device_by_name(extended_name)
+                extended = self.devicetree.get_device_by_device_id(extended_name)
                 self.destroy_device(extended)
 
     def get_free_space(self, disks=None, partitions=None):

blivet/devices/btrfs.py

@@ -226,6 +226,11 @@ def __init__(self, *args, **kwargs):
     def members(self):
         return list(self.parents)
 
+    @property
+    def device_id(self):
+        # BTRFS-<uuid>
+        return "BTRFS-%s" % self.uuid
+
     def _set_level(self, value, data):
         """ Sets a valid level for this device and level type.
 
@@ -599,6 +604,11 @@ def volume(self):
     def container(self):
         return self.volume
 
+    @property
+    def device_id(self):
+        # BTRFS-<volume uuid>-<name>
+        return "BTRFS-%s-%s" % (self.volume.uuid, self.name)
+
     def setup_parents(self, orig=False):
         """ Run setup method of all parent devices. """
         log_method_call(self, name=self.name, orig=orig)

blivet/devices/device.py

@@ -262,6 +262,16 @@ def _set_name(self, value):
                     lambda s, v: s._set_name(v),
                     doc="This device's name")
 
+    @property
+    def device_id(self):
+        """ Unique ID for this device.
+
+            Note: This is an internal identifier in Blivet which is designed to be unique
+                  even for devices with the same name or label.
+                  This ID is persistent between blivet.reset() calls for existing devices.
+        """
+        return self.name
+
     @property
     def isleaf(self):
         """ True if no other device depends on this one. """

blivet/devices/dm.py

@@ -99,6 +99,11 @@ def map_name(self):
         """ This device's device-mapper map name """
         return self.name
 
+    @property
+    def device_id(self):
+        # DM-<name>
+        return "DM-%s" % self.name
+
     @property
     def status(self):
         try:

blivet/devices/luks.py

@@ -70,6 +70,11 @@ def raw_device(self):
             return self.parents[0].parents[0]
         return self.parents[0]
 
+    @property
+    def device_id(self):
+        # LUKS-<name>
+        return "LUKS-%s" % self.name
+
     def _get_size(self):
         if not self.exists:
             size = self.raw_device.size - crypto.LUKS_METADATA_SIZE

blivet/devices/lvm.py

@@ -208,6 +208,11 @@ def path(self):
         """ Device node representing this device. """
         return "%s/%s" % (self._dev_dir, self.map_name)
 
+    @property
+    def device_id(self):
+        # LVM-<vgname>
+        return "LVM-%s" % self.name
+
     def update_sysfs_path(self):
         """ Update this device's sysfs path. """
         log_method_call(self, self.name, status=self.status)
@@ -1176,6 +1181,11 @@ def lvname(self):
         """ The LV's name (not including VG name). """
         return self._name
 
+    @property
+    def device_id(self):
+        # LVM-<vgname>-<lvname>
+        return "LVM-%s" % self.name
+
     @property
     def complete(self):
         """ Test if vg exits and if it has all pvs. """

blivet/devices/md.py

@@ -150,6 +150,10 @@ def __init__(self, name, level=None, major=None, minor=None, size=None,
         if self.parents and self.parents[0].type == "mdcontainer" and self.type != "mdbiosraidarray":
             raise errors.DeviceError("A device with mdcontainer member must be mdbiosraidarray.")
 
+    @property
+    def device_id(self):
+        return "MDRAID-%s" % self.name
+
     @property
     def mdadm_format_uuid(self):
         """ This array's UUID, formatted for external use.

blivet/devices/stratis.py

@@ -58,6 +58,11 @@ def __init__(self, *args, **kwargs):
 
         super(StratisPoolDevice, self).__init__(*args, **kwargs)
 
+    @property
+    def device_id(self):
+        # STRATIS-<pool name>
+        return "STRATIS-%s" % self.name
+
     @property
     def blockdevs(self):
         """ A list of this pool block devices """
@@ -216,6 +221,11 @@ def fsname(self):
         """ The Stratis filesystem name (not including pool name). """
         return self._name
 
+    @property
+    def device_id(self):
+        # STRATIS-<pool name>/<fsname>
+        return "STRATIS-%s/%s" % (self.pool.name, self.fsname)
+
     @property
     def pool(self):
         if not self.parents:

blivet/devicetree.py

@@ -585,7 +585,7 @@ def get_device_by_path(self, path, incomplete=False, hidden=False):
         return result
 
     def get_device_by_id(self, id_num, incomplete=False, hidden=False):
-        """ Return a device with specified device id.
+        """ Return a device with specified id.
 
             :param int id_num: the id to look for
             :param bool incomplete: include incomplete devices in search
@@ -599,6 +599,21 @@ def get_device_by_id(self, id_num, incomplete=False, hidden=False):
         log_method_return(self, result)
         return result
 
+    def get_device_by_device_id(self, device_id, incomplete=False, hidden=False):
+        """ Return a device with specified device id.
+
+            :param str device id: the device id to look for
+            :param bool incomplete: include incomplete devices in search
+            :param bool hidden: include hidden devices in search
+            :returns: the first matching device found
+            :rtype: :class:`~.devices.Device`
+        """
+        log_method_call(self, device_id=device_id, incomplete=incomplete, hidden=hidden)
+        devices = self._filter_devices(incomplete=incomplete, hidden=hidden)
+        result = six.next((d for d in devices if d.device_id == device_id), None)
+        log_method_return(self, result)
+        return result
+
     def resolve_device(self, devspec, blkid_tab=None, crypt_tab=None, options=None, subvolspec=None):
         """ Return the device matching the provided device specification.
 

blivet/populator/helpers/luks.py

@@ -121,7 +121,7 @@ def run(self):
             return
 
         # look up or create the mapped device
-        if not self._devicetree.get_device_by_name(self.device.format.map_name):
+        if not self._devicetree.get_device_by_device_id("LUKS-" + self.device.format.map_name):
             passphrase = luks_data.luks_devs.get(self.device.format.uuid)
             if self.device.format.configured:
                 pass

blivet/populator/helpers/lvm.py

@@ -53,21 +53,23 @@ def run(self):
         log_method_call(self, name=name)
 
         vg_name = udev.device_get_lv_vg_name(self.data)
-        device = self._devicetree.get_device_by_name(vg_name, hidden=True)
+        vg_id = "LVM-%s" % vg_name
+        device = self._devicetree.get_device_by_device_id(vg_id, hidden=True)
         if device and not isinstance(device, LVMVolumeGroupDevice):
-            log.warning("found non-vg device with name %s", vg_name)
+            log.warning("found non-vg device with device id %s", vg_id)
             device = None
 
         self._devicetree._add_parent_devices(self.data)
 
         # LVM provides no means to resolve conflicts caused by duplicated VG
         # names, so we're just being optimistic here. Woo!
         vg_name = udev.device_get_lv_vg_name(self.data)
-        vg_device = self._devicetree.get_device_by_name(vg_name)
+        vg_id = "LVM-%s" % vg_name
+        vg_device = self._devicetree.get_device_by_device_id(vg_id)
         if not vg_device:
             log.error("failed to find vg '%s' after scanning pvs", vg_name)
 
-        return self._devicetree.get_device_by_name(name)
+        return self._devicetree.get_device_by_device_id("LVM-" + name)
 
     def _handle_rename(self):
         name = self.data.get("DM_LV_NAME")
@@ -161,12 +163,13 @@ def add_required_lv(name, msg):
                 :raises: :class:`~.errors.DeviceTreeError` on failure
 
             """
-            vol = self._devicetree.get_device_by_name(name)
+            vgid = "LVM-" + name
+            vol = self._devicetree.get_device_by_device_id(vgid)
             if vol is None:
                 new_lv = add_lv(lv_info[name])
                 if new_lv:
                     all_lvs.append(new_lv)
-                vol = self._devicetree.get_device_by_name(name)
+                vol = self._devicetree.get_device_by_device_id(vgid)
 
                 if vol is None:
                     log.error("%s: %s", msg, name)
@@ -184,7 +187,7 @@ def add_lv(lv):
             lv_kwargs = {}
             name = "%s-%s" % (vg_name, lv_name)
 
-            lv_device = self._devicetree.get_device_by_name(name)
+            lv_device = self._devicetree.get_device_by_device_id("LVM-" + name)
             if lv_device is not None:
                 # some lvs may have been added on demand below
                 log.debug("already added %s", name)
@@ -215,7 +218,7 @@ def add_lv(lv):
                     origin_device_name = "%s-%s" % (vg_name, origin_name)
                     add_required_lv(origin_device_name,
                                     "failed to locate origin lv")
-                    origin = self._devicetree.get_device_by_name(origin_device_name)
+                    origin = self._devicetree.get_device_by_device_id("LVM-" + origin_device_name)
 
                 lv_kwargs["origin"] = origin
             elif lv_attr[0] in 'IrielTCoD' and lv_name.endswith(']'):
@@ -238,10 +241,10 @@ def add_lv(lv):
                 if origin_name:
                     origin_device_name = "%s-%s" % (vg_name, origin_name)
                     add_required_lv(origin_device_name, "failed to locate origin lv")
-                    origin = self._devicetree.get_device_by_name(origin_device_name)
+                    origin = self._devicetree.get_device_by_device_id("LVM-" + origin_device_name)
                     lv_kwargs["origin"] = origin
 
-                lv_parents = [self._devicetree.get_device_by_name(pool_device_name)]
+                lv_parents = [self._devicetree.get_device_by_device_id("LVM-" + pool_device_name)]
             elif lv_attr[0] == 'd':
                 # vdo pool
                 if BLOCKDEV_LVM_PLUGIN_VDO.available:
@@ -259,7 +262,7 @@ def add_lv(lv):
                 pool_device_name = "%s-%s" % (vg_name, pool_name)
                 add_required_lv(pool_device_name, "failed to look up VDO pool")
 
-                lv_parents = [self._devicetree.get_device_by_name(pool_device_name)]
+                lv_parents = [self._devicetree.get_device_by_device_id("LVM-" + pool_device_name)]
             elif lv_name.endswith(']'):
                 # unrecognized Internal LVM2 device
                 return
@@ -385,7 +388,7 @@ def _add_vg_device(self):
             vg_device.parents.append(self.device)
             callbacks.parent_added(device=vg_device, parent=self.device)
         elif vg_device is None:
-            same_name = self._devicetree.get_device_by_name(vg_name)
+            same_name = self._devicetree.get_device_by_device_id("LVM-" + vg_name)
             if isinstance(same_name, LVMVolumeGroupDevice):
                 raise DuplicateVGError("multiple LVM volume groups with the same name (%s)" % vg_name)
 

blivet/populator/helpers/mdraid.py

@@ -58,7 +58,7 @@ def run(self):
             return None
 
         # try to get the device again now that we've got all the parents
-        device = self._devicetree.get_device_by_name(name, incomplete=flags.allow_imperfect_devices)
+        device = self._devicetree.get_device_by_device_id("MDRAID-" + name, incomplete=flags.allow_imperfect_devices)
 
         if device is None:
             try:
@@ -175,7 +175,7 @@ def run(self):
                     md_name = md_name[2:]
 
                 if md_name:
-                    array = self._devicetree.get_device_by_name(md_name, incomplete=True)
+                    array = self._devicetree.get_device_by_device_id("MDRAID-" + md_name, incomplete=True)
                     if array and array.uuid != md_uuid:
                         log.error("found multiple devices with the name %s", md_name)
 

blivet/populator/helpers/partition.py

@@ -46,21 +46,21 @@ def run(self):
         log_method_call(self, name=name)
         sysfs_path = udev.device_get_sysfs_path(self.data)
 
-        device = self._devicetree.get_device_by_name(name)
+        device = self._devicetree.get_device_by_device_id(name)
         if device:
             return device
 
         disk = None
         disk_name = udev.device_get_partition_disk(self.data)
         if disk_name:
-            disk = self._devicetree.get_device_by_name(disk_name)
+            disk = self._devicetree.get_device_by_device_id(disk_name)
             if disk is None:
                 # create a device instance for the disk
                 disk_info = six.next((i for i in udev.get_devices()
                                       if udev.device_get_name(i) == disk_name), None)
                 if disk_info is not None:
                     self._devicetree.handle_device(disk_info)
-                    disk = self._devicetree.get_device_by_name(disk_name)
+                    disk = self._devicetree.get_device_by_device_id(disk_name)
 
         if disk is None:
             # if the disk is still not in the tree something has gone wrong

blivet/populator/populator.py

@@ -192,7 +192,7 @@ def _handle_degraded_md(self, info, device):
         if md_name is None:
             log.warning("No name for possibly degraded md array.")
         else:
-            device = self.get_device_by_name(md_name, incomplete=flags.allow_imperfect_devices)
+            device = self.get_device_by_device_id("MDRAID-" + md_name, incomplete=flags.allow_imperfect_devices)
 
         if device and not isinstance(device, MDRaidArrayDevice):
             log.warning("Found device %s, but it turns out not be an md array device after all.", device.name)