Improve block device enumeration and availability detection

Replace the BlockDeviceInfo TypedDict and the per-call disk_is_available()
check with a dataclass that includes availability as a field, determined once
at scan time using mountpoint, mdadm, LVM, and ZFS checks. Extend enumeration
to cover mdadm arrays and multipath devices in addition to local disks. Update
all callers to use attribute access instead of dict subscript.

Signed-off-by: Gaëtan Lehmann <gaetan.lehmann@vates.tech>

Author: glehmann

conftest.py

@@ -415,12 +415,12 @@ def _host_disks(host: Host, hosts_cli_disks: list[DiskDevName] | None) -> Iterab
         # check all disks in --disks=host:... exist
         for cli_disk in hosts_cli_disks:
             for disk in host_disks:
-                if disk['name'] == cli_disk:
+                if disk.name == cli_disk:
                     yield disk
                     break # names are unique, don't expect another one
             else:
                 raise Exception(f"no {cli_disk!r} disk on host {host.hostname_or_ip}, "
-                                f"has {','.join(disk['name'] for disk in host_disks)}")
+                                f"has {','.join(disk.name for disk in host_disks)}")
 
     ret = {host: list(_host_disks(host, cli_disks.get(host.hostname_or_ip)))
            for host in pools_hosts_by_name_or_ip.values()
@@ -433,7 +433,7 @@ def unused_512B_disks(disks: dict[Host, list[Host.BlockDeviceInfo]]
                       ) -> dict[Host, list[Host.BlockDeviceInfo]]:
     """Dict identifying names of all 512-bytes-blocks disks for on all hosts of first pool."""
     ret = {host: [disk for disk in host_disks
-                  if disk["log-sec"] == "512" and host.disk_is_available(disk["name"])]
+                  if disk.log_sec == 512 and disk.available]
            for host, host_disks in disks.items()
            }
     logging.debug("available disks collected: %s", {host.hostname_or_ip: value for host, value in ret.items()})
@@ -444,7 +444,7 @@ def unused_4k_disks(disks: dict[Host, list[Host.BlockDeviceInfo]]
                     ) -> dict[Host, list[Host.BlockDeviceInfo]]:
     """Dict identifying names of all 4K-blocks disks for on all hosts of first pool."""
     ret = {host: [disk for disk in host_disks
-                  if disk["log-sec"] == "4096" and host.disk_is_available(disk["name"])]
+                  if disk.log_sec == 4096 and disk.available]
            for host, host_disks in disks.items()
            }
     logging.debug("available 4k disks collected: %s", {host.hostname_or_ip: value for host, value in ret.items()})

lib/host.py

@@ -7,12 +7,12 @@
 import subprocess
 import tempfile
 import uuid
+from dataclasses import dataclass
 
 from packaging import version
 
 import lib.commands as commands
 from lib.common import (
-    DiskDevName,
     _param_add,
     _param_clear,
     _param_get,
@@ -31,7 +31,7 @@
 from lib.vm import VM
 from lib.xo import xo_cli, xo_object_exists
 
-from typing import TYPE_CHECKING, Literal, TypedDict, overload
+from typing import TYPE_CHECKING, Literal, overload
 
 if TYPE_CHECKING:
     from lib.pool import Pool
@@ -55,14 +55,14 @@ class Host:
     pool: "Pool"
 
     # Data extraction is automatic, no conversion from str is done.
-    BlockDeviceInfo = TypedDict('BlockDeviceInfo', {"name": str,
-                                                    "kname": str,
-                                                    "pkname": str,
-                                                    "size": str,
-                                                    "log-sec": str,
-                                                    "type": str,
-                                                    })
-    BLOCK_DEVICES_FIELDS = ','.join(k.upper() for k in BlockDeviceInfo.__annotations__)
+    @dataclass
+    class BlockDeviceInfo:
+        name: str       # short kernel name: "sda", "md0", "dm-3"
+        path: str       # full device path: "/dev/sda", "/dev/md/myarray", "/dev/mapper/mpathb"
+        size: int       # bytes
+        log_sec: int    # logical sector size; 0 for md/mpath
+        type: str       # "disk", "md", "mpath"
+        available: bool # not mounted, not member of md/lvm/mpath/zfs
 
     block_devices_info: list[BlockDeviceInfo]
 
@@ -669,48 +669,121 @@ def management_pif(self) -> PIF:
 
     def rescan_block_devices_info(self) -> None:
         """
-        Initalize static informations about the disks.
+        Initialize information about block devices: local disks, mdadm arrays, and multipath devices.
 
-        Despite those being static, it can be necessary to rescan,
+        Despite those being mostly static, it can be necessary to rescan,
         when we test how XCP-ng reacts to changes of hardware (or
         reconfiguration of device blocksize), or after a reboot.
         """
-        output_string = self.ssh(
-            f'lsblk --pairs --bytes -I 8,259 --output {Host.BLOCK_DEVICES_FIELDS}'
-        )  # limit to: sd, blkext
-
-        self.block_devices_info = [
-            Host.BlockDeviceInfo({key.lower(): value.strip('"') # type: ignore[misc]
-                                  for key, value in re.findall(r'(\S+)=(".*?"|\S+)', line)})
-            for line in output_string.strip().splitlines()
-        ]
-        logging.debug("blockdevs found: %s", [disk["name"] for disk in self.block_devices_info])
+        # Majors: 8=SCSI/SATA, 65-71,128-135=SCSI extended, 259=NVMe/blkext
+        LOCAL_MAJORS = '8,65,66,67,68,69,70,71,128,129,130,131,132,133,134,135,259'
+        LSBLK_FIELDS = 'NAME,KNAME,PKNAME,SIZE,LOG-SEC,TYPE'
+
+        devices: list[Host.BlockDeviceInfo] = []
+
+        # --- Local block devices ---
+        raw = self.ssh(f'lsblk --pairs --bytes -I {LOCAL_MAJORS} --output {LSBLK_FIELDS}')
+        rows = [
+            {key.lower(): val.strip('"')
+             for key, val in re.findall(r'(\S+)=(".*?"|\S+)', line)}
+            for line in raw.strip().splitlines()
+        ] if raw.strip() else []
+
+        # build set of device names that are parents of something (have children)
+        pknames = {r['pkname'] for r in rows if r.get('pkname')}
+        # leaf disks: no parent, not a partition, and not themselves parents
+        for r in rows:
+            if r.get('pkname') or r.get('type') == 'part' or r['kname'] in pknames:
+                continue
+            disk_name = r['name']
+            dev = f'/dev/{disk_name}'
+            available = self._disk_is_available_local(disk_name)
+            devices.append(Host.BlockDeviceInfo(
+                name=disk_name,
+                path=dev,
+                size=int(r['size']),
+                log_sec=int(r['log-sec']),
+                type='disk',
+                available=available,
+            ))
+
+        # --- mdadm arrays ---
+        # lsblk -I 9 does not reliably enumerate md devices on all kernels/versions,
+        # so enumerate via /sys/block/md* and query each device individually.
+        md_names = self.ssh('ls /sys/block/ 2>/dev/null | grep -E "^md[0-9]" || true').strip().splitlines()
+        for md_name in md_names:
+            md_name = md_name.strip()
+            if not md_name:
+                continue
+            raw = self.ssh(
+                f'lsblk --pairs --bytes /dev/{md_name} --output NAME,SIZE,LOG-SEC,TYPE 2>/dev/null || true'
+            )
+            for line in raw.strip().splitlines():
+                r = {key.lower(): val.strip('"')
+                     for key, val in re.findall(r'(\S+)=(".*?"|\S+)', line)}
+                if r.get('name') != md_name:
+                    continue
+                if r.get('type') not in ('raid0', 'raid1', 'raid4', 'raid5', 'raid6', 'raid10', 'linear'):
+                    break
+                mountpoint = self.ssh(
+                    f'lsblk --noheadings -o MOUNTPOINT /dev/{md_name} 2>/dev/null || true'
+                ).strip()
+                devices.append(Host.BlockDeviceInfo(
+                    name=md_name,
+                    path=f'/dev/{md_name}',
+                    size=int(r['size']),
+                    log_sec=int(r.get('log-sec', '0') or '0'),
+                    type='md',
+                    available=len(mountpoint) == 0,
+                ))
+                break
 
-    def disks(self) -> list[Host.BlockDeviceInfo]:
-        """ List of BlockDeviceInfo for all disks. """
-        # store the names of the parent devices to filter out the devices with children
-        pknames = set(disk['pkname'] for disk in self.block_devices_info if disk['pkname'])
-        # filter out partitions from block_devices
-        return sorted(
-            (
-                disk
-                for disk in self.block_devices_info
-                if (not disk["pkname"] or disk['type'] == 'raid0') and disk['kname'] not in pknames
-            ),
-            key=lambda disk: disk["name"],
+        # --- multipath devices ---
+        raw_mpath = self.ssh(
+            'lsblk --pairs --bytes -I 253 --output NAME,SIZE,LOG-SEC,TYPE,DM-NAME 2>/dev/null || true'
         )
+        for line in raw_mpath.strip().splitlines():
+            r = {key.lower(): val.strip('"')
+                 for key, val in re.findall(r'(\S+)=(".*?"|\S+)', line)}
+            if not r or r.get('type') != 'mpath':
+                continue
+            dm_name = r['name']     # e.g. "dm-3"
+            dm_alias = r.get('dm-name', '').strip()  # e.g. "mpathb"
+            path = f'/dev/mapper/{dm_alias}' if dm_alias else f'/dev/{dm_name}'
+            mountpoint = self.ssh(f'lsblk --noheadings -o MOUNTPOINT /dev/{dm_name} 2>/dev/null || true').strip()
+            devices.append(Host.BlockDeviceInfo(
+                name=dm_name,
+                path=path,
+                size=int(r['size']),
+                log_sec=int(r.get('log-sec', '0') or '0'),
+                type='mpath',
+                available=len(mountpoint) == 0,
+            ))
+
+        self.block_devices_info = sorted(devices, key=lambda d: d.name)
+        logging.debug("blockdevs found: %s", [d.name for d in self.block_devices_info])
+
+    def _disk_is_available_local(self, disk: str) -> bool:
+        """Check if a local block device is not in use (not mounted, not a member of md/lvm/mpath/zfs)."""
+        # 1. Check mountpoints
+        mountpoint = self.ssh(f'lsblk --noheadings -o MOUNTPOINT /dev/{disk}').strip()
+        if mountpoint:
+            return False
+        # 2. Check if md member
+        result = self.ssh_with_result(f'mdadm --examine /dev/{disk} 2>/dev/null')
+        if result.returncode == 0:
+            return False
+        # 3. Check if LVM member
+        result = self.ssh_with_result(f'pvs /dev/{disk} 2>/dev/null')
+        if result.returncode == 0:
+            return False
+        # 4. Check if ZFS pool member (zpool may not be installed)
+        zpool_status = self.ssh('zpool status 2>/dev/null || true').strip()
+        return not (zpool_status and f'/dev/{disk}' in zpool_status)
 
-    def disk_is_available(self, disk: DiskDevName) -> bool:
-        """
-        Check if a disk is unmounted and appears available for use.
-
-        It may or may not contain identifiable filesystem or partition label.
-        If there are no mountpoints, it is assumed that the disk is not in use.
-
-        Warn: This function may misclassify LVM_member disks (e.g. in XOSTOR, RAID, ZFS) as "available".
-        Such disks may not have mountpoints but still be in use.
-        """
-        return len(self.ssh(f'lsblk --noheadings -o MOUNTPOINT /dev/{disk}').strip()) == 0
+    def disks(self) -> list[Host.BlockDeviceInfo]:
+        """ List of all block devices (local disks, mdadm arrays, multipath devices). """
+        return list(self.block_devices_info)
 
     def file_exists(self, filepath: str, regular_file: bool = True) -> bool:
         option = '-f' if regular_file else '-e'

pkgfixtures.py

@@ -25,7 +25,7 @@ def sr_disk_wiped(host: Host, unused_512B_disks: dict[Host, list[Host.BlockDevic
     """A disk on MASTER HOST OF FIRST POOL which we wipe."""
     host_disks = unused_512B_disks[host]
     assert host_disks, f"No 512B disk available on host {host}"
-    sr_disk = host_disks[0]["name"]
+    sr_disk = host_disks[0].name
     logging.info(">> wipe disk %s" % sr_disk)
     host.ssh(f'wipefs -a /dev/{sr_disk}')
     yield sr_disk
@@ -38,7 +38,7 @@ def formatted_and_mounted_ext4_disk(host: Host, unused_512B_disks: dict[Host, li
     mountpoint = '/var/tmp/sr_disk_mountpoint'
     host_disks = unused_512B_disks[host]
     assert host_disks, f"No 512B disk available on host {host}"
-    sr_disk = host_disks[0]["name"]
+    sr_disk = host_disks[0].name
     setup_formatted_and_mounted_disk(host, sr_disk, 'ext4', mountpoint)
     yield mountpoint
     teardown_formatted_and_mounted_disk(host, mountpoint)

tests/storage/conftest.py

@@ -83,7 +83,7 @@ def xfs_sr_on_hostA2(
     _xfs_config_on_hostA2: XfsConfig,
 ) -> Generator[SR, None, None]:
     """ A XFS SR on first host. """
-    sr_disk = unused_512B_disks[hostA2_with_xfsprogs][0]["name"]
+    sr_disk = unused_512B_disks[hostA2_with_xfsprogs][0].name
     sr = hostA2_with_xfsprogs.sr_create('xfs', "XFS-local-SR-test",
                                         {'device': '/dev/' + sr_disk,
                                          'preferred-image-formats': image_format})
@@ -123,7 +123,7 @@ def xfs_sr_on_hostB1(
     _xfs_config_on_hostB1: XfsConfig,
 ) -> Generator[SR, None, None]:
     """ A XFS SR on first host. """
-    sr_disk = unused_512B_disks[hostB1_with_xfsprogs][0]["name"]
+    sr_disk = unused_512B_disks[hostB1_with_xfsprogs][0].name
     sr = hostB1_with_xfsprogs.sr_create('xfs', "XFS-local-SR-test",
                                         {'device': '/dev/' + sr_disk,
                                          'preferred-image-formats': image_format})

tests/storage/ext/conftest.py

@@ -18,7 +18,7 @@ def ext_sr(host: Host,
            image_format: ImageFormat
            ) -> Generator[SR, None, None]:
     """ An EXT SR on first host. """
-    sr_disk = unused_512B_disks[host][0]["name"]
+    sr_disk = unused_512B_disks[host][0].name
     sr = host.sr_create('ext', "EXT-local-SR-test",
                         {'device': '/dev/' + sr_disk,
                          'preferred-image-formats': image_format})

tests/storage/ext/test_ext_sr.py

@@ -42,7 +42,7 @@ def test_create_and_destroy_sr(self, host: Host,
                                    image_format: ImageFormat
                                    ) -> None:
         # Create and destroy tested in the same test to leave the host as unchanged as possible
-        sr_disk = unused_512B_disks[host][0]["name"]
+        sr_disk = unused_512B_disks[host][0].name
         sr = host.sr_create('ext', "EXT-local-SR-test",
                             {'device': '/dev/' + sr_disk,
                              'preferred-image-formats': image_format}, verify=True)

tests/storage/glusterfs/conftest.py

@@ -122,7 +122,7 @@ def gluster_disk(
     pool = pool_with_unused_512B_disk
     mountpoint = '/mnt/sr_disk'
     for h in pool.hosts:
-        sr_disk = unused_512B_disks[h][0]["name"]
+        sr_disk = unused_512B_disks[h][0].name
         setup_formatted_and_mounted_disk(h, sr_disk, 'xfs', mountpoint)
 
     yield

tests/storage/largeblock/conftest.py

@@ -20,7 +20,7 @@ def largeblock_sr(host: Host,
                   unused_4k_disks: dict[Host, list[Host.BlockDeviceInfo]],
                   image_format: ImageFormat) -> Generator[SR, None, None]:
     """ A LARGEBLOCK SR on first host. """
-    sr_disk = unused_4k_disks[host][0]["name"]
+    sr_disk = unused_4k_disks[host][0].name
     sr = host.sr_create('largeblock', "LARGEBLOCK-local-SR-test",
                         {'device': '/dev/' + sr_disk,
                          'preferred-image-formats': image_format})

tests/storage/largeblock/test_largeblock_sr.py

@@ -31,7 +31,7 @@ def test_create_and_destroy_sr(self, host: Host,
                                    unused_4k_disks: dict[Host, list[Host.BlockDeviceInfo]],
                                    image_format: ImageFormat) -> None:
         # Create and destroy tested in the same test to leave the host as unchanged as possible
-        sr_disk = unused_4k_disks[host][0]["name"]
+        sr_disk = unused_4k_disks[host][0].name
         sr = host.sr_create('largeblock', "LARGEBLOCK-local-SR-test",
                             {'device': '/dev/' + sr_disk,
                              'preferred-image-formats': image_format}, verify=True)

tests/storage/linstor/conftest.py

@@ -60,7 +60,7 @@ def lvm_disks(
 
     @functools.cache
     def host_devices(host: Host) -> list[str]:
-        return [os.path.join("/dev", disk["name"]) for disk in unused_512B_disks[host][0:1]]
+        return [disk.path for disk in unused_512B_disks[host][0:1]]
 
     for host in hosts:
         devices = host_devices(host)