provisioning: Flesh out create-partitition with role

Exporting the role allows tooling to determine the intended mountpoint
for a strategy's partitions.

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

Author: ikeycode

crates/provisioning/src/commands.rs

@@ -1,4 +1,5 @@
 // SPDX-FileCopyrightText: Copyright © 2025 Serpent OS Developers
+// SPDX-FileCopyrightText: Copyright © 2025 AerynOS Developers
 //
 // SPDX-License-Identifier: MPL-2.0
 
@@ -11,7 +12,7 @@ mod find_disk;
 /// A command
 #[derive(Debug)]
 pub enum Command {
-    CreatePartition,
+    CreatePartition(Box<create_partition::Command>),
     CreatePartitionTable(Box<create_partition_table::Command>),
     FindDisk(Box<find_disk::Command>),
 }
@@ -22,7 +23,7 @@ type CommandExec = for<'a> fn(Context<'a>) -> Result<Command, crate::Error>;
 /// Map of command names to functions
 static COMMANDS: phf::Map<&'static str, CommandExec> = phf::phf_map! {
     "find-disk" => find_disk::parse,
-    //"create-partition" => create_partition::parse,
+    "create-partition" => create_partition::parse,
     "create-partition-table" => create_partition_table::parse,
 };
 

crates/provisioning/src/commands/create_partition.rs

@@ -1,11 +1,33 @@
 // SPDX-FileCopyrightText: Copyright © 2025 Serpent OS Developers
+// SPDX-FileCopyrightText: Copyright © 2025 AerynOS Developers
 //
 // SPDX-License-Identifier: MPL-2.0
 
-use super::Command;
-use crate::Context;
+use crate::{get_kdl_property, get_property_str, Context, FromKdlProperty, PartitionRole};
+
+/// Command to create a partition
+#[derive(Debug)]
+pub struct Command {
+    /// The disk ID to create the partition on
+    pub disk: String,
+
+    /// The reference ID of the partition
+    pub id: String,
+
+    /// The role, if any, of the partition
+    pub role: Option<PartitionRole>,
+}
 
 /// Generate a command to create a partition
-pub(crate) fn parse(_context: Context<'_>) -> Result<Command, crate::Error> {
-    unimplemented!("Command not implemented");
+pub(crate) fn parse(context: Context<'_>) -> Result<super::Command, crate::Error> {
+    let disk = get_property_str(context.node, "disk")?;
+    let id = get_property_str(context.node, "id")?;
+    let role = if let Ok(role) = get_kdl_property(context.node, "role") {
+        Some(PartitionRole::from_kdl_property(role)?)
+    } else {
+        None
+    };
+
+    // TODO: Load constraints etc
+    Ok(super::Command::CreatePartition(Box::new(Command { disk, id, role })))
 }

crates/provisioning/src/types.rs

@@ -1,4 +1,5 @@
 // SPDX-FileCopyrightText: Copyright © 2025 Serpent OS Developers
+// SPDX-FileCopyrightText: Copyright © 2025 AerynOS Developers
 //
 // SPDX-License-Identifier: MPL-2.0
 
@@ -10,6 +11,8 @@ use crate::Error;
 
 mod partition_table;
 pub use partition_table::*;
+mod partition_role;
+pub use partition_role::*;
 
 mod units;
 pub use units::*;

crates/provisioning/src/types/partition_role.rs

@@ -0,0 +1,68 @@
+// SPDX-FileCopyrightText: Copyright © 2025 Serpent OS Developers
+// SPDX-FileCopyrightText: Copyright © 2025 AerynOS Developers
+//
+// SPDX-License-Identifier: MPL-2.0
+
+use std::{fmt, str::FromStr};
+
+use crate::kdl_value_to_string;
+
+use super::FromKdlProperty;
+
+/// The role assigned to a partition
+#[derive(Debug, PartialEq)]
+pub enum PartitionRole {
+    /// Boot partition (usually ESP)
+    Boot,
+
+    /// Extended boot partition (e.g. XBOOTLDR)
+    ExtendedBoot,
+
+    /// Root filesystem
+    Root,
+
+    /// Home directory mount
+    Home,
+
+    /// Swap partition
+    Swap,
+}
+
+impl fmt::Display for PartitionRole {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Boot => f.write_str("boot"),
+            Self::ExtendedBoot => f.write_str("extended-boot"),
+            Self::Root => f.write_str("root"),
+            Self::Home => f.write_str("home"),
+            Self::Swap => f.write_str("swap"),
+        }
+    }
+}
+
+impl FromStr for PartitionRole {
+    type Err = crate::Error;
+
+    /// Attempt to convert a string to a partition role
+    fn from_str(value: &str) -> Result<Self, Self::Err> {
+        match value {
+            "boot" => Ok(Self::Boot),
+            "extended-boot" => Ok(Self::ExtendedBoot),
+            "root" => Ok(Self::Root),
+            "home" => Ok(Self::Home),
+            "swap" => Ok(Self::Swap),
+            _ => Err(crate::Error::UnknownVariant),
+        }
+    }
+}
+
+impl FromKdlProperty<'_> for PartitionRole {
+    fn from_kdl_property(entry: &kdl::KdlEntry) -> Result<Self, crate::Error> {
+        let value = kdl_value_to_string(entry)?;
+        let v = value.parse().map_err(|_| crate::UnsupportedValue {
+            at: entry.span(),
+            advice: Some("'boot', 'extended-boot', 'root', 'home' and 'swap' are supported".into()),
+        })?;
+        Ok(v)
+    }
+}

crates/provisioning/src/types/partition_table.rs

@@ -1,4 +1,5 @@
 // SPDX-FileCopyrightText: Copyright © 2025 Serpent OS Developers
+// SPDX-FileCopyrightText: Copyright © 2025 AerynOS Developers
 //
 // SPDX-License-Identifier: MPL-2.0
 

crates/provisioning/tests/use_whole_disk.kdl

@@ -13,16 +13,16 @@ strategy name="whole_disk" summary="Wipe and use an entire disk" {
     create-partition-table type="gpt" disk="root_disk"
 
     // Create the ESP
-    create-partition disk="root_disk" id="esp" {
+    create-partition disk="root_disk" role="boot" id="esp" {
         constraints {
             min (GB)1
             max (GB)2
         }
-        type (GUID)"LinuxRoot"
+        type (GUID)"ESP"
     }
 
     // Create xbootldr
-    create-partition disk="root_disk" id="xbootldr" {
+    create-partition disk="root_disk" role="extended-boot" id="xbootldr" {
         constraints {
             min (GB)2
             max (GB)4
@@ -47,7 +47,7 @@ strategy name="whole_disk_with_swap" inherits="whole_disk" \
     summary="Wipe disk, include a swap" \
 {
     // Create a swap partition in addition to the base strategy
-    create-partition disk="root_disk" id="swap" {
+    create-partition disk="root_disk" id="swap" role="swap" {
         constraints {
             min (GB)4
             max (GB)8