crystal-linux-mirror
/
jade
mirror of https://git.getcryst.al/crystal/software/jade.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #10 from crystal-linux/development

Browse Source 
Merge development into main
axtloss/rework-partitioning
axtloss 2 years ago committed by GitHub
parent c02b6f159a 3a0d8a5088
commit 7d966b0fde
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
11 changed files with 234 additions and 245 deletions
Show Stats Download Patch File Download Diff File

8
README.md
Unescape Escape View File

@ -68,18 +68,16 @@ jade networking getcryst.al --ipv6
### configure users ### configure users
```sh ```sh
# make a new user called nonRootHaver, without sudo and easytohack as the password # make a new user called nonRootHaver, without sudo and easytohack as the password
# jade uses prehashed passwords for user creation, so you'll have to calculate the hash of the password jade users newUser nonRootHaver easytohack
jade users newUser nonRootHaver $(openssl passwd -6 easytohack)
# make a user called rootHaver, with sudo and omgsosuperhardtohack as the password # make a user called rootHaver, with sudo and omgsosuperhardtohack as the password
jade users newUser rootHaver $(openssl passwd -6 omgsuperhardtohack) --sudoer jade users newUser rootHaver omgsuperhardtohack --sudoer
``` ```
### set root password ### set root password
```sh ```sh
# set the root password to 'muchSecurity,veryHardToHack' # set the root password to 'muchSecurity,veryHardToHack'
# the same hashing thing goes for root passwords jade users rootPass muchSecurity,veryHardToHack
jade users rootPass $(openssl passwd -6 muchSecurity,veryHardToHack)
``` ```
### install a desktop environment ### install a desktop environment

1
src/args.rs
Unescape Escape View File

@ -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)] #[derive(Debug, ArgEnum, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Serialize, Deserialize)]
pub enum PartitionMode { pub enum PartitionMode {
#[clap(name = "auto")] #[clap(name = "auto")]

64
src/functions/base.rs
Unescape Escape View File

@ -1,30 +1,29 @@
use crate::internal::exec::*; use crate::internal::exec::*;
use crate::internal::*;
use crate::internal::files::append_file; use crate::internal::files::append_file;
use std::path::PathBuf; use crate::internal::*;
use log::warn; use log::warn;
use std::path::PathBuf;
pub fn install_base_packages(kernel: String) { pub fn install_base_packages(kernel: String) {
let mut kernel_to_install: String = String::new();
std::fs::create_dir_all("/mnt/etc").unwrap(); std::fs::create_dir_all("/mnt/etc").unwrap();
files::copy_file("/etc/pacman.conf", "/mnt/etc/pacman.conf"); 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 { } else {
match kernel.as_str() { 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); warn!("Unknown kernel: {}, using default instead", kernel);
kernel_to_install = "linux".to_string(); "linux"
} }
} }
} };
install::install(vec![ install::install(vec![
"base", "base",
kernel_to_install.as_str(), kernel_to_install,
"linux-firmware", "linux-firmware",
"systemd-sysvcompat", "systemd-sysvcompat",
"networkmanager", "networkmanager",
@ -55,7 +54,13 @@ pub fn genfstab() {
} }
pub fn install_bootloader_efi(efidir: PathBuf) { 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 efidir = std::path::Path::new("/mnt").join(efidir);
let efi_str = efidir.to_str().unwrap(); let efi_str = efidir.to_str().unwrap();
if !std::path::Path::new(&format!("/mnt{efi_str}")).exists() { if !std::path::Path::new(&format!("/mnt{efi_str}")).exists() {
@ -66,7 +71,7 @@ pub fn install_bootloader_efi(efidir: PathBuf) {
"grub-install", "grub-install",
vec![ vec![
String::from("--target=x86_64-efi"), String::from("--target=x86_64-efi"),
format!("--efi-directory={}" , efi_str), format!("--efi-directory={}", efi_str),
String::from("--bootloader-id=crystal"), String::from("--bootloader-id=crystal"),
String::from("--removable"), String::from("--removable"),
], ],
@ -85,8 +90,11 @@ pub fn install_bootloader_efi(efidir: PathBuf) {
"install grub as efi without --removable", "install grub as efi without --removable",
); );
files_eval( 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_eval(
exec_chroot( exec_chroot(
@ -98,7 +106,12 @@ pub fn install_bootloader_efi(efidir: PathBuf) {
} }
pub fn install_bootloader_legacy(device: 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() { if !device.exists() {
crash(format!("The device {device:?} does not exist"), 1); crash(format!("The device {device:?} does not exist"), 1);
} }
@ -111,8 +124,11 @@ pub fn install_bootloader_legacy(device: PathBuf) {
"install grub as legacy", "install grub as legacy",
); );
files_eval( 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_eval(
exec_chroot( exec_chroot(
@ -138,7 +154,15 @@ pub fn install_homemgr() {
pub fn install_flatpak() { pub fn install_flatpak() {
install(vec!["flatpak"]); install(vec!["flatpak"]);
exec_eval( 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", "add flathub remote",
) )
} }

2
src/functions/mod.rs
Unescape Escape View File

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

199
src/functions/partition.rs
Unescape Escape View File

@ -1,5 +1,5 @@
use crate::args::PartitionMode;
use crate::args; use crate::args;
use crate::args::PartitionMode;
use crate::internal::exec::*; use crate::internal::exec::*;
use crate::internal::*; use crate::internal::*;
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
@ -9,130 +9,60 @@ mkfs.btrfs mkfs.ext2 mkfs.ext4 mkfs.minix mkfs.vfat */
pub fn fmt_mount(mountpoint: &str, filesystem: &str, blockdevice: &str) { pub fn fmt_mount(mountpoint: &str, filesystem: &str, blockdevice: &str) {
match filesystem { match filesystem {
"vfat" => { "vfat" => exec_eval(
exec_eval( exec(
exec( "mkfs.vfat",
"mkfs.vfat", vec![
vec![ String::from("-F"),
String::from("-F"), String::from("32"),
String::from("32"), String::from(blockdevice),
String::from(blockdevice), ],
], ),
), format!("Formatting {blockdevice} as vfat").as_str(),
format!("Formatting {blockdevice} as vfat").as_str(), ),
) "bfs" => exec_eval(
} exec("mkfs.bfs", vec![String::from(blockdevice)]),
"bfs" => { format!("Formatting {blockdevice} as bfs").as_str(),
exec_eval( ),
exec( "cramfs" => exec_eval(
"mkfs.bfs", exec("mkfs.cramfs", vec![String::from(blockdevice)]),
vec![ format!("Formatting {blockdevice} as cramfs").as_str(),
String::from(blockdevice), ),
], "ext3" => exec_eval(
), exec("mkfs.ext3", vec![String::from(blockdevice)]),
format!("Formatting {blockdevice} as bfs").as_str(), format!("Formatting {blockdevice} as ext3").as_str(),
) ),
} "fat" => exec_eval(
"cramfs" => { exec("mkfs.fat", vec![String::from(blockdevice)]),
exec_eval( format!("Formatting {blockdevice} as fat").as_str(),
exec( ),
"mkfs.cramfs", "msdos" => exec_eval(
vec![ exec("mkfs.msdos", vec![String::from(blockdevice)]),
String::from(blockdevice), format!("Formatting {blockdevice} as msdos").as_str(),
], ),
), "xfs" => exec_eval(
format!("Formatting {blockdevice} as cramfs").as_str(), exec("mkfs.xfs", vec![String::from(blockdevice)]),
) format!("Formatting {blockdevice} as xfs").as_str(),
} ),
"ext3" => { "btrfs" => exec_eval(
exec_eval( exec(
exec( "mkfs.btrfs",
"mkfs.ext3", vec![String::from("-f"), String::from(blockdevice)],
vec![ ),
String::from(blockdevice), format!("Formatting {blockdevice} as btrfs").as_str(),
], ),
), "ext2" => exec_eval(
format!("Formatting {blockdevice} as ext3").as_str(), exec("mkfs.ext2", vec![String::from(blockdevice)]),
) format!("Formatting {blockdevice} as ext2").as_str(),
} ),
"fat" => { "ext4" => exec_eval(
exec_eval( exec("mkfs.ext4", vec![String::from(blockdevice)]),
exec( format!("Formatting {blockdevice} as ext4").as_str(),
"mkfs.fat", ),
vec![ "minix" => exec_eval(
String::from(blockdevice), exec("mkfs.minix", vec![String::from(blockdevice)]),
], format!("Formatting {blockdevice} as minix").as_str(),
), ),
format!("Formatting {blockdevice} as fat").as_str(),
)
}
"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),
],
),
format!("Formatting {blockdevice} as xfs").as_str(),
)
}
"btrfs" => {
exec_eval(
exec(
"mkfs.btrfs",
vec![
String::from("-f"),
String::from(blockdevice),
],
),
format!("Formatting {blockdevice} as btrfs").as_str(),
)
}
"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),
],
),
format!("Formatting {blockdevice} as ext4").as_str(),
)
}
"minix" => {
exec_eval(
exec(
"mkfs.minix",
vec![
String::from(blockdevice),
],
),
format!("Formatting {blockdevice} as minix").as_str(),
)
}
"don't format" => { "don't format" => {
log::debug!("Not formatting {}", blockdevice); log::debug!("Not formatting {}", blockdevice);
} }
@ -147,20 +77,19 @@ pub fn fmt_mount(mountpoint: &str, filesystem: &str, blockdevice: &str) {
} }
} }
exec_eval( 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(), format!("Creating mountpoint {mountpoint} for {blockdevice}").as_str(),
); );
mount(blockdevice, mountpoint, ""); 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); println!("{:?}", mode);
match mode { match mode {
PartitionMode::Auto => { PartitionMode::Auto => {
@ -785,7 +714,7 @@ pub fn mount(partition: &str, mountpoint: &str, options: &str) {
} }
} }
fn umount(mountpoint: &str) { pub fn umount(mountpoint: &str) {
exec_eval( exec_eval(
exec("umount", vec![String::from(mountpoint)]), exec("umount", vec![String::from(mountpoint)]),
format!("unmount {}", mountpoint).as_str(), format!("unmount {}", mountpoint).as_str(),

83
src/functions/unakite.rs
Unescape Escape View File

@ -1,11 +1,16 @@
use crate::args::DesktopSetup;
use crate::functions::partition::mount;
use crate::functions::*;
use crate::internal::exec::*; use crate::internal::exec::*;
use crate::internal::*; use crate::internal::*;
use crate::functions::*;
use crate::functions::partition::mount;
use std::path::PathBuf; use std::path::PathBuf;
use crate::args::DesktopSetup;
pub fn install_bootloader_efi(efidir: PathBuf) { 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 efidir = std::path::Path::new("/mnt").join(efidir);
let efi_str = efidir.to_str().unwrap(); let efi_str = efidir.to_str().unwrap();
if !std::path::Path::new(&format!("/mnt{efi_str}")).exists() { if !std::path::Path::new(&format!("/mnt{efi_str}")).exists() {
@ -16,7 +21,7 @@ pub fn install_bootloader_efi(efidir: PathBuf) {
"grub-install", "grub-install",
vec![ vec![
String::from("--target=x86_64-efi"), String::from("--target=x86_64-efi"),
format!("--efi-directory={}" , efi_str), format!("--efi-directory={}", efi_str),
String::from("--bootloader-id=unakite"), String::from("--bootloader-id=unakite"),
String::from("--removable"), String::from("--removable"),
], ],
@ -35,8 +40,11 @@ pub fn install_bootloader_efi(efidir: PathBuf) {
"install unakite grub as efi without --removable", "install unakite grub as efi without --removable",
); );
files_eval( 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_eval(
exec_chroot( 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) { pub fn remount(root: &str, oldroot: &str, efi: bool, efidir: &str, bootdev: &str, firstrun: bool) {
if efi && firstrun { if efi && firstrun {
exec_eval( exec_eval(
exec( exec("umount", vec![String::from(bootdev)]),
"umount",
vec![String::from(bootdev)],
),
&format!("Unmount {}", bootdev), &format!("Unmount {}", bootdev),
); );
exec_eval( exec_eval(
exec( exec("umount", vec![String::from(oldroot)]),
"umount",
vec![String::from(oldroot)],
),
"Unmount old root", "Unmount old root",
); );
mount(root, "/mnt", ""); mount(root, "/mnt", "");
exec_eval( 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(), format!("Creating mountpoint {efidir} for {bootdev}").as_str(),
); );
mount(bootdev, efidir, ""); mount(bootdev, efidir, "");
} else if efi && !firstrun { } else if efi && !firstrun {
exec_eval( exec_eval(
exec( exec("umount", vec![String::from(bootdev)]),
"umount",
vec![String::from(bootdev)],
),
&format!("Unmount {}", bootdev), &format!("Unmount {}", bootdev),
); );
exec_eval( exec_eval(
exec( exec("umount", vec![String::from(root)]),
"umount",
vec![String::from(root)],
),
"Unmount unakite root", "Unmount unakite root",
); );
mount(oldroot, "/mnt", ""); mount(oldroot, "/mnt", "");
mount(bootdev, efidir, ""); mount(bootdev, efidir, "");
} else if !efi && firstrun { } else if !efi && firstrun {
exec_eval( exec_eval(
exec( exec("umount", vec![String::from(bootdev)]),
"umount",
vec![String::from(bootdev)],
),
&format!("Unmount {}", bootdev), &format!("Unmount {}", bootdev),
); );
exec_eval( exec_eval(
exec( exec("umount", vec![String::from(oldroot)]),
"umount",
vec![String::from(oldroot)],
),
"Unmount old root", "Unmount old root",
); );
mount(root, "/mnt", ""); mount(root, "/mnt", "");
exec_eval( 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(), format!("Creating mountpoint /boot for {bootdev}").as_str(),
); );
mount(bootdev, "/mnt/boot", ""); mount(bootdev, "/mnt/boot", "");
} else if !efi && !firstrun { } else if !efi && !firstrun {
exec_eval( exec_eval(
exec( exec("umount", vec![String::from(bootdev)]),
"umount",
vec![String::from(bootdev)],
),
&format!("Unmount {}", bootdev), &format!("Unmount {}", bootdev),
); );
exec_eval( exec_eval(
exec( exec("umount", vec![String::from(root)]),
"umount",
vec![String::from(root)],
),
"Unmount unakite root", "Unmount unakite root",
); );
mount(oldroot, "/mnt", ""); mount(oldroot, "/mnt", "");
@ -154,6 +126,7 @@ pub fn setup_unakite(root: &str, oldroot: &str, efi: bool, efidir: &str, bootdev
"unakite", "unakite",
true, true,
"Cp7oN04ZY0PsA", // unakite "Cp7oN04ZY0PsA", // unakite
false,
); );
exec_eval( exec_eval(
exec( exec(
@ -191,7 +164,7 @@ pub fn setup_unakite(root: &str, oldroot: &str, efi: bool, efidir: &str, bootdev
vec![ vec![
String::from("/tmp/jade.json"), String::from("/tmp/jade.json"),
String::from("/mnt/etc/installSettings.json"), String::from("/mnt/etc/installSettings.json"),
] ],
), ),
"Copy jade.json to /etc/installSettings.json in unakite", "Copy jade.json to /etc/installSettings.json in unakite",
); );
@ -201,6 +174,6 @@ pub fn setup_unakite(root: &str, oldroot: &str, efi: bool, efidir: &str, bootdev
"grub-mkconfig", "grub-mkconfig",
vec![String::from("-o"), String::from("/boot/grub/grub.cfg")], vec![String::from("-o"), String::from("/boot/grub/grub.cfg")],
), ),
"Recreate grub.cfg in crystal" "Recreate grub.cfg in crystal",
); );
} }

28
src/functions/users.rs
Unescape Escape View File

@ -1,7 +1,15 @@
use crate::internal::exec::*; use crate::internal::exec::*;
use crate::internal::*; use crate::internal::*;
use std::process::Command;
pub fn new_user(username: &str, hasroot: bool, password: &str) { pub fn new_user(username: &str, hasroot: bool, password: &str, do_hash_pass: bool) {
if do_hash_pass {
let hashed_pass = &*hash_pass(password).stdout;
let _password = match std::str::from_utf8(hashed_pass) {
Ok(v) => v,
Err(e) => panic!("Failed to hash password, invalid UTF-8 sequence {}", e),
};
}
exec_eval( exec_eval(
exec_chroot( exec_chroot(
"useradd", "useradd",
@ -10,7 +18,7 @@ pub fn new_user(username: &str, hasroot: bool, password: &str) {
String::from("-s"), String::from("-s"),
String::from("/bin/bash"), String::from("/bin/bash"),
String::from("-p"), String::from("-p"),
String::from(password), String::from(password).replace('\n', ""),
String::from(username), String::from(username),
], ],
), ),
@ -21,10 +29,8 @@ pub fn new_user(username: &str, hasroot: bool, password: &str) {
exec_chroot( exec_chroot(
"usermod", "usermod",
vec![ vec![
String::from("-a"), String::from("-aG"),
String::from("-G"),
String::from("wheel"), String::from("wheel"),
String::from("nix-users"),
String::from(username), String::from(username),
], ],
), ),
@ -41,15 +47,21 @@ pub fn new_user(username: &str, hasroot: bool, password: &str) {
} }
} }
pub fn hash_pass(password: &str) -> std::process::Output {
let output = Command::new("openssl")
.args(["passwd", "-1", password])
.output()
.expect("Failed to hash password");
output
}
pub fn root_pass(root_pass: &str) { pub fn root_pass(root_pass: &str) {
exec_eval( exec_eval(
exec_chroot( exec_chroot(
"bash", "bash",
vec![ vec![
String::from("-c"), String::from("-c"),
format!( format!(r#"'usermod --password {root_pass} root'"#),
r#"'usermod --password {root_pass} root'"#
),
], ],
), ),
"set root password", "set root password",

69
src/internal/config.rs
Unescape Escape View File

@ -1,5 +1,5 @@
use crate::args::{DesktopSetup, PartitionMode};
use crate::args; use crate::args;
use crate::args::{DesktopSetup, PartitionMode};
use crate::functions::*; use crate::functions::*;
use crate::internal::*; use crate::internal::*;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
@ -105,7 +105,7 @@ pub fn read_config(configpath: PathBuf) {
config.partition.mode, config.partition.mode,
config.partition.efi, config.partition.efi,
&mut partitions, &mut partitions,
config.unakite.enable config.unakite.enable,
); );
base::install_base_packages(config.kernel); base::install_base_packages(config.kernel);
base::genfstab(); base::genfstab();
@ -142,6 +142,7 @@ pub fn read_config(configpath: PathBuf) {
config.users[i].name.as_str(), config.users[i].name.as_str(),
config.users[i].hasroot, config.users[i].hasroot,
config.users[i].password.as_str(), config.users[i].password.as_str(),
false,
); );
println!("---------"); println!("---------");
} }
@ -182,20 +183,66 @@ pub fn read_config(configpath: PathBuf) {
} }
install(extra_packages); install(extra_packages);
log::info!("Setup unakite"); 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()); 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()); 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 { } 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()); 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()); 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 { } else {
log::info!("Unakite disabled"); log::info!("Unakite disabled");
} }

2
src/internal/files.rs
Unescape Escape View File

@ -32,7 +32,7 @@ pub fn copy_file(path: &str, destpath: &str) {
pub fn append_file(path: &str, content: &str) -> std::io::Result<()> { pub fn append_file(path: &str, content: &str) -> std::io::Result<()> {
log::info!("Append '{}' to file {}", content.trim_end(), path); log::info!("Append '{}' to file {}", content.trim_end(), path);
let mut file = OpenOptions::new().append(true).open(path)?; let mut file = OpenOptions::new().append(true).open(path)?;
file.write_all(content.as_bytes())?; file.write_all(format!("\n{content}\n").as_bytes())?;
Ok(()) Ok(())
} }

3
src/internal/install.rs
Unescape Escape View File

@ -1,4 +1,6 @@
use crate::internal::*; use crate::internal::*;
use crate::functions::partition::mount;
use crate::functions::partition::umount;
use std::process::Command; use std::process::Command;
pub fn install(pkgs: Vec<&str>) { pub fn install(pkgs: Vec<&str>) {
@ -6,4 +8,5 @@ pub fn install(pkgs: Vec<&str>) {
Command::new("pacstrap").arg("/mnt").args(&pkgs).status(), Command::new("pacstrap").arg("/mnt").args(&pkgs).status(),
format!("Install packages {}", pkgs.join(", ")).as_str(), format!("Install packages {}", pkgs.join(", ")).as_str(),
); );
umount("/mnt/dev");
} }

18
src/main.rs
Unescape Escape View File

@ -14,12 +14,16 @@ fn main() {
match opt.command { match opt.command {
Command::Partition(args) => { Command::Partition(args) => {
let mut partitions = args.partitions; 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) => { Command::InstallBase(args) => {
base::install_base_packages( base::install_base_packages(args.kernel);
args.kernel,
);
} }
Command::GenFstab => { Command::GenFstab => {
base::genfstab(); base::genfstab();
@ -49,7 +53,7 @@ fn main() {
} }
Command::Users { subcommand } => match subcommand { Command::Users { subcommand } => match subcommand {
UsersSubcommand::NewUser(args) => { UsersSubcommand::NewUser(args) => {
users::new_user(&args.username, args.hasroot, &args.password); users::new_user(&args.username, args.hasroot, &args.password, true);
} }
UsersSubcommand::RootPass { password } => { UsersSubcommand::RootPass { password } => {
users::root_pass(&password); users::root_pass(&password);
@ -57,7 +61,7 @@ fn main() {
}, },
Command::Nix => { Command::Nix => {
base::install_homemgr(); base::install_homemgr();
}, }
Command::Flatpak => { Command::Flatpak => {
base::install_flatpak(); base::install_flatpak();
} }
@ -69,7 +73,7 @@ fn main() {
&args.efidir, &args.efidir,
&args.bootdev, &args.bootdev,
); );
}, }
Command::Config { config } => { Command::Config { config } => {
crate::internal::config::read_config(config); crate::internal::config::read_config(config);
} }

Write Preview
Loading…
Cancel
Save