Merge pull request #67 from cgwalters/add-config-files

install: Add systemd-style drop-in config files

Author: jmarrero

Makefile

@@ -8,6 +8,7 @@ all-test:
 
 install:
 	install -D -t $(DESTDIR)$(prefix)/bin target/release/bootc
+	install -D -t $(DESTDIR)$(prefix)/lib/bootc/install lib/src/install/*.toml
 
 bin-archive: all
 	$(MAKE) install DESTDIR=tmp-install && tar --zstd -C tmp-install -cf bootc.tar.zst . && rm tmp-install -rf

lib/Cargo.toml

@@ -20,6 +20,7 @@ fn-error-context = "0.2.0"
 gvariant = "0.4.0"
 indicatif = "0.17.0"
 libc = "^0.2"
+liboverdrop = "0.1.0"
 once_cell = "1.9"
 openssl = "^0.10"
 nix = ">= 0.24, < 0.26"
@@ -32,6 +33,7 @@ tokio = { features = ["io-std", "time", "process", "rt", "net"], version = ">= 1
 tokio-util = { features = ["io-util"], version = "0.7" }
 tracing = "0.1"
 tempfile = "3.3.0"
+toml = "0.7.2"
 xshell = { version = "0.2", optional = true }
 uuid = { version = "1.2.2", features = ["v4"] }
 

lib/src/install.rs

@@ -168,6 +168,7 @@ pub(crate) struct State {
     override_disable_selinux: bool,
     config_opts: InstallConfigOpts,
     target_opts: InstallTargetOpts,
+    install_config: config::InstallConfiguration,
 }
 
 /// Path to initially deployed version information
@@ -260,6 +261,76 @@ impl FromStr for MountSpec {
     }
 }
 
+mod config {
+    use super::*;
+
+    /// The toplevel config entry for installation configs stored
+    /// in bootc/install (e.g. /etc/bootc/install/05-custom.toml)
+    #[derive(Debug, Deserialize, Default)]
+    #[serde(deny_unknown_fields)]
+    pub(crate) struct InstallConfigurationToplevel {
+        pub(crate) install: Option<InstallConfiguration>,
+    }
+
+    /// The serialized [install] section
+    #[derive(Debug, Deserialize, Default)]
+    #[serde(rename = "install", rename_all = "kebab-case", deny_unknown_fields)]
+    pub(crate) struct InstallConfiguration {
+        pub(crate) root_fs_type: Option<super::baseline::Filesystem>,
+    }
+
+    impl InstallConfiguration {
+        /// Apply any values in other, overriding any existing values in `self`.
+        fn merge(&mut self, other: Self) {
+            fn mergeopt<T>(s: &mut Option<T>, o: Option<T>) {
+                if let Some(o) = o {
+                    *s = Some(o);
+                }
+            }
+            mergeopt(&mut self.root_fs_type, other.root_fs_type)
+        }
+    }
+
+    #[context("Loading configuration")]
+    /// Load the install configuration, merging all found configuration files.
+    pub(crate) fn load_config() -> Result<InstallConfiguration> {
+        const SYSTEMD_CONVENTIONAL_BASES: &[&str] = &["/usr/lib", "/usr/local/lib", "/etc", "/run"];
+        let fragments =
+            liboverdrop::scan(SYSTEMD_CONVENTIONAL_BASES, "bootc/install", &["toml"], true);
+        let mut config: Option<InstallConfiguration> = None;
+        for (_name, path) in fragments {
+            let buf = std::fs::read_to_string(&path)?;
+            let c: InstallConfigurationToplevel =
+                toml::from_str(&buf).with_context(|| format!("Parsing {path:?}"))?;
+            if let Some(config) = config.as_mut() {
+                if let Some(install) = c.install {
+                    config.merge(install);
+                }
+            } else {
+                config = c.install;
+            }
+        }
+        config.ok_or_else(|| anyhow::anyhow!("Failed to find any installation config files"))
+    }
+
+    #[test]
+    /// Verify that we can parse our default config file
+    fn test_parse_config() {
+        use super::baseline::Filesystem;
+        let buf = include_str!("install/00-defaults.toml");
+        let c: InstallConfigurationToplevel = toml::from_str(buf).unwrap();
+        let mut install = c.install.unwrap();
+        assert_eq!(install.root_fs_type.unwrap(), Filesystem::Xfs);
+        let other = InstallConfigurationToplevel {
+            install: Some(InstallConfiguration {
+                root_fs_type: Some(Filesystem::Ext4),
+            }),
+        };
+        install.merge(other.install.unwrap());
+        assert_eq!(install.root_fs_type.unwrap(), Filesystem::Ext4);
+    }
+}
+
 fn bind_mount_from_host(src: impl AsRef<Utf8Path>, dest: impl AsRef<Utf8Path>) -> Result<()> {
     let src = src.as_ref();
     let dest = dest.as_ref();
@@ -626,6 +697,8 @@ async fn prepare_install(
     let override_disable_selinux =
         reexecute_self_for_selinux_if_needed(&srcdata, config_opts.disable_selinux)?;
 
+    let install_config = config::load_config()?;
+
     // Create our global (read-only) state which gets wrapped in an Arc
     // so we can pass it to worker threads too. Right now this just
     // combines our command line options along with some bind mounts from the host.
@@ -637,6 +710,7 @@ async fn prepare_install(
         source_digest,
         config_opts,
         target_opts,
+        install_config,
     });
 
     Ok(state)
@@ -709,7 +783,9 @@ pub(crate) async fn install(opts: InstallOpts) -> Result<()> {
 
     // This is all blocking stuff
     let mut rootfs = {
-        tokio::task::spawn_blocking(move || baseline::install_create_rootfs(block_opts)).await??
+        let state = state.clone();
+        tokio::task::spawn_blocking(move || baseline::install_create_rootfs(&state, block_opts))
+            .await??
     };
 
     install_to_filesystem_impl(&state, &mut rootfs).await?;

lib/src/install/00-defaults.toml

@@ -0,0 +1,3 @@
+# The default configuration for installations.
+[install]
+root-fs-type = "xfs"

lib/src/install/baseline.rs

@@ -22,6 +22,7 @@ use serde::{Deserialize, Serialize};
 
 use super::MountSpec;
 use super::RootSetup;
+use super::State;
 use super::RUN_BOOTC;
 use super::RW_KARG;
 use crate::lsm::lsm_label;
@@ -44,6 +45,7 @@ pub(crate) const PREPPN: u32 = 1;
 pub(crate) const RESERVEDPN: u32 = 1;
 
 #[derive(clap::ValueEnum, Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "kebab-case")]
 pub(crate) enum Filesystem {
     Xfs,
     Ext4,
@@ -97,9 +99,8 @@ pub(crate) struct InstallBlockDeviceOpts {
     pub(crate) block_setup: BlockSetup,
 
     /// Target root filesystem type.
-    #[clap(long, value_enum, default_value_t)]
-    #[serde(default)]
-    pub(crate) filesystem: Filesystem,
+    #[clap(long, value_enum)]
+    pub(crate) filesystem: Option<Filesystem>,
 
     /// Size of the root partition (default specifier: M).  Allowed specifiers: M (mebibytes), G (gibibytes), T (tebibytes).
     ///
@@ -156,7 +157,10 @@ fn mkfs<'a>(
 }
 
 #[context("Creating rootfs")]
-pub(crate) fn install_create_rootfs(opts: InstallBlockDeviceOpts) -> Result<RootSetup> {
+pub(crate) fn install_create_rootfs(
+    state: &State,
+    opts: InstallBlockDeviceOpts,
+) -> Result<RootSetup> {
     // Verify that the target is empty (if not already wiped in particular, but it's
     // also good to verify that the wipe worked)
     let device = crate::blockdev::list_dev(&opts.device)?;
@@ -302,7 +306,11 @@ pub(crate) fn install_create_rootfs(opts: InstallBlockDeviceOpts) -> Result<Root
 
     // Initialize rootfs
     let rootdev = &format!("{device}{ROOTPN}");
-    let root_uuid = mkfs(rootdev, opts.filesystem, Some("root"), [])?;
+    let root_filesystem = opts
+        .filesystem
+        .or(state.install_config.root_fs_type)
+        .ok_or_else(|| anyhow::anyhow!("No root filesystem specified"))?;
+    let root_uuid = mkfs(rootdev, root_filesystem, Some("root"), [])?;
     let rootarg = format!("root=UUID={root_uuid}");
     let bootsrc = format!("UUID={boot_uuid}");
     let bootarg = format!("boot={bootsrc}");

lib/src/privtests.rs

@@ -151,7 +151,7 @@ fn test_install_filesystem(image: &str, blockdev: &Utf8Path) -> Result<()> {
     let mountpoint: &Utf8Path = mountpoint_dir.path().try_into().unwrap();
 
     // And run the install
-    cmd!(sh, "podman run --rm --privileged --pid=host --net=none --env=RUST_LOG -v /usr/bin/bootc:/usr/bin/bootc -v {mountpoint}:/target-root {image} bootc install-to-filesystem /target-root").run()?;
+    cmd!(sh, "podman run --rm --privileged --pid=host --net=none --env=RUST_LOG -v /usr/bin/bootc:/usr/bin/bootc -v /usr/lib/bootc:/usr/lib/bootc -v {mountpoint}:/target-root {image} bootc install-to-filesystem /target-root").run()?;
 
     cmd!(sh, "umount -R {mountpoint}").run()?;
 

tests/kolainst/install

@@ -20,7 +20,7 @@ cd $(mktemp -d)
 
 case "${AUTOPKGTEST_REBOOT_MARK:-}" in
   "")
-    podman run --rm -ti --privileged --pid=host --net=none -v /usr/bin/bootc:/usr/bin/bootc ${IMAGE} bootc install --karg=foo=bar ${DEV}
+    podman run --rm -ti --privileged --pid=host --net=none -v /usr/bin/bootc:/usr/bin/bootc -v /usr/lib/bootc:/usr/lib/bootc ${IMAGE} bootc install --karg=foo=bar ${DEV}
     # In theory we could e.g. wipe the bootloader setup on the primary disk, then reboot;
     # but for now let's just sanity test that the install command executes.
     lsblk ${DEV}