provisioning: Add new constraints type and plumb into create-partition

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

Author: ikeycode

crates/provisioning/src/commands/create_partition.rs

@@ -3,7 +3,7 @@
 //
 // SPDX-License-Identifier: MPL-2.0
 
-use crate::{get_kdl_property, get_property_str, Context, FromKdlProperty, PartitionRole};
+use crate::{get_kdl_property, get_property_str, Constraints, Context, FromKdlProperty, PartitionRole};
 
 /// Command to create a partition
 #[derive(Debug)]
@@ -16,6 +16,8 @@ pub struct Command {
 
     /// The role, if any, of the partition
     pub role: Option<PartitionRole>,
+
+    pub constraints: Constraints,
 }
 
 /// Generate a command to create a partition
@@ -28,6 +30,18 @@ pub(crate) fn parse(context: Context<'_>) -> Result<super::Command, crate::Error
         None
     };
 
+    let constraints =
+        if let Some(constraints) = context.node.iter_children().find(|n| n.name().value() == "constraints") {
+            Constraints::from_kdl_node(constraints)?
+        } else {
+            return Err(crate::Error::MissingNode("constraints"));
+        };
+
     // TODO: Load constraints etc
-    Ok(super::Command::CreatePartition(Box::new(Command { disk, id, role })))
+    Ok(super::Command::CreatePartition(Box::new(Command {
+        disk,
+        id,
+        role,
+        constraints,
+    })))
 }

crates/provisioning/src/errors.rs

@@ -37,6 +37,13 @@ pub enum Error {
     #[error(transparent)]
     UnsupportedNode(#[from] UnsupportedNode),
 
+    #[diagnostic(transparent)]
+    #[error(transparent)]
+    MissingEntry(#[from] MissingEntry),
+
+    #[error("missing node: {0}")]
+    MissingNode(&'static str),
+
     #[diagnostic(transparent)]
     #[error(transparent)]
     MissingProperty(#[from] MissingProperty),
@@ -84,6 +91,20 @@ pub struct MissingProperty {
     pub advice: Option<String>,
 }
 
+/// Error for missing mandatory properties
+#[derive(Debug, Diagnostic, Error)]
+#[error("missing entry: {id}")]
+#[diagnostic(severity(error))]
+pub struct MissingEntry {
+    #[label]
+    pub at: SourceSpan,
+
+    pub id: String,
+
+    #[help]
+    pub advice: Option<String>,
+}
+
 /// Error for unsupported node types
 #[derive(Debug, Diagnostic, Error)]
 #[error("unsupported node: {name}")]

crates/provisioning/src/helpers.rs

@@ -2,9 +2,9 @@
 //
 // SPDX-License-Identifier: MPL-2.0
 
-use kdl::{KdlEntry, KdlNode};
+use kdl::{KdlEntry, KdlNode, NodeKey};
 
-use crate::{Error, InvalidType, KdlType, MissingProperty};
+use crate::{Error, FromKdlType, InvalidType, KdlType, MissingEntry, MissingProperty, StorageUnit};
 
 // Get a property from a node
 pub(crate) fn get_kdl_property<'a>(node: &'a KdlNode, name: &'static str) -> Result<&'a KdlEntry, Error> {
@@ -17,6 +17,19 @@ pub(crate) fn get_kdl_property<'a>(node: &'a KdlNode, name: &'static str) -> Res
     Ok(entry)
 }
 
+pub(crate) fn get_kdl_entry<'a, T>(node: &'a KdlNode, id: &'a T) -> Result<&'a KdlEntry, Error>
+where
+    T: Into<NodeKey> + ToString + Clone,
+{
+    let entry = node.entry(id.clone()).ok_or_else(|| MissingEntry {
+        at: node.span(),
+        id: id.to_string(),
+        advice: None,
+    })?;
+
+    Ok(entry)
+}
+
 // Get a string property from a value
 pub(crate) fn kdl_value_to_string(entry: &kdl::KdlEntry) -> Result<String, Error> {
     let value = entry.value().as_string().ok_or(InvalidType {
@@ -27,6 +40,23 @@ pub(crate) fn kdl_value_to_string(entry: &kdl::KdlEntry) -> Result<String, Error
     Ok(value.to_owned())
 }
 
+// Get an integer property from a value
+pub(crate) fn kdl_value_to_integer(entry: &kdl::KdlEntry) -> Result<i128, Error> {
+    let value = entry.value().as_integer().ok_or(InvalidType {
+        at: entry.span(),
+        expected_type: KdlType::Integer,
+    })?;
+
+    Ok(value)
+}
+
+// Convert a KDL value to a storage size
+pub(crate) fn kdl_value_to_storage_size(entry: &kdl::KdlEntry) -> Result<u64, Error> {
+    let value = kdl_value_to_integer(entry)?;
+    let units = StorageUnit::from_kdl_type(entry)?;
+    Ok(value as u64 * units as u64)
+}
+
 // Get a string property from a node
 pub(crate) fn get_property_str(node: &KdlNode, name: &'static str) -> Result<String, Error> {
     let value = get_kdl_property(node, name).and_then(kdl_value_to_string)?;

crates/provisioning/src/types.rs

@@ -16,6 +16,8 @@ pub use partition_role::*;
 
 mod units;
 pub use units::*;
+pub mod constraints;
+pub use constraints::*;
 
 /// The type of a KDL value
 #[derive(Debug)]

crates/provisioning/src/types/constraints.rs

@@ -0,0 +1,52 @@
+// SPDX-FileCopyrightText: Copyright © 2025 AerynOS Developers
+//
+// SPDX-License-Identifier: MPL-2.0
+
+use crate::{get_kdl_entry, kdl_value_to_storage_size};
+
+/// Constraints for partition size, 1:1 mapping to SizeRequirements in
+/// partitioning strategy internals.
+#[derive(Debug)]
+pub enum Constraints {
+    /// Exact size in bytes
+    Exact(u64),
+    /// Minimum size in bytes, using more if available
+    AtLeast(u64),
+    /// Between min and max bytes
+    Range { min: u64, max: u64 },
+    /// Use all remaining space
+    Remaining,
+}
+
+impl Constraints {
+    pub fn from_kdl_node(node: &kdl::KdlNode) -> Result<Self, crate::Error> {
+        let range = node
+            .iter_children()
+            .find(|n| n.name().value() == "min")
+            .zip(node.iter_children().find(|n| n.name().value() == "max"));
+
+        if let Some((min, max)) = range {
+            let min = kdl_value_to_storage_size(get_kdl_entry(min, &0)?)? as u64;
+            let max = kdl_value_to_storage_size(get_kdl_entry(max, &0)?)? as u64;
+
+            Ok(Self::Range {
+                min: min as u64,
+                max: max as u64,
+            })
+        } else if let Some(min) = node.iter_children().find(|n| n.name().value() == "min") {
+            let min = kdl_value_to_storage_size(get_kdl_entry(min, &0)?)? as u64;
+            Ok(Self::AtLeast(min as u64))
+        } else if let Some(exact) = node.iter_children().find(|n| n.name().value() == "exactly") {
+            let exact = kdl_value_to_storage_size(get_kdl_entry(exact, &0)?)? as u64;
+            Ok(Self::Exact(exact as u64))
+        } else if node.iter_children().any(|n| n.name().value() == "remaining") {
+            Ok(Self::Remaining)
+        } else {
+            Err(crate::Error::MissingProperty(crate::MissingProperty {
+                at: node.span(),
+                id: "min, max, exactly or remaining",
+                advice: Some("add one of these properties".into()),
+            }))
+        }
+    }
+}