provisioning: Expose the roles/filesystems for mounts + formatting

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

Author: ikeycode

Cargo.lock

@@ -58,6 +58,14 @@ fn apply_partitioning(whence: &Path) -> Result<(), Box<dyn std::error::Error>> {
         disk_writer.write()?;
     }
 
+    for (device, fs) in plan.filesystems.iter() {
+        eprintln!("To format: {:?} with {:?}", device, fs);
+    }
+
+    for (role, device) in plan.role_mounts.iter() {
+        eprintln!("To mount: {:?} as {:?} (`{}`)", device, role, role.as_path());
+    }
+
     Ok(())
 }
 

crates/disktester/src/main.rs

@@ -6,6 +6,7 @@ description = "A library for working directly with partitions"
 
 [dependencies]
 disks = { path = "../disks" }
+types = { path = "../types" }
 thiserror.workspace = true
 log.workspace = true
 gpt.workspace = true

crates/partitioning/Cargo.toml

@@ -3,6 +3,7 @@
 // SPDX-License-Identifier: MPL-2.0
 
 use gpt::partition_types;
+use types::{Filesystem, PartitionRole};
 use uuid::Uuid;
 
 /// Represents the table attributes of a GPT partition
@@ -51,4 +52,6 @@ impl TableAttributes {
 #[derive(Debug, Clone)]
 pub struct PartitionAttributes {
     pub table: TableAttributes,
+    pub role: Option<PartitionRole>,
+    pub filesystem: Option<Filesystem>,
 }

crates/partitioning/src/attributes.rs

@@ -92,6 +92,8 @@ pub struct Region {
 
     /// The partition ID of this region if it represents a partition
     pub partition_id: Option<u32>,
+
+    pub attributes: Option<PartitionAttributes>,
 }
 
 /// partitions aligned to 1MiB boundaries. This helps ensure optimal
@@ -109,6 +111,7 @@ impl Region {
             start,
             end,
             partition_id: None,
+            attributes: None,
         }
     }
 
@@ -319,14 +322,15 @@ impl Planner {
                 start,
                 end,
                 partition_id,
-                ..
+                attributes,
             } = change
             {
                 debug!("Adding partition {}..{} (ID: {})", start, end, partition_id);
                 layout.push(Region {
                     start: *start,
                     end: *end,
                     partition_id: Some(*partition_id),
+                    attributes: attributes.clone(),
                 });
             }
         }

crates/partitioning/src/planner.rs

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

crates/provisioning/Cargo.toml

@@ -43,6 +43,8 @@ impl Command {
                 name: self.partition_type.as_ref().map(|p| p.to_string()),
                 uuid: None,
             }),
+            role: self.role.clone(),
+            filesystem: self.filesystem.clone(),
         }
     }
 }

crates/provisioning/src/commands/create_partition.rs

@@ -11,18 +11,11 @@ use miette::{Diagnostic, NamedSource, Severity};
 mod provisioner;
 pub use provisioner::*;
 
-mod errors;
-pub use errors::*;
-
-mod helpers;
-use helpers::*;
-
-mod types;
-pub use types::*;
-
 mod commands;
 use commands::*;
 
+pub use types::*;
+
 /// Command evaluation context
 pub struct Context<'a> {
     /// The node being parsed

crates/provisioning/src/lib.rs

@@ -3,14 +3,15 @@
 //
 // SPDX-License-Identifier: MPL-2.0
 
-use std::collections::HashMap;
+use std::{collections::HashMap, path::PathBuf};
 
 use disks::BlockDevice;
 use log::{debug, info, trace, warn};
 use partitioning::{
     planner::{Planner, PARTITION_ALIGNMENT},
     strategy::{AllocationStrategy, PartitionRequest, SizeRequirement, Strategy},
 };
+use types::{Filesystem, PartitionRole};
 
 use crate::{commands::Command, Constraints, StrategyDefinition};
 
@@ -27,6 +28,12 @@ pub struct Provisioner {
 pub struct Plan<'a> {
     pub strategy: &'a StrategyDefinition,
     pub device_assignments: HashMap<String, DevicePlan<'a>>,
+
+    // Global mount points
+    pub role_mounts: HashMap<PartitionRole, PathBuf>,
+
+    // Filesystems to be formatted
+    pub filesystems: HashMap<PathBuf, Filesystem>,
 }
 
 #[derive(Debug, Clone)]
@@ -172,18 +179,36 @@ impl Provisioner {
             }
         }
 
+        let mut role_mounts = HashMap::new();
+        let mut filesystems = HashMap::new();
+
         // OK lets now apply any mutations to the device assignments
         for (disk_name, device_plan) in device_assignments.iter_mut() {
             debug!("Applying device plan for disk {}", disk_name);
             if let Err(e) = device_plan.strategy.apply(&mut device_plan.planner) {
                 warn!("Failed to apply strategy for disk {}: {:?}", disk_name, e);
             }
+            for region in device_plan.planner.current_layout().iter() {
+                if let Some(id) = region.partition_id {
+                    let device_path = device_plan.device.partition_path(id as usize);
+                    if let Some(attributes) = region.attributes.as_ref() {
+                        if let Some(role) = attributes.role.as_ref() {
+                            role_mounts.insert(role.clone(), device_path.clone());
+                        }
+                        if let Some(fs) = attributes.filesystem.as_ref() {
+                            filesystems.insert(device_path, fs.clone());
+                        }
+                    }
+                }
+            }
         }
 
         // All commands processed successfully - create a plan
         debug!("Creating final plan for strategy {}", strategy.name);
         plans.push(Plan {
             strategy,
+            role_mounts,
+            filesystems,
             device_assignments: device_assignments.clone(),
         });
     }

crates/provisioning/src/provisioner.rs

@@ -0,0 +1,11 @@
+[package]
+name = "types"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+kdl.workspace = true
+thiserror.workspace = true
+miette.workspace = true
+gpt.workspace = true
+uuid.workspace = true