Merge branch 'development' of github.com:crystal-linux/jade into development

src/args.rs

@@ -154,7 +154,6 @@ pub fn parse_partitions(s: &str) -> Result<Partition, &'static str> {
     ))
 }
 
-
 #[derive(Debug, ArgEnum, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Serialize, Deserialize)]
 pub enum PartitionMode {
     #[clap(name = "auto")]

src/functions/base.rs

@@ -1,30 +1,29 @@
 use crate::internal::exec::*;
-use crate::internal::*;
 use crate::internal::files::append_file;
-use std::path::PathBuf;
+use crate::internal::*;
 use log::warn;
+use std::path::PathBuf;
 
 pub fn install_base_packages(kernel: String) {
-    let kernel_to_install: String;
     std::fs::create_dir_all("/mnt/etc").unwrap();
     files::copy_file("/etc/pacman.conf", "/mnt/etc/pacman.conf");
-    if kernel.is_empty() {
+    let kernel_to_install = if kernel.is_empty() {
-        kernel_to_install = "linux".to_string();
+        "linux"
     } else {
         match kernel.as_str() {
-            "linux" => kernel_to_install = "linux".to_string(),
+            "linux" => "linux",
-            "linux-lts" => kernel_to_install = "linux-lts".to_string(),
+            "linux-lts" => "linux-lts",
-            "linux-zen" => kernel_to_install = "linux-zen".to_string(),
+            "linux-zen" => "linux-zen",
-            "linux-hardened" => kernel_to_install = "linux-hardened".to_string(),
+            "linux-hardened" => "linux-hardened",
             _ => {
                 warn!("Unknown kernel: {}, using default instead", kernel);
-                kernel_to_install = "linux".to_string();
+                "linux"
-            }
             }
         }
+    };
     install::install(vec![
         "base",
-        kernel_to_install.as_str(),
+        kernel_to_install,
         "linux-firmware",
         "systemd-sysvcompat",
         "networkmanager",
@@ -55,7 +54,13 @@ pub fn genfstab() {
 }
 
 pub fn install_bootloader_efi(efidir: PathBuf) {
-    install::install(vec!["grub", "efibootmgr", "grub-btrfs", "crystal-grub-theme", "os-prober"]);
+    install::install(vec![
+        "grub",
+        "efibootmgr",
+        "grub-btrfs",
+        "crystal-grub-theme",
+        "os-prober",
+    ]);
     let efidir = std::path::Path::new("/mnt").join(efidir);
     let efi_str = efidir.to_str().unwrap();
     if !std::path::Path::new(&format!("/mnt{efi_str}")).exists() {
@@ -85,8 +90,11 @@ pub fn install_bootloader_efi(efidir: PathBuf) {
         "install grub as efi without --removable",
     );
     files_eval(
-        append_file("/mnt/etc/default/grub", "GRUB_THEME=\"/usr/share/grub/themes/crystal/theme.txt\""),
+        append_file(
-        "enable crystal grub theme"
+            "/mnt/etc/default/grub",
+            "GRUB_THEME=\"/usr/share/grub/themes/crystal/theme.txt\"",
+        ),
+        "enable crystal grub theme",
     );
     exec_eval(
         exec_chroot(
@@ -98,7 +106,12 @@ pub fn install_bootloader_efi(efidir: PathBuf) {
 }
 
 pub fn install_bootloader_legacy(device: PathBuf) {
-    install::install(vec!["grub", "grub-btrfs", "crystal-grub-theme", "os-prober"]);
+    install::install(vec![
+        "grub",
+        "grub-btrfs",
+        "crystal-grub-theme",
+        "os-prober",
+    ]);
     if !device.exists() {
         crash(format!("The device {device:?} does not exist"), 1);
     }
@@ -111,8 +124,11 @@ pub fn install_bootloader_legacy(device: PathBuf) {
         "install grub as legacy",
     );
     files_eval(
-        append_file("/mnt/etc/default/grub", "GRUB_THEME=\"/usr/share/grub/themes/crystal/theme.txt\""),
+        append_file(
-        "enable crystal grub theme"
+            "/mnt/etc/default/grub",
+            "GRUB_THEME=\"/usr/share/grub/themes/crystal/theme.txt\"",
+        ),
+        "enable crystal grub theme",
     );
     exec_eval(
         exec_chroot(
@@ -138,7 +154,15 @@ pub fn install_homemgr() {
 pub fn install_flatpak() {
     install(vec!["flatpak"]);
     exec_eval(
-        exec_chroot("flatpak", vec![String::from("remote-add"), String::from("--if-not-exists"), String::from("flathub"), String::from("https://flathub.org/repo/flathub.flatpakrepo")]),
+        exec_chroot(
+            "flatpak",
+            vec![
+                String::from("remote-add"),
+                String::from("--if-not-exists"),
+                String::from("flathub"),
+                String::from("https://flathub.org/repo/flathub.flatpakrepo"),
+            ],
+        ),
         "add flathub remote",
     )
 }

src/functions/mod.rs

@@ -3,5 +3,5 @@ pub mod desktops;
 pub mod locale;
 pub mod network;
 pub mod partition;
-pub mod users;
 pub mod unakite;
+pub mod users;

src/functions/partition.rs

@@ -1,5 +1,5 @@
-use crate::args::PartitionMode;
 use crate::args;
+use crate::args::PartitionMode;
 use crate::internal::exec::*;
 use crate::internal::*;
 use std::path::{Path, PathBuf};
@@ -9,8 +9,7 @@ mkfs.btrfs mkfs.ext2  mkfs.ext4  mkfs.minix mkfs.vfat */
 
 pub fn fmt_mount(mountpoint: &str, filesystem: &str, blockdevice: &str) {
     match filesystem {
-        "vfat" => {
+        "vfat" => exec_eval(
-            exec_eval(
             exec(
                 "mkfs.vfat",
                 vec![
@@ -20,119 +19,50 @@ pub fn fmt_mount(mountpoint: &str, filesystem: &str, blockdevice: &str) {
                 ],
             ),
             format!("Formatting {blockdevice} as vfat").as_str(),
-            )
-        }
-        "bfs" => {
-            exec_eval(
-                exec(
-                    "mkfs.bfs",
-                    vec![
-                        String::from(blockdevice),
-                    ],
         ),
+        "bfs" => exec_eval(
+            exec("mkfs.bfs", vec![String::from(blockdevice)]),
             format!("Formatting {blockdevice} as bfs").as_str(),
-            )
-        }
-        "cramfs" => {
-            exec_eval(
-                exec(
-                    "mkfs.cramfs",
-                    vec![
-                        String::from(blockdevice),
-                    ],
         ),
+        "cramfs" => exec_eval(
+            exec("mkfs.cramfs", vec![String::from(blockdevice)]),
             format!("Formatting {blockdevice} as cramfs").as_str(),
-            )
-        }
-        "ext3" => {
-            exec_eval(
-                exec(
-                    "mkfs.ext3",
-                    vec![
-                        String::from(blockdevice),
-                    ],
         ),
+        "ext3" => exec_eval(
+            exec("mkfs.ext3", vec![String::from(blockdevice)]),
             format!("Formatting {blockdevice} as ext3").as_str(),
-            )
-        }
-        "fat" => {
-            exec_eval(
-                exec(
-                    "mkfs.fat",
-                    vec![
-                        String::from(blockdevice),
-                    ],
         ),
+        "fat" => exec_eval(
+            exec("mkfs.fat", vec![String::from(blockdevice)]),
             format!("Formatting {blockdevice} as fat").as_str(),
-            )
-        }
-        "msdos" => {
-            exec_eval(
-                exec(
-                    "mkfs.msdos",
-                    vec![
-                        String::from(blockdevice),
-                    ],
         ),
+        "msdos" => exec_eval(
+            exec("mkfs.msdos", vec![String::from(blockdevice)]),
             format!("Formatting {blockdevice} as msdos").as_str(),
-            )
-        }
-        "xfs" => {
-            exec_eval(
-                exec(
-                    "mkfs.xfs",
-                    vec![
-                        String::from(blockdevice),
-                    ],
         ),
+        "xfs" => exec_eval(
+            exec("mkfs.xfs", vec![String::from(blockdevice)]),
             format!("Formatting {blockdevice} as xfs").as_str(),
-            )
+        ),
-        }
+        "btrfs" => exec_eval(
-        "btrfs" => {
-            exec_eval(
             exec(
                 "mkfs.btrfs",
-                    vec![
+                vec![String::from("-f"), String::from(blockdevice)],
-                        String::from("-f"),
-                        String::from(blockdevice),
-                    ],
             ),
             format!("Formatting {blockdevice} as btrfs").as_str(),
-            )
-        }
-        "ext2" => {
-            exec_eval(
-                exec(
-                    "mkfs.ext2",
-                    vec![
-                        String::from(blockdevice),
-                    ],
         ),
+        "ext2" => exec_eval(
+            exec("mkfs.ext2", vec![String::from(blockdevice)]),
             format!("Formatting {blockdevice} as ext2").as_str(),
-            )
-        }
-        "ext4" => {
-            exec_eval(
-                exec(
-                    "mkfs.ext4",
-                    vec![
-                        String::from(blockdevice),
-                    ],
         ),
+        "ext4" => exec_eval(
+            exec("mkfs.ext4", vec![String::from(blockdevice)]),
             format!("Formatting {blockdevice} as ext4").as_str(),
-            )
-        }
-        "minix" => {
-            exec_eval(
-                exec(
-                    "mkfs.minix",
-                    vec![
-                        String::from(blockdevice),
-                    ],
         ),
+        "minix" => exec_eval(
+            exec("mkfs.minix", vec![String::from(blockdevice)]),
             format!("Formatting {blockdevice} as minix").as_str(),
-            )
+        ),
-        }
         "don't format" => {
             log::debug!("Not formatting {}", blockdevice);
         }
@@ -147,20 +77,19 @@ pub fn fmt_mount(mountpoint: &str, filesystem: &str, blockdevice: &str) {
         }
     }
     exec_eval(
-        exec(
+        exec("mkdir", vec![String::from("-p"), String::from(mountpoint)]),
-            "mkdir",
-            vec![
-                String::from("-p"),
-                String::from(mountpoint),
-            ],
-        ),
         format!("Creating mountpoint {mountpoint} for {blockdevice}").as_str(),
     );
     mount(blockdevice, mountpoint, "");
 }
 
-pub fn partition(device: PathBuf, mode: PartitionMode, efi: bool, partitions: &mut Vec<args::Partition>, unakite: bool) {
+pub fn partition(
-
+    device: PathBuf,
+    mode: PartitionMode,
+    efi: bool,
+    partitions: &mut Vec<args::Partition>,
+    unakite: bool,
+) {
     println!("{:?}", mode);
     match mode {
         PartitionMode::Auto => {

src/functions/unakite.rs

@@ -1,11 +1,16 @@
+use crate::args::DesktopSetup;
+use crate::functions::partition::mount;
+use crate::functions::*;
 use crate::internal::exec::*;
 use crate::internal::*;
-use crate::functions::*;
-use crate::functions::partition::mount;
 use std::path::PathBuf;
-use crate::args::DesktopSetup;
 pub fn install_bootloader_efi(efidir: PathBuf) {
-    install::install(vec!["grub", "efibootmgr", "grub-btrfs", "crystal-grub-theme"]);
+    install::install(vec![
+        "grub",
+        "efibootmgr",
+        "grub-btrfs",
+        "crystal-grub-theme",
+    ]);
     let efidir = std::path::Path::new("/mnt").join(efidir);
     let efi_str = efidir.to_str().unwrap();
     if !std::path::Path::new(&format!("/mnt{efi_str}")).exists() {
@@ -35,8 +40,11 @@ pub fn install_bootloader_efi(efidir: PathBuf) {
         "install unakite grub as efi without --removable",
     );
     files_eval(
-        files::append_file("/mnt/etc/default/grub", "GRUB_THEME=\"/usr/share/grub/themes/crystal/theme.txt\""),
+        files::append_file(
-        "enable crystal grub theme"
+            "/mnt/etc/default/grub",
+            "GRUB_THEME=\"/usr/share/grub/themes/crystal/theme.txt\"",
+        ),
+        "enable crystal grub theme",
     );
     exec_eval(
         exec_chroot(
@@ -50,88 +58,52 @@ pub fn install_bootloader_efi(efidir: PathBuf) {
 pub fn remount(root: &str, oldroot: &str, efi: bool, efidir: &str, bootdev: &str, firstrun: bool) {
     if efi && firstrun {
         exec_eval(
-            exec(
+            exec("umount", vec![String::from(bootdev)]),
-                "umount",
-                vec![String::from(bootdev)],
-            ),
             &format!("Unmount {}", bootdev),
         );
         exec_eval(
-            exec(
+            exec("umount", vec![String::from(oldroot)]),
-                "umount",
-                vec![String::from(oldroot)],
-            ),
             "Unmount old root",
         );
         mount(root, "/mnt", "");
         exec_eval(
-            exec(
+            exec("mkdir", vec![String::from("-p"), String::from(efidir)]),
-                "mkdir",
-                vec![
-                    String::from("-p"),
-                    String::from(efidir),
-                ],
-            ),
             format!("Creating mountpoint {efidir} for {bootdev}").as_str(),
         );
         mount(bootdev, efidir, "");
     } else if efi && !firstrun {
         exec_eval(
-            exec(
+            exec("umount", vec![String::from(bootdev)]),
-                "umount",
-                vec![String::from(bootdev)],
-            ),
             &format!("Unmount {}", bootdev),
         );
         exec_eval(
-            exec(
+            exec("umount", vec![String::from(root)]),
-                "umount",
-                vec![String::from(root)],
-            ),
             "Unmount unakite root",
         );
         mount(oldroot, "/mnt", "");
         mount(bootdev, efidir, "");
     } else if !efi && firstrun {
         exec_eval(
-            exec(
+            exec("umount", vec![String::from(bootdev)]),
-                "umount",
-                vec![String::from(bootdev)],
-            ),
             &format!("Unmount {}", bootdev),
         );
         exec_eval(
-            exec(
+            exec("umount", vec![String::from(oldroot)]),
-                "umount",
-                vec![String::from(oldroot)],
-            ),
             "Unmount old root",
         );
         mount(root, "/mnt", "");
         exec_eval(
-            exec(
+            exec("mkdir", vec![String::from("-p"), String::from("/mnt/boot")]),
-                "mkdir",
-                vec![
-                    String::from("-p"),
-                    String::from("/mnt/boot"),
-                ],
-            ),
             format!("Creating mountpoint /boot for {bootdev}").as_str(),
         );
         mount(bootdev, "/mnt/boot", "");
     } else if !efi && !firstrun {
         exec_eval(
-            exec(
+            exec("umount", vec![String::from(bootdev)]),
-                "umount",
-                vec![String::from(bootdev)],
-            ),
             &format!("Unmount {}", bootdev),
         );
         exec_eval(
-            exec(
+            exec("umount", vec![String::from(root)]),
-                "umount",
-                vec![String::from(root)],
-            ),
             "Unmount unakite root",
         );
         mount(oldroot, "/mnt", "");
@@ -192,7 +164,7 @@ pub fn setup_unakite(root: &str, oldroot: &str, efi: bool, efidir: &str, bootdev
             vec![
                 String::from("/tmp/jade.json"),
                 String::from("/mnt/etc/installSettings.json"),
-            ]
+            ],
         ),
         "Copy jade.json to /etc/installSettings.json in unakite",
     );
@@ -202,6 +174,6 @@ pub fn setup_unakite(root: &str, oldroot: &str, efi: bool, efidir: &str, bootdev
             "grub-mkconfig",
             vec![String::from("-o"), String::from("/boot/grub/grub.cfg")],
         ),
-        "Recreate grub.cfg in crystal"
+        "Recreate grub.cfg in crystal",
     );
 }

src/functions/users.rs

@@ -49,15 +49,10 @@ pub fn new_user(username: &str, hasroot: bool, password: &str, do_hash_pass: boo
 
 pub fn hash_pass(password: &str) -> std::process::Output {
     let output = Command::new("openssl")
-        .args([
+        .args(["passwd", "-1", password])
-            "passwd",
-            "-1",
-            password
-        ])
         .output()
         .expect("Failed to hash password");
     output
-
 }
 
 pub fn root_pass(root_pass: &str) {
@@ -66,9 +61,7 @@ pub fn root_pass(root_pass: &str) {
             "bash",
             vec![
                 String::from("-c"),
-                format!(
+                format!(r#"'usermod --password {root_pass} root'"#),
-                    r#"'usermod --password {root_pass} root'"#
-                ),
             ],
         ),
         "set root password",

src/internal/config.rs

@@ -1,5 +1,5 @@
-use crate::args::{DesktopSetup, PartitionMode};
 use crate::args;
+use crate::args::{DesktopSetup, PartitionMode};
 use crate::functions::*;
 use crate::internal::*;
 use serde::{Deserialize, Serialize};
@@ -105,7 +105,7 @@ pub fn read_config(configpath: PathBuf) {
         config.partition.mode,
         config.partition.efi,
         &mut partitions,
-        config.unakite.enable
+        config.unakite.enable,
     );
     base::install_base_packages(config.kernel);
     base::genfstab();
@@ -183,20 +183,66 @@ pub fn read_config(configpath: PathBuf) {
     }
     install(extra_packages);
     log::info!("Setup unakite");
-    if config.partition.mode == PartitionMode::Auto && !config.partition.efi && config.unakite.enable && !config.partition.device.to_string().contains("nvme") {
+    if config.partition.mode == PartitionMode::Auto
+        && !config.partition.efi
+        && config.unakite.enable
+        && !config.partition.device.to_string().contains("nvme")
+    {
         let root = PathBuf::from("/dev/").join(config.partition.device.as_str());
-        unakite::setup_unakite(format!("{}2",root.to_str().unwrap()).as_str(), format!("{}3",root.to_str().unwrap()).as_str(), config.partition.efi, "/boot", format!("{}1",root.to_str().unwrap()).as_str())
+        unakite::setup_unakite(
-    } else if config.partition.mode == PartitionMode::Auto && config.partition.efi && config.unakite.enable && !config.partition.device.to_string().contains("nvme") {
+            format!("{}2", root.to_str().unwrap()).as_str(),
+            format!("{}3", root.to_str().unwrap()).as_str(),
+            config.partition.efi,
+            "/boot",
+            format!("{}1", root.to_str().unwrap()).as_str(),
+        )
+    } else if config.partition.mode == PartitionMode::Auto
+        && config.partition.efi
+        && config.unakite.enable
+        && !config.partition.device.to_string().contains("nvme")
+    {
         let root = PathBuf::from("/dev/").join(config.partition.device.as_str());
-        unakite::setup_unakite(format!("{}2",root.to_str().unwrap()).as_str(), format!("{}3",root.to_str().unwrap()).as_str(), config.partition.efi, "/boot/efi", format!("{}1",root.to_str().unwrap()).as_str())
+        unakite::setup_unakite(
+            format!("{}2", root.to_str().unwrap()).as_str(),
+            format!("{}3", root.to_str().unwrap()).as_str(),
+            config.partition.efi,
+            "/boot/efi",
+            format!("{}1", root.to_str().unwrap()).as_str(),
+        )
     } else if config.unakite.enable {
-        unakite::setup_unakite(&config.unakite.root, &config.unakite.oldroot, config.partition.efi, &config.unakite.efidir, &config.unakite.bootdev);
+        unakite::setup_unakite(
-    } else if config.partition.mode == PartitionMode::Auto && config.partition.efi && config.unakite.enable && config.partition.device.to_string().contains("nvme") {
+            &config.unakite.root,
+            &config.unakite.oldroot,
+            config.partition.efi,
+            &config.unakite.efidir,
+            &config.unakite.bootdev,
+        );
+    } else if config.partition.mode == PartitionMode::Auto
+        && config.partition.efi
+        && config.unakite.enable
+        && config.partition.device.to_string().contains("nvme")
+    {
         let root = PathBuf::from("/dev/").join(config.partition.device.as_str());
-        unakite::setup_unakite(format!("{}p2",root.to_str().unwrap()).as_str(), format!("{}p3",root.to_str().unwrap()).as_str(), config.partition.efi, "/boot/efi", format!("{}p1",root.to_str().unwrap()).as_str())
+        unakite::setup_unakite(
-    } else if config.partition.mode == PartitionMode::Auto && !config.partition.efi && config.unakite.enable && config.partition.device.to_string().contains("nvme") {
+            format!("{}p2", root.to_str().unwrap()).as_str(),
+            format!("{}p3", root.to_str().unwrap()).as_str(),
+            config.partition.efi,
+            "/boot/efi",
+            format!("{}p1", root.to_str().unwrap()).as_str(),
+        )
+    } else if config.partition.mode == PartitionMode::Auto
+        && !config.partition.efi
+        && config.unakite.enable
+        && config.partition.device.to_string().contains("nvme")
+    {
         let root = PathBuf::from("/dev/").join(config.partition.device.as_str());
-        unakite::setup_unakite(format!("{}p2",root.to_str().unwrap()).as_str(), format!("{}p3",root.to_str().unwrap()).as_str(), config.partition.efi, "/boot", format!("{}p1",root.to_str().unwrap()).as_str())
+        unakite::setup_unakite(
+            format!("{}p2", root.to_str().unwrap()).as_str(),
+            format!("{}p3", root.to_str().unwrap()).as_str(),
+            config.partition.efi,
+            "/boot",
+            format!("{}p1", root.to_str().unwrap()).as_str(),
+        )
     } else {
         log::info!("Unakite disabled");
     }

src/main.rs

@@ -14,12 +14,16 @@ fn main() {
     match opt.command {
         Command::Partition(args) => {
             let mut partitions = args.partitions;
-            partition::partition(args.device, args.mode, args.efi, &mut partitions, args.unakite);
+            partition::partition(
+                args.device,
+                args.mode,
+                args.efi,
+                &mut partitions,
+                args.unakite,
+            );
         }
         Command::InstallBase(args) => {
-            base::install_base_packages(
+            base::install_base_packages(args.kernel);
-                args.kernel,
-            );
         }
         Command::GenFstab => {
             base::genfstab();
@@ -57,7 +61,7 @@ fn main() {
         },
         Command::Nix => {
             base::install_homemgr();
-        },
+        }
         Command::Flatpak => {
             base::install_flatpak();
         }
@@ -69,7 +73,7 @@ fn main() {
                 &args.efidir,
                 &args.bootdev,
             );
-        },
+        }
         Command::Config { config } => {
             crate::internal::config::read_config(config);
         }