disktester: Quick in tree helper for testing the provisioner

Signed-off-by: Ikey Doherty <[email protected]>

Author: ikeycode

.gitignore

@@ -1 +1,2 @@
 /target
+lesparse.img

Cargo.lock

@@ -0,0 +1,9 @@
+[package]
+name = "disktester"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+disks = { path = "../disks" }
+partitioning = { path = "../partitioning" }
+provisioning = { path = "../provisioning" }

crates/disktester/Cargo.toml

@@ -0,0 +1,86 @@
+// SPDX-FileCopyrightText: Copyright © 2025 Serpent OS Developers
+//
+// SPDX-License-Identifier: MPL-2.0
+
+use std::path::{Path, PathBuf};
+
+use disks::BlockDevice;
+use partitioning::{blkpg, loopback, sparsefile, writer::DiskWriter};
+use provisioning::{Parser, Provisioner, StrategyDefinition};
+
+/// Loads provisioning strategies from a configuration file
+///
+/// # Arguments
+/// * `path` - Path to the provisioning configuration file
+///
+/// # Returns
+/// * `Result<Vec<StrategyDefinition>>` - Vector of loaded strategy definitions
+fn load_provisioning(path: impl Into<PathBuf>) -> Result<Vec<StrategyDefinition>, Box<dyn std::error::Error>> {
+    let p = path.into();
+    let parser = Parser::new_for_path(p)?;
+    Ok(parser.strategies)
+}
+
+/// Applies partitioning strategies to a block device
+///
+/// # Arguments
+/// * `whence` - Path to the block device to partition
+///
+/// # Returns
+/// * `Result<()>` - Success or error status
+fn apply_partitioning(whence: &Path) -> Result<(), Box<dyn std::error::Error>> {
+    // Initialize provisioner and load strategies
+    let mut prov = Provisioner::new();
+    for strategy in load_provisioning("crates/provisioning/tests/use_whole_disk.kdl")? {
+        prov.add_strategy(strategy);
+    }
+
+    // Set up block device
+    let device = disks::loopback::Device::from_device_path(whence).ok_or("Not a loop device")?;
+    let blk = BlockDevice::loopback_device(device);
+    prov.push_device(blk);
+
+    // Generate and validate partitioning plans
+    let plans = prov.plan();
+    for plan in &plans {
+        eprintln!("Plan: {}", plan.strategy.name);
+    }
+    let plan = plans.first().ok_or("No plans")?;
+
+    // Apply partitioning changes
+    for (disk, device_plan) in plan.device_assignments.iter() {
+        eprintln!("strategy for {} is now: {}", disk, device_plan.strategy.describe());
+        eprintln!("After: {}", device_plan.planner.describe_changes());
+
+        let disk_writer = DiskWriter::new(device_plan.device, &device_plan.planner);
+        disk_writer.simulate()?;
+        eprintln!("Simulation passed");
+        disk_writer.write()?;
+    }
+
+    Ok(())
+}
+
+/// Main entry point - creates and partitions a loopback device
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Create sparse file and attach loopback device
+    sparsefile::create("lesparse.img", 32 * 1024 * 1024 * 1024)?;
+    let l = loopback::LoopDevice::create()?;
+    l.attach("lesparse.img")?;
+
+    eprintln!("Loopback device: {:?}", &l.path);
+
+    // Apply partitioning and handle errors
+    let whence = PathBuf::from(&l.path);
+    if let Err(e) = apply_partitioning(&whence) {
+        eprintln!("Error applying partitioning: {}", e);
+    }
+
+    // Sync partition table changes
+    blkpg::sync_gpt_partitions(whence)?;
+
+    // Clean up loopback device
+    l.detach()?;
+
+    Ok(())
+}