Refactor/project structure (#3085)

* refactor project structure * environment-based default registry * fix tests * update build container * use docker platform for iso build emulation * simplify compat * Fix docker platform spec in run-compat.sh * handle riscv compat * fix bug with dep error exists attr * undo removal of sorting * use qemu for iso stage --------- Co-authored-by: Mariusz Kogen <k0gen@pm.me> Co-authored-by: Matt Hill <mattnine@protonmail.com>
2026-04-01 21:13:09 +00:00 · 2025-12-22 13:39:38 -07:00
parent eda08d5b0f
commit 96ae532879
389 changed files with 744 additions and 4005 deletions
--- a/core/src/disk/mod.rs
+++ b/core/src/disk/mod.rs
@@ -0,0 +1,136 @@
+use std::path::{Path, PathBuf};
+
+use itertools::Itertools;
+use lazy_format::lazy_format;
+use rpc_toolkit::{CallRemoteHandler, Context, Empty, HandlerExt, ParentHandler, from_fn_async};
+use serde::{Deserialize, Serialize};
+
+use crate::Error;
+use crate::context::{CliContext, RpcContext};
+use crate::disk::util::DiskInfo;
+use crate::util::serde::{HandlerExtSerde, WithIoFormat, display_serializable};
+
+pub mod fsck;
+pub mod main;
+pub mod mount;
+pub mod util;
+
+pub const BOOT_RW_PATH: &str = "/media/boot-rw";
+pub const REPAIR_DISK_PATH: &str = "/media/startos/config/repair-disk";
+
+#[derive(Clone, Debug, Default, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct OsPartitionInfo {
+    pub efi: Option<PathBuf>,
+    pub bios: Option<PathBuf>,
+    pub boot: PathBuf,
+    pub root: PathBuf,
+}
+impl OsPartitionInfo {
+    pub fn contains(&self, logicalname: impl AsRef<Path>) -> bool {
+        self.efi
+            .as_ref()
+            .map(|p| p == logicalname.as_ref())
+            .unwrap_or(false)
+            || self
+                .bios
+                .as_ref()
+                .map(|p| p == logicalname.as_ref())
+                .unwrap_or(false)
+            || &*self.boot == logicalname.as_ref()
+            || &*self.root == logicalname.as_ref()
+    }
+}
+
+pub fn disk<C: Context>() -> ParentHandler<C> {
+    ParentHandler::new()
+        .subcommand(
+            "list",
+            from_fn_async(list)
+                .with_display_serializable()
+                .with_custom_display_fn(|handle, result| display_disk_info(handle.params, result))
+                .with_about("List disk info")
+                .with_call_remote::<CliContext>(),
+        )
+        .subcommand("repair", from_fn_async(|_: C| repair()).no_cli())
+        .subcommand(
+            "repair",
+            CallRemoteHandler::<CliContext, _, _>::new(
+                from_fn_async(|_: RpcContext| repair())
+                    .no_display()
+                    .with_about("Repair disk in the event of corruption"),
+            ),
+        )
+}
+
+fn display_disk_info(params: WithIoFormat<Empty>, args: Vec<DiskInfo>) -> Result<(), Error> {
+    use prettytable::*;
+
+    if let Some(format) = params.format {
+        return display_serializable(format, args);
+    }
+
+    let mut table = Table::new();
+    table.add_row(row![bc =>
+        "LOGICALNAME",
+        "LABEL",
+        "CAPACITY",
+        "USED",
+        "STARTOS VERSION"
+    ]);
+    for disk in args {
+        let row = row![
+            disk.logicalname.display(),
+            "N/A",
+            &format!("{:.2} GiB", disk.capacity as f64 / 1024.0 / 1024.0 / 1024.0),
+            "N/A",
+            "N/A",
+        ];
+        table.add_row(row);
+        for part in disk.partitions {
+            let row = row![
+                part.logicalname.display(),
+                if let Some(label) = part.label.as_ref() {
+                    label
+                } else {
+                    "N/A"
+                },
+                part.capacity,
+                &if let Some(used) = part
+                    .used
+                    .map(|u| format!("{:.2} GiB", u as f64 / 1024.0 / 1024.0 / 1024.0))
+                {
+                    used
+                } else {
+                    "N/A".to_owned()
+                },
+                &if part.start_os.is_empty() {
+                    "N/A".to_owned()
+                } else if part.start_os.len() == 1 {
+                    part.start_os
+                        .first_key_value()
+                        .map(|(_, info)| info.version.to_string())
+                        .unwrap()
+                } else {
+                    part.start_os
+                        .iter()
+                        .map(|(id, info)| lazy_format!("{} ({})", info.version, id))
+                        .join(", ")
+                },
+            ];
+            table.add_row(row);
+        }
+    }
+    table.print_tty(false)?;
+    Ok(())
+}
+
+// #[command(display(display_disk_info))]
+pub async fn list(ctx: RpcContext, _: Empty) -> Result<Vec<DiskInfo>, Error> {
+    crate::disk::util::list(&ctx.os_partitions).await
+}
+
+pub async fn repair() -> Result<(), Error> {
+    tokio::fs::write(REPAIR_DISK_PATH, b"").await?;
+    Ok(())
+}