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

complete unakite

Browse Source
axtloss/rework-partitioning
axtlos 2 years ago
parent 96aaa78850
commit dc8219831a
5 changed files with 381 additions and 47 deletions
Show Stats Download Patch File Download Diff File

3
src/args.rs
Unescape Escape View File

@ -95,6 +95,9 @@ pub struct PartitionArgs {
#[clap(long)] #[clap(long)]
pub efi: bool, pub efi: bool,
#[clap(long)]
pub unakite: bool,
/// The partitions to use for manual partitioning /// The partitions to use for manual partitioning
#[clap(required_if_eq("mode", "Partition::Manual"), parse(try_from_str = parse_partitions))] #[clap(required_if_eq("mode", "Partition::Manual"), parse(try_from_str = parse_partitions))]
pub partitions: Vec<Partition>, pub partitions: Vec<Partition>,

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

@ -159,7 +159,7 @@ pub fn fmt_mount(mountpoint: &str, filesystem: &str, blockdevice: &str) {
mount(blockdevice, mountpoint, ""); mount(blockdevice, mountpoint, "");
} }
pub fn partition(device: PathBuf, mode: PartitionMode, efi: bool, partitions: &mut Vec<args::Partition>) { pub fn partition(device: PathBuf, mode: PartitionMode, efi: bool, partitions: &mut Vec<args::Partition>, unakite: bool) {
println!("{:?}", mode); println!("{:?}", mode);
match mode { match mode {
@ -169,14 +169,14 @@ pub fn partition(device: PathBuf, mode: PartitionMode, efi: bool, partitions: &m
} }
log::debug!("automatically partitioning {device:?}"); log::debug!("automatically partitioning {device:?}");
if efi { if efi {
partition_with_efi(&device); partition_with_efi(&device, unakite);
} else { } else {
partition_no_efi(&device); partition_no_efi(&device, unakite);
} }
if device.to_string_lossy().contains("nvme") { if device.to_string_lossy().contains("nvme") {
part_nvme(&device, efi); part_nvme(&device, efi, unakite);
} else { } else {
part_disk(&device, efi); part_disk(&device, efi, unakite);
} }
} }
PartitionMode::Manual => { PartitionMode::Manual => {
@ -198,7 +198,7 @@ pub fn partition(device: PathBuf, mode: PartitionMode, efi: bool, partitions: &m
} }
} }
fn partition_no_efi(device: &Path) { fn partition_no_efi(device: &Path, unakite: bool) {
let device = device.to_string_lossy().to_string(); let device = device.to_string_lossy().to_string();
exec_eval( exec_eval(
exec( exec(
@ -227,6 +227,38 @@ fn partition_no_efi(device: &Path) {
), ),
"create bios boot partition", "create bios boot partition",
); );
if unakite {
exec_eval(
exec(
"parted",
vec![
String::from("-s"),
String::from(&device),
String::from("mkpart"),
String::from("primary"),
String::from("btrfs"),
String::from("512MIB"),
String::from("10048MIB"),
],
),
"create btrfs Unakite root partition",
);
exec_eval(
exec(
"parted",
vec![
String::from("-s"),
device,
String::from("mkpart"),
String::from("primary"),
String::from("btrfs"),
String::from("10048MIB"),
String::from("100%"),
],
),
"create btrfs Crystal root partition",
);
} else {
exec_eval( exec_eval(
exec( exec(
"parted", "parted",
@ -243,8 +275,9 @@ fn partition_no_efi(device: &Path) {
"create btrfs root partition", "create btrfs root partition",
); );
} }
}
fn partition_with_efi(device: &Path) { fn partition_with_efi(device: &Path, unakite: bool) {
let device = device.to_string_lossy().to_string(); let device = device.to_string_lossy().to_string();
exec_eval( exec_eval(
exec( exec(
@ -272,6 +305,22 @@ fn partition_with_efi(device: &Path) {
), ),
"create EFI partition", "create EFI partition",
); );
if unakite {
exec_eval(
exec(
"parted",
vec![
String::from("-s"),
String::from(&device),
String::from("mkpart"),
String::from("primary"),
String::from("btrfs"),
String::from("512MIB"),
String::from("10048MIB"),
],
),
"create btrfs Unakite root partition",
);
exec_eval( exec_eval(
exec( exec(
"parted", "parted",
@ -279,18 +328,36 @@ fn partition_with_efi(device: &Path) {
String::from("-s"), String::from("-s"),
device, device,
String::from("mkpart"), String::from("mkpart"),
String::from("primary"),
String::from("btrfs"), String::from("btrfs"),
String::from("300"), String::from("10048MIB"),
String::from("100%"), String::from("100%"),
], ],
), ),
"Create btrfs root partition", "create btrfs Crystal root partition",
);
} else {
exec_eval(
exec(
"parted",
vec![
String::from("-s"),
device,
String::from("mkpart"),
String::from("primary"),
String::from("btrfs"),
String::from("512MIB"),
String::from("100%"),
],
),
"create btrfs root partition",
); );
} }
}
fn part_nvme(device: &Path, efi: bool) { fn part_nvme(device: &Path, efi: bool, unakite: bool) {
let device = device.to_string_lossy().to_string(); let device = device.to_string_lossy().to_string();
if efi { if efi && !unakite {
exec_eval( exec_eval(
exec("mkfs.vfat", vec![format!("{}p1", device)]), exec("mkfs.vfat", vec![format!("{}p1", device)]),
format!("format {}p1 as fat32", device).as_str(), format!("format {}p1 as fat32", device).as_str(),
@ -341,7 +408,112 @@ fn part_nvme(device: &Path, efi: bool) {
"subvol=@home", "subvol=@home",
); );
mount(format!("{}p1", device).as_str(), "/mnt/boot/efi", ""); mount(format!("{}p1", device).as_str(), "/mnt/boot/efi", "");
} else { } else if !efi && !unakite {
exec_eval(
exec("mkfs.ext4", vec![format!("{}p1", device)]),
format!("format {}p1 as ext4", device).as_str(),
);
exec_eval(
exec(
"mkfs.btrfs",
vec!["-f".to_string(), format!("{}p2", device)],
),
format!("format {}p2 as btrfs", device).as_str(),
);
mount(format!("{}p2", device).as_str(), "/mnt/", "");
exec_eval(
exec_workdir(
"btrfs",
"/mnt",
vec![
String::from("subvolume"),
String::from("create"),
String::from("@"),
],
),
"Create btrfs subvolume @",
);
exec_eval(
exec_workdir(
"btrfs",
"/mnt",
vec![
String::from("subvolume"),
String::from("create"),
String::from("@home"),
],
),
"Create btrfs subvolume @home",
);
umount("/mnt");
mount(format!("{}p2", device).as_str(), "/mnt/", "subvol=@");
files_eval(files::create_directory("/mnt/boot"), "create /mnt/boot");
files_eval(files::create_directory("/mnt/home"), "create /mnt/home");
mount(
format!("{}p2", device).as_str(),
"/mnt/home",
"subvol=@home",
);
mount(format!("{}p1", device).as_str(), "/mnt/boot", "");
} else if efi && unakite {
exec_eval(
exec("mkfs.vfat", vec![format!("{}p1", device)]),
format!("format {}p1 as fat32", device).as_str(),
);
exec_eval(
exec(
"mkfs.btrfs",
vec!["-f".to_string(), format!("{}p2", device)],
),
format!("format {}p2 as btrfs", device).as_str(),
);
exec_eval(
exec(
"mkfs.btrfs",
vec!["-f".to_string(), format!("{}p3", device)],
),
format!("format {}p3 as btrfs", device).as_str(),
);
mount(format!("{}p3", device).as_str(), "/mnt", "");
exec_eval(
exec_workdir(
"btrfs",
"/mnt",
vec![
String::from("subvolume"),
String::from("create"),
String::from("@"),
],
),
"Create btrfs subvolume @",
);
exec_eval(
exec_workdir(
"btrfs",
"/mnt",
vec![
String::from("subvolume"),
String::from("create"),
String::from("@home"),
],
),
"Create btrfs subvolume @home",
);
umount("/mnt");
mount(format!("{}p3", device).as_str(), "/mnt/", "subvol=@");
files_eval(files::create_directory("/mnt/boot"), "create /mnt/boot");
files_eval(
files::create_directory("/mnt/boot/efi"),
"create /mnt/boot/efi",
);
files_eval(files::create_directory("/mnt/home"), "create /mnt/home");
mount(
format!("{}p3", device).as_str(),
"/mnt/home",
"subvol=@home",
);
mount(format!("{}p1", device).as_str(), "/mnt/boot/efi", "");
} else if !efi && unakite {
exec_eval( exec_eval(
exec("mkfs.ext4", vec![format!("{}p1", device)]), exec("mkfs.ext4", vec![format!("{}p1", device)]),
format!("format {}p1 as ext4", device).as_str(), format!("format {}p1 as ext4", device).as_str(),
@ -391,9 +563,9 @@ fn part_nvme(device: &Path, efi: bool) {
} }
} }
fn part_disk(device: &Path, efi: bool) { fn part_disk(device: &Path, efi: bool, unakite: bool) {
let device = device.to_string_lossy().to_string(); let device = device.to_string_lossy().to_string();
if efi { if efi && !unakite {
exec_eval( exec_eval(
exec("mkfs.vfat", vec![format!("{}1", device)]), exec("mkfs.vfat", vec![format!("{}1", device)]),
format!("format {}1 as fat32", device).as_str(), format!("format {}1 as fat32", device).as_str(),
@ -437,7 +609,7 @@ fn part_disk(device: &Path, efi: bool) {
files_eval(files::create_directory("/mnt/home"), "create /mnt/home"); files_eval(files::create_directory("/mnt/home"), "create /mnt/home");
mount(format!("{}2", device).as_str(), "/mnt/home", "subvol=@home"); mount(format!("{}2", device).as_str(), "/mnt/home", "subvol=@home");
mount(format!("{}1", device).as_str(), "/mnt/boot/efi", ""); mount(format!("{}1", device).as_str(), "/mnt/boot/efi", "");
} else { } else if !efi && !unakite {
exec_eval( exec_eval(
exec("mkfs.ext4", vec![format!("{}1", device)]), exec("mkfs.ext4", vec![format!("{}1", device)]),
format!("format {}1 as ext4", device).as_str(), format!("format {}1 as ext4", device).as_str(),
@ -483,6 +655,104 @@ fn part_disk(device: &Path, efi: bool) {
); );
mount(format!("{}2", device).as_str(), "/mnt/home", "subvol=@home"); mount(format!("{}2", device).as_str(), "/mnt/home", "subvol=@home");
mount(format!("{}1", device).as_str(), "/mnt/boot", ""); mount(format!("{}1", device).as_str(), "/mnt/boot", "");
} else if efi && unakite {
exec_eval(
exec("mkfs.vfat", vec![format!("{}1", device)]),
format!("format {}1 as fat32", device).as_str(),
);
exec_eval(
exec("mkfs.btrfs", vec!["-f".to_string(), format!("{}2", device)]),
format!("format {}2 as btrfs", device).as_str(),
);
exec_eval(
exec("mkfs.btrfs", vec!["-f".to_string(), format!("{}3", device)]),
format!("format {}3 as btrfs", device).as_str(),
);
mount(format!("{}3", device).as_str(), "/mnt", "");
exec_eval(
exec_workdir(
"btrfs",
"/mnt",
vec![
String::from("subvolume"),
String::from("create"),
String::from("@"),
],
),
"Create btrfs subvolume @",
);
exec_eval(
exec_workdir(
"btrfs",
"/mnt",
vec![
String::from("subvolume"),
String::from("create"),
String::from("@home"),
],
),
"Create btrfs subvolume @home",
);
umount("/mnt");
mount(format!("{}3", device).as_str(), "/mnt/", "subvol=@");
files_eval(files::create_directory("/mnt/boot"), "create /mnt/boot");
files_eval(
files::create_directory("/mnt/boot/efi"),
"create /mnt/boot/efi",
);
files_eval(files::create_directory("/mnt/home"), "create /mnt/home");
mount(format!("{}3", device).as_str(), "/mnt/home", "subvol=@home");
mount(format!("{}1", device).as_str(), "/mnt/boot/efi", "");
} else if !efi && unakite {
exec_eval(
exec("mkfs.ext4", vec![format!("{}1", device)]),
format!("format {}1 as ext4", device).as_str(),
);
exec_eval(
exec("mkfs.btrfs", vec!["-f".to_string(), format!("{}2", device)]),
format!("format {}2 as btrfs", device).as_str(),
);
exec_eval(
exec("mkfs.btrfs", vec!["-f".to_string(), format!("{}3", device)]),
format!("format {}3 as btrfs", device).as_str(),
);
mount(format!("{}3", device).as_str(), "/mnt/", "");
exec_eval(
exec_workdir(
"btrfs",
"/mnt",
vec![
String::from("subvolume"),
String::from("create"),
String::from("@"),
],
),
"Create btrfs subvolume @",
);
exec_eval(
exec_workdir(
"btrfs",
"/mnt",
vec![
String::from("subvolume"),
String::from("create"),
String::from("@home"),
],
),
"create btrfs subvolume @home",
);
umount("/mnt");
mount(format!("{}3", device).as_str(), "/mnt/", "subvol=@");
files_eval(
files::create_directory("/mnt/boot"),
"create directory /mnt/boot",
);
files_eval(
files::create_directory("/mnt/home"),
"create directory /mnt/home",
);
mount(format!("{}3", device).as_str(), "/mnt/home", "subvol=@home");
mount(format!("{}1", device).as_str(), "/mnt/boot", "");
} }
} }

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

@ -146,9 +146,6 @@ pub fn setup_unakite(root: &str, oldroot: &str, efi: bool, efidir: &str, bootdev
remount(root, oldroot, efi, efidir, bootdev, true); remount(root, oldroot, efi, efidir, bootdev, true);
base::install_base_packages(); base::install_base_packages();
base::genfstab(); base::genfstab();
if efi {
install_bootloader_efi(PathBuf::from(efidir.replace("/mnt", "")));
}
locale::set_locale("en_US.UTF-8 UTF-8".to_string()); locale::set_locale("en_US.UTF-8 UTF-8".to_string());
locale::set_timezone("Europe/Berlin"); // TODO: get the proper timezone locale::set_timezone("Europe/Berlin"); // TODO: get the proper timezone
network::set_hostname("unakite"); network::set_hostname("unakite");
@ -158,8 +155,42 @@ pub fn setup_unakite(root: &str, oldroot: &str, efi: bool, efidir: &str, bootdev
true, true,
"Cp7oN04ZY0PsA", // unakite "Cp7oN04ZY0PsA", // unakite
); );
exec_eval(
exec(
"sed",
vec![
String::from("-i"),
String::from("-e"),
String::from("s/crystal/unakite/g"),
String::from("/mnt/etc/os-release"),
],
),
"Change os-release",
);
exec_eval(
exec(
"sed",
vec![
String::from("-i"),
String::from("-e"),
String::from("s/Crystal/Unakite/g"),
String::from("/mnt/etc/os-release"),
],
),
"Change os-release",
);
if efi {
install_bootloader_efi(PathBuf::from(efidir.replace("/mnt", "")));
}
users::root_pass("Cp7oN04ZY0PsA"); // unakite users::root_pass("Cp7oN04ZY0PsA"); // unakite
desktops::install_desktop_setup(DesktopSetup::Xfce); desktops::install_desktop_setup(DesktopSetup::Xfce);
install(vec!["gparted", "firefox"]); install(vec!["gparted", "firefox"]);
remount(root, oldroot, efi, efidir, bootdev, false); remount(root, oldroot, efi, efidir, bootdev, false);
exec_eval(
exec_chroot(
"grub-mkconfig",
vec![String::from("-o"), String::from("/boot/grub/grub.cfg")],
),
"Recreate grub.cfg in crystal"
);
} }

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

@ -17,6 +17,7 @@ struct Config {
timeshift: bool, timeshift: bool,
flatpak: bool, flatpak: bool,
extra_packages: Vec<String>, extra_packages: Vec<String>,
unakite: Unakite,
} }
#[derive(Serialize, Deserialize)] #[derive(Serialize, Deserialize)]
@ -53,6 +54,15 @@ struct Users {
hasroot: bool, hasroot: bool,
} }
#[derive(Serialize, Deserialize)]
struct Unakite {
enable: bool,
root: String,
oldroot: String,
efidir: String,
bootdev: String,
}
pub fn read_config(configpath: PathBuf) { pub fn read_config(configpath: PathBuf) {
let data = std::fs::read_to_string(&configpath); let data = std::fs::read_to_string(&configpath);
match &data { match &data {
@ -88,11 +98,13 @@ pub fn read_config(configpath: PathBuf) {
partition.split(':').collect::<Vec<&str>>()[2].to_string(), partition.split(':').collect::<Vec<&str>>()[2].to_string(),
)); ));
} }
let device = PathBuf::from("/dev/").join(config.partition.device.as_str());
partition::partition( partition::partition(
PathBuf::from("/dev/").join(config.partition.device), device,
config.partition.mode, config.partition.mode,
config.partition.efi, config.partition.efi,
&mut partitions, &mut partitions,
config.unakite.enable
); );
base::install_base_packages(); base::install_base_packages();
base::genfstab(); base::genfstab();
@ -168,5 +180,23 @@ pub fn read_config(configpath: PathBuf) {
extra_packages.push(config.extra_packages[i].as_str()); extra_packages.push(config.extra_packages[i].as_str());
} }
install(extra_packages); 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") {
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())
} 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())
} else if config.unakite.enable {
unakite::setup_unakite(&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())
} 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())
} else {
log::info!("Unakite disabled");
}
println!("Installation finished! You may reboot now!") println!("Installation finished! You may reboot now!")
} }

2
src/main.rs
Unescape Escape View File

@ -14,7 +14,7 @@ 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); partition::partition(args.device, args.mode, args.efi, &mut partitions, args.unakite);
} }
Command::InstallBase => { Command::InstallBase => {
base::install_base_packages(); base::install_base_packages();

Write Preview
Loading…
Cancel
Save