types: Guard all KDL/miette stuff with kdl feature

This keeps the provisioning internals free from the other
crates for use in blsforme, etc.

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

Author: ikeycode

crates/provisioning/Cargo.toml

@@ -9,7 +9,7 @@ miette = { workspace = true, features = ["fancy"] }
 [dependencies]
 disks = { path = "../disks" }
 partitioning = { path = "../partitioning" }
-types = { path = "../types" }
+types = { path = "../types", features = ["kdl"] }
 kdl = { workspace = true, features = ["span"] }
 miette = { workspace = true }
 itertools = { workspace = true }

crates/types/Cargo.toml

@@ -4,8 +4,11 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-kdl.workspace = true
+kdl = { workspace = true, optional = true }
 thiserror.workspace = true
-miette.workspace = true
+miette = { workspace = true, optional = true }
 gpt.workspace = true
 uuid.workspace = true
+
+[features]
+kdl = ["dep:kdl", "dep:miette"]

crates/types/src/constraints.rs

@@ -2,6 +2,7 @@
 //
 // SPDX-License-Identifier: MPL-2.0
 
+#[cfg(feature = "kdl")]
 use crate::{get_kdl_entry, kdl_value_to_storage_size};
 
 /// Constraints for partition size, 1:1 mapping to SizeRequirements in
@@ -22,6 +23,7 @@ pub enum Constraints {
     Invalid,
 }
 
+#[cfg(feature = "kdl")]
 impl Constraints {
     pub fn from_kdl_node(node: &kdl::KdlNode) -> Result<Self, crate::Error> {
         let range = node

crates/types/src/errors.rs

@@ -2,57 +2,72 @@
 //
 // SPDX-License-Identifier: MPL-2.0
 
-use std::{io, sync::Arc};
+use std::io;
 
+#[cfg(feature = "kdl")]
 use miette::{Diagnostic, NamedSource, SourceSpan};
+#[cfg(feature = "kdl")]
+use std::sync::Arc;
 use thiserror::Error;
 
+#[cfg(feature = "kdl")]
 use crate::KdlType;
 
 /// Error type for the provisioning crate
-#[derive(Diagnostic, Debug, Error)]
+#[cfg_attr(feature = "kdl", derive(Diagnostic))]
+#[derive(Debug, Error)]
 pub enum Error {
     #[error(transparent)]
     IO(#[from] io::Error),
 
+    #[cfg(feature = "kdl")]
     #[diagnostic(transparent)]
     #[error(transparent)]
     Kdl(#[from] kdl::KdlError),
 
+    #[cfg(feature = "kdl")]
     #[error("unknown type")]
     UnknownType,
 
     #[error("unknown variant")]
     UnknownVariant,
 
+    #[cfg(feature = "kdl")]
     #[diagnostic(transparent)]
     #[error(transparent)]
     InvalidArguments(#[from] InvalidArguments),
 
+    #[cfg(feature = "kdl")]
     #[diagnostic(transparent)]
     #[error(transparent)]
     InvalidType(#[from] InvalidType),
 
+    #[cfg(feature = "kdl")]
     #[diagnostic(transparent)]
     #[error(transparent)]
     UnsupportedNode(#[from] UnsupportedNode),
 
+    #[cfg(feature = "kdl")]
     #[diagnostic(transparent)]
     #[error(transparent)]
     MissingEntry(#[from] MissingEntry),
 
+    #[cfg(feature = "kdl")]
     #[error("missing node: {0}")]
     MissingNode(&'static str),
 
+    #[cfg(feature = "kdl")]
     #[diagnostic(transparent)]
     #[error(transparent)]
     MissingProperty(#[from] MissingProperty),
 
+    #[cfg(feature = "kdl")]
     #[diagnostic(transparent)]
     #[error(transparent)]
     UnsupportedValue(#[from] UnsupportedValue),
 }
 
+#[cfg(feature = "kdl")]
 /// Merged error for parsing failures
 /// Returns a list of diagnostics for the user
 #[derive(Debug, Diagnostic, Error)]
@@ -65,6 +80,7 @@ pub struct ParseError {
     pub diagnostics: Vec<Error>,
 }
 
+#[cfg(feature = "kdl")]
 /// Error for invalid types
 #[derive(Debug, Diagnostic, Error)]
 #[error("invalid type, expected {expected_type}")]
@@ -77,6 +93,7 @@ pub struct InvalidType {
     pub expected_type: KdlType,
 }
 
+#[cfg(feature = "kdl")]
 /// Error for missing mandatory properties
 #[derive(Debug, Diagnostic, Error)]
 #[error("missing property: {id}")]
@@ -91,6 +108,7 @@ pub struct MissingProperty {
     pub advice: Option<String>,
 }
 
+#[cfg(feature = "kdl")]
 /// Error for missing mandatory properties
 #[derive(Debug, Diagnostic, Error)]
 #[error("missing entry: {id}")]
@@ -105,6 +123,7 @@ pub struct MissingEntry {
     pub advice: Option<String>,
 }
 
+#[cfg(feature = "kdl")]
 /// Error for unsupported node types
 #[derive(Debug, Diagnostic, Error)]
 #[error("unsupported node: {name}")]
@@ -116,6 +135,7 @@ pub struct UnsupportedNode {
     pub name: String,
 }
 
+#[cfg(feature = "kdl")]
 /// Error for unsupported values
 #[derive(Debug, Diagnostic, Error)]
 #[error("unsupported value")]
@@ -128,6 +148,7 @@ pub struct UnsupportedValue {
     pub advice: Option<String>,
 }
 
+#[cfg(feature = "kdl")]
 /// Error for invalid arguments
 #[derive(Debug, Diagnostic, Error)]
 #[error("invalid arguments")]
@@ -140,6 +161,7 @@ pub struct InvalidArguments {
     pub advice: Option<String>,
 }
 
+#[cfg(feature = "kdl")]
 /// Error for missing types
 #[derive(Debug, Diagnostic, Error)]
 #[error("missing type")]

crates/types/src/filesystem.rs

@@ -5,8 +5,10 @@
 
 use std::{fmt, str::FromStr};
 
+#[cfg(feature = "kdl")]
 use crate::{get_kdl_entry, kdl_value_to_integer, kdl_value_to_string};
 
+#[cfg(feature = "kdl")]
 use super::FromKdlProperty;
 
 /// The filesystem information for a partition
@@ -57,6 +59,7 @@ impl FromStr for StandardFilesystemType {
     }
 }
 
+#[cfg(feature = "kdl")]
 impl FromKdlProperty<'_> for StandardFilesystemType {
     fn from_kdl_property(entry: &kdl::KdlEntry) -> Result<Self, crate::Error> {
         let value = kdl_value_to_string(entry)?;
@@ -68,6 +71,7 @@ impl FromKdlProperty<'_> for StandardFilesystemType {
     }
 }
 
+#[cfg(feature = "kdl")]
 impl Filesystem {
     pub fn from_kdl_node(node: &kdl::KdlNode) -> Result<Self, crate::Error> {
         let mut fs_type = None;

crates/types/src/kdl_helpers.rs

@@ -2,9 +2,59 @@
 //
 // SPDX-License-Identifier: MPL-2.0
 
-use kdl::{KdlEntry, KdlNode, NodeKey};
+use std::fmt;
 
-use crate::{Error, FromKdlType, InvalidType, KdlType, MissingEntry, MissingProperty, StorageUnit};
+use crate::{Error, InvalidType, MissingEntry, MissingProperty, StorageUnit};
+use kdl::{KdlEntry, KdlNode, KdlValue, NodeKey};
+
+/// The type of a KDL value
+#[derive(Debug)]
+pub enum KdlType {
+    /// A boolean value
+    Boolean,
+    /// A string value
+    String,
+    /// A null value
+    Null,
+    /// An integer value
+    Integer,
+}
+
+impl KdlType {
+    // Determine the kdl value type
+    pub fn for_value(value: &KdlValue) -> Result<Self, Error> {
+        if value.is_bool() {
+            Ok(Self::Boolean)
+        } else if value.is_string() {
+            Ok(Self::String)
+        } else if value.is_null() {
+            Ok(Self::Null)
+        } else if value.is_integer() {
+            Ok(Self::Integer)
+        } else {
+            Err(Error::UnknownType)
+        }
+    }
+}
+
+impl fmt::Display for KdlType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            KdlType::Boolean => f.write_str("boolean"),
+            KdlType::String => f.write_str("string"),
+            KdlType::Null => f.write_str("null"),
+            KdlType::Integer => f.write_str("int"),
+        }
+    }
+}
+
+pub trait FromKdlProperty<'a>: Sized {
+    fn from_kdl_property(entry: &'a KdlEntry) -> Result<Self, Error>;
+}
+
+pub trait FromKdlType<'a>: Sized {
+    fn from_kdl_type(id: &'a KdlEntry) -> Result<Self, Error>;
+}
 
 // Get a property from a node
 pub fn get_kdl_property<'a>(node: &'a KdlNode, name: &'static str) -> Result<&'a KdlEntry, Error> {

crates/types/src/lib.rs

@@ -3,11 +3,9 @@
 //
 // SPDX-License-Identifier: MPL-2.0
 
-use std::fmt;
-
-use kdl::{KdlEntry, KdlValue};
-
+#[cfg(feature = "kdl")]
 mod kdl_helpers;
+#[cfg(feature = "kdl")]
 pub use kdl_helpers::*;
 mod errors;
 pub use errors::*;
@@ -27,52 +25,3 @@ pub mod filesystem;
 pub use filesystem::*;
 mod partition_type;
 pub use partition_type::*;
-
-/// The type of a KDL value
-#[derive(Debug)]
-pub enum KdlType {
-    /// A boolean value
-    Boolean,
-    /// A string value
-    String,
-    /// A null value
-    Null,
-    /// An integer value
-    Integer,
-}
-
-impl KdlType {
-    // Determine the kdl value type
-    pub fn for_value(value: &KdlValue) -> Result<Self, Error> {
-        if value.is_bool() {
-            Ok(Self::Boolean)
-        } else if value.is_string() {
-            Ok(Self::String)
-        } else if value.is_null() {
-            Ok(Self::Null)
-        } else if value.is_integer() {
-            Ok(Self::Integer)
-        } else {
-            Err(Error::UnknownType)
-        }
-    }
-}
-
-impl fmt::Display for KdlType {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            KdlType::Boolean => f.write_str("boolean"),
-            KdlType::String => f.write_str("string"),
-            KdlType::Null => f.write_str("null"),
-            KdlType::Integer => f.write_str("int"),
-        }
-    }
-}
-
-pub trait FromKdlProperty<'a>: Sized {
-    fn from_kdl_property(entry: &'a KdlEntry) -> Result<Self, Error>;
-}
-
-pub trait FromKdlType<'a>: Sized {
-    fn from_kdl_type(id: &'a KdlEntry) -> Result<Self, Error>;
-}

crates/types/src/partition_role.rs

@@ -5,8 +5,10 @@
 
 use std::{fmt, str::FromStr};
 
+#[cfg(feature = "kdl")]
 use crate::kdl_value_to_string;
 
+#[cfg(feature = "kdl")]
 use super::FromKdlProperty;
 
 /// The role assigned to a partition
@@ -68,6 +70,7 @@ impl FromStr for PartitionRole {
     }
 }
 
+#[cfg(feature = "kdl")]
 impl FromKdlProperty<'_> for PartitionRole {
     fn from_kdl_property(entry: &kdl::KdlEntry) -> Result<Self, crate::Error> {
         let value = kdl_value_to_string(entry)?;

crates/types/src/partition_table.rs

@@ -5,9 +5,10 @@
 
 use std::{fmt, str::FromStr};
 
-use crate::kdl_value_to_string;
-
+#[cfg(feature = "kdl")]
 use super::FromKdlProperty;
+#[cfg(feature = "kdl")]
+use crate::kdl_value_to_string;
 
 /// The type of partition table to create
 #[derive(Debug, PartialEq)]
@@ -41,6 +42,7 @@ impl FromStr for PartitionTableType {
     }
 }
 
+#[cfg(feature = "kdl")]
 impl FromKdlProperty<'_> for PartitionTableType {
     fn from_kdl_property(entry: &kdl::KdlEntry) -> Result<Self, crate::Error> {
         let value = kdl_value_to_string(entry)?;