Use blkid instead of lsblk to get disk info when udev is not present

[ravanelli]

• OSBuild does not allow udev rules in loop devices, for this reason can not rely on labels on the partitions to create the osmet image, we
  need to skip this part and pass only the fstype
  for the it to be mounted.

[jlebon]

Hmm, how about instead, we keep the interface the same (no new command-line arguments), but in get_partitions, we check if udev is present (e.g. check for /run/udev/control; we have code that does something similar already), and if so then use lsblk(), otherwise use blkid().

Both return a Result<Vec<HashMap<String, String>>> we can iterate over. But of course in the blkid case, some of the key names to pull from will be different.

[jlebon]

Both return a Result<Vec<HashMap<String, String>>> we can iterate over. But of course in the blkid case, some of the key names to pull from will be different.

Though I think this is glossing over an important detail. blkid() will return information about all devices, whereas lsblk() only returns information about the passed device. Since we can still use lsblk() at least to get the list of partitions on the disk, we can then call a blkid_single() that only does blkid on one device (or just change blkid() to take an dev: Option<String>) to get the info we need. So basically something like:

fn get_partitions(&self) -> Result<Vec<Partition>> {
    // walk each device in the output
    let mut result: Vec<Partition> = Vec::new();
    for devinfo in lsblk(Path::new(&self.path), true)? {
        if let Some(name) = devinfo.get("NAME") {
            // Only return partitions.  Skip the whole-disk device, as well
            // as holders like LVM or RAID devices using one of the partitions.
            if devinfo.get("TYPE").map(|s| s.as_str()) != Some("part") {
                continue;
            }
            // only trust lsblk output for the following fields if we have udev
            if have_udev() {
                let (mountpoint, swap) = match devinfo.get("MOUNTPOINT") {
                    Some(mp) if mp == "[SWAP]" => (None, true),
                    Some(mp) => (Some(mp.to_string()), false),
                    None => (None, false),
                };
                result.push(Partition {
                    path: name.to_owned(),
                    label: devinfo.get("LABEL").map(<_>::to_string),
                    fstype: devinfo.get("FSTYPE").map(<_>::to_string),
                    parent: self.path.to_owned(),
                    mountpoint,
                    swap,
                });
            } else {
                let devinfo = blkid_single(name)?;
                // note TYPE here: blkid uses TYPE instead of FSTYPE
                let fstype = devinfo.get("TYPE").map(<_>::to_string);
                result.push(Partition {
                    path: name.to_owned(),
                    label: devinfo.get("LABEL").map(<_>::to_string),
                    fstype,
                    parent: self.path.to_owned(),
                    None,
                    fstype.is_some_and(|s| s == "swap"),
                });
            }
        }
    }
    Ok(result)
}

[ravanelli]

Though I think this is glossing over an important detail. blkid()

Great, in the current code I used bklid for a single device as well adding the dev path:

     Command::new("blkid");
      cmd.arg(path);

Fixing the rest ;)

[jlebon]

Can just use map here if we don't need filtering functionality.

[jlebon]

Minor: spacing

[jlebon]

A more idiomatic way to restructure all this is:

let cmd_dev = if let Some(paths) = dev {
    paths
} else {
    let devices = {
        ...
    };
    devices.lines().map(|line| Path::new(line.trim())).collect()
};

[ravanelli]

Thanks for the free rust class @jlebon ;)

[jlebon]

Just added spacing and tweaked some of the variable names.

LGTM!