add bootloader and base package installation and make crash/log msesages all the same format

src/functions/base.rs

@@ -0,0 +1,54 @@
+use crate::internal::exec::*;
+use crate::internal::*;
+
+pub fn install_base_packages() {
+    install::install(vec![
+        "base",
+        "linux",
+        "linux-firmware",
+        "systemd-sysvcompat",
+        "networkmanager",
+        "man-db",
+        "man-pages",
+        "texinfo",
+        "micro",
+        "sudo",
+        "curl",
+        "archlinux-keyring",
+        "neofetch",
+        "btrfs-progs",
+        "timeshift",
+        "timeshift-autosnap",
+        "which",
+    ]);
+}
+
+pub fn create_hosts() {
+    files::create_file("/mnt/etc/hosts");
+    files_eval(files::append_file("/mnt/etc/hosts", "127.0.0.1     localhost"), "create /etc/hosts");
+}
+
+pub fn install_bootloader_efi(efidir: &str) {
+    install::install(vec!["grub", "efibootmgr",]);
+    exec_eval(exec_chroot("grub-install", vec![
+        String::from("--target=x86_64-efi"),
+        format!("--efi-directory={}", efidir),
+        String::from("--bootloader-id=crystal"),
+    ]), "install grub as efi");
+    exec_eval(exec_chroot("grub-mkconfig", vec![
+        String::from("-o"),
+        String::from("/boot/grub/grub.cfg"),
+    ]), "create grub.cfg");
+}
+
+pub fn install_bootloader_legacy(device: &str) {
+    install::install(vec!["grub"]);
+    exec_eval(exec_chroot("grub-install", vec![
+        String::from("--target=i386-pc"),
+        String::from(device),
+    ]), "install grub as legacy");
+    exec_eval(exec_chroot("grub-mkconfig", vec![
+        String::from("-o"),
+        String::from("/boot/grub/grub.cfg"),
+    ]), "create grub.cfg");
+}

src/functions/locale.rs

@@ -9,16 +9,16 @@ pub fn set_timezone(timezone: &str) {
             format!("/usr/share/zoneinfo/{}", timezone),
             "/etc/localtime".to_string(),
         ],
-    ));
-    exec_eval(exec_chroot("hwclock", vec!["--systohc".to_string()]));
+    ), "Set timezone");
+    exec_eval(exec_chroot("hwclock", vec!["--systohc".to_string()]), "Set system clock");
 }
 
 pub fn set_locale(locale: String) {
-    files_eval(files::append_file("/etc/locale.gen", "en_US.UTF-8 UTF-8"));
-    files_eval(files::append_file("/etc/locale.gen", locale.as_str()));
-    exec_eval(exec_chroot("locale-gen", vec!["".to_string()]));
+    files_eval(files::append_file("/etc/locale.gen", "en_US.UTF-8 UTF-8"), "add en_US.UTF-8 UTF-8 to locale.gen");
+    files_eval(files::append_file("/etc/locale.gen", locale.as_str()), "add locales to locale.gen");
+    exec_eval(exec_chroot("locale-gen", vec!["".to_string()]), "generate locales");
     files::create_file("/etc/locale.conf");
-    files_eval(files::append_file("/etc/locale.conf", "LANG=en_US.UTF-8"));
+    files_eval(files::append_file("/etc/locale.conf", "LANG=en_US.UTF-8"), "edit locale.conf");
 }
 
 pub fn set_keyboard(keyboard: &str) {
@@ -26,27 +26,5 @@ pub fn set_keyboard(keyboard: &str) {
     files_eval(files::append_file(
         "/etc/vconsole.conf",
         format!("KEYMAP={}", keyboard).as_str(),
-    ));
-}
-
-fn files_eval(return_code: std::result::Result<(), std::io::Error>) {
-    match return_code {
-        Ok(_) => {
-            log("Success".to_string());
-        }
-        Err(e) => {
-            crash(format!("Failed to create file, Error: {}", e), 1);
-        }
-    }
-}
-
-fn exec_eval(return_code: std::result::Result<std::process::Output, std::io::Error>) {
-    match return_code {
-        Ok(_) => {
-            log("Success".to_string());
-        }
-        Err(e) => {
-            crash(format!("Failed with error: {}", e), 1);
-        }
-    }
+    ), "set keyboard layout");
 }

src/functions/mod.rs

@@ -3,3 +3,4 @@ pub mod locale;
 pub mod network;
 pub mod partition;
 pub mod users;
+pub mod base;

src/functions/network.rs

@@ -3,32 +3,14 @@ use crate::internal::*;
 pub fn set_hostname(hostname: &str) {
     println!("Setting hostname to {}", hostname);
     files::create_file("/mnt/etc/hostname");
-    let return_val = files::append_file("/mnt/etc/hostname", hostname);
-    match return_val {
-        Ok(_) => {
-            log(format!("Set hostname to {}", hostname));
-        }
-        Err(e) => {
-            crash(
-                format!("Failed to set hostname to {}, Error: {}", hostname, e),
-                1,
-            );
-        }
-    }
+    files_eval(files::append_file("/mnt/etc/hostname", hostname), "set hostname");
 }
 
-pub fn enable_ipv6(ipv6: bool) {
-    if ipv6 {
-        let return_val = files::append_file("/mnt/etc/hosts", "::1 localhost");
-        match return_val {
-            Ok(_) => {
-                log("Enabled IPv6".to_string());
-            }
-            Err(e) => {
-                crash(format!("Failed to enable IPv6, Error: {}", e), 1);
-            }
-        }
-    } else {
-        log("Not enabling ipv6".to_string());
-    }
+pub fn create_hosts() {
+    files::create_file("/mnt/etc/hosts");
+    files_eval(files::append_file("/mnt/etc/hosts", "127.0.0.1     localhost"), "create /etc/hosts");
+}
+
+pub fn enable_ipv6() {
+    files_eval(files::append_file("/mnt/etc/hosts", "::1 localhost"), "add ipv6 localhost");
 }

src/functions/partition.rs

@@ -7,7 +7,7 @@ pub fn partition(device: &str, mode: &str, efi: bool) {
     } else {
         log(format!("automatically partitioning {}", device));
         if efi {
-            returncode_eval(exec(
+            exec_eval(exec(
                 "parted",
                 vec![
                     String::from("-s"),
@@ -15,8 +15,8 @@ pub fn partition(device: &str, mode: &str, efi: bool) {
                     String::from("mklabel"),
                     String::from("gpt"),
                 ],
-            ));
-            returncode_eval(exec(
+            ), format!("create gpt label on {}", device).as_str());
+            exec_eval(exec(
                 "parted",
                 vec![
                     String::from("-s"),
@@ -26,8 +26,8 @@ pub fn partition(device: &str, mode: &str, efi: bool) {
                     String::from("0"),
                     String::from("300"),
                 ],
-            ));
-            returncode_eval(exec(
+            ), "create EFI partition");
+            exec_eval(exec(
                 "parted",
                 vec![
                     String::from("-s"),
@@ -37,9 +37,9 @@ pub fn partition(device: &str, mode: &str, efi: bool) {
                     String::from("300"),
                     String::from("100%"),
                 ],
-            ));
+            ), "Create btrfs root partition");
         } else {
-            returncode_eval(exec(
+            exec_eval(exec(
                 "parted",
                 vec![
                     String::from("-s"),
@@ -47,8 +47,8 @@ pub fn partition(device: &str, mode: &str, efi: bool) {
                     String::from("mklabel"),
                     String::from("msdos"),
                 ],
-            ));
-            returncode_eval(exec(
+            ), format!("Create msdos label on {}", device).as_str());
+            exec_eval(exec(
                 "parted",
                 vec![
                     String::from("-s"),
@@ -58,8 +58,8 @@ pub fn partition(device: &str, mode: &str, efi: bool) {
                     String::from("512MIB"),
                     String::from("100&"),
                 ],
-            ));
-            returncode_eval(exec(
+            ), "create btrfs root partition");
+            exec_eval(exec(
                 "parted",
                 vec![
                     String::from("-s"),
@@ -69,7 +69,7 @@ pub fn partition(device: &str, mode: &str, efi: bool) {
                     String::from("1MIB"),
                     String::from("512MIB"),
                 ],
-            ));
+            ), "create bios boot partition");
         }
     }
     if device.contains("nvme") {
@@ -81,16 +81,10 @@ pub fn partition(device: &str, mode: &str, efi: bool) {
 
 fn part_nvme(device: &str, efi: bool) {
     if efi {
-        returncode_eval(exec(
-            "mkfs.vfat",
-            vec![format!("{}p1", device)],
-        ));
-        returncode_eval(exec(
-            "mkfs.btrfs",
-            vec![format!("{}p2", device)],
-        ));
-        mount(format!("{}p2", device), "/mnt", "");
-        returncode_eval(exec_workdir(
+        exec_eval(exec("mkfs.vfat", vec![format!("{}p1", device)]), format!("format {}p1 as fat32", device).as_str());
+        exec_eval(exec("mkfs.btrfs", vec![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![
@@ -98,8 +92,8 @@ fn part_nvme(device: &str, efi: bool) {
                 String::from("create"),
                 String::from("@"),
             ],
-        ));
-        returncode_eval(exec_workdir(
+        ), "Create btrfs subvolume @");
+        exec_eval(exec_workdir(
             "btrfs",
             "/mnt",
             vec![
@@ -107,25 +101,19 @@ fn part_nvme(device: &str, efi: bool) {
                 String::from("create"),
                 String::from("@home"),
             ],
-        ));
+        ), "Create btrfs subvolume @home");
         umount("/mnt");
-        mount(format!("{}p2", device), "/mnt/", "subvol=@");
-        files::create_directory("/mnt/boot");
-        files::create_directory("/mnt/boot/efi");
-        files::create_directory("/mnt/home");
-        mount(format!("{}p2", device), "/mnt/home", "subvol=@home");
-        mount(format!("{}p1", device), "/mnt/boot/efi", "");
+        mount(format!("{}p2", 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!("{}p2", device).as_str(), "/mnt/home", "subvol=@home");
+        mount(format!("{}p1", device).as_str(), "/mnt/boot/efi", "");
     } else {
-        returncode_eval(exec(
-            "mkfs.ext4",
-            vec![format!("{}p1", device)],
-        ));
-        returncode_eval(exec(
-            "mkfs.btrfs",
-            vec![format!("{}p2", device)],
-        ));
-        mount(format!("{}p2", device), "/mnt/", "");
-        returncode_eval(exec_workdir(
+        exec_eval(exec("mkfs.ext4", vec![format!("{}p1", device)]), format!("format {}p1 as ext4", device).as_str());
+        exec_eval(exec("mkfs.btrfs", vec![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![
@@ -133,8 +121,8 @@ fn part_nvme(device: &str, efi: bool) {
                 String::from("create"),
                 String::from("@"),
             ],
-        ));
-        returncode_eval(exec_workdir(
+        ), "Create btrfs subvolume @");
+        exec_eval(exec_workdir(
             "btrfs",
             "/mnt",
             vec![
@@ -142,28 +130,22 @@ fn part_nvme(device: &str, efi: bool) {
                 String::from("create"),
                 String::from("@home"),
             ],
-        ));
+        ), "Create btrfs subvolume @home");
         umount("/mnt");
-        mount(format!("{}p2", device), "/mnt/", "subvol=@");
-        files::create_directory("/mnt/boot");
-        files::create_directory("/mnt/home");
-        mount(format!("{}p2", device), "/mnt/home", "subvol=@home");
-        mount(format!("{}p1", device), "/mnt/boot", "");
+        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", "");
     }
 }
 
 fn part_disk(device: &str, efi: bool) {
     if efi {
-        returncode_eval(exec(
-            "mkfs.vfat",
-            vec![format!("{}1", device)],
-        ));
-        returncode_eval(exec(
-            "mkfs.btrfs",
-            vec![format!("{}2", device)],
-        ));
-        mount(format!("{}2", device), "/mnt", "");
-        returncode_eval(exec_workdir(
+        exec_eval(exec("mkfs.vfat", vec![format!("{}1", device)]), format!("format {}1 as fat32", device).as_str());
+        exec_eval(exec("mkfs.btrfs", vec![format!("{}2", device)]), format!("format {}2 as btrfs", device).as_str());
+        mount(format!("{}2", device).as_str(), "/mnt", "");
+        exec_eval(exec_workdir(
             "btrfs",
             "/mnt",
             vec![
@@ -171,8 +153,8 @@ fn part_disk(device: &str, efi: bool) {
                 String::from("create"),
                 String::from("@"),
             ],
-        ));
-        returncode_eval(exec_workdir(
+        ), "Create btrfs subvolume @");
+        exec_eval(exec_workdir(
             "btrfs",
             "/mnt",
             vec![
@@ -180,25 +162,19 @@ fn part_disk(device: &str, efi: bool) {
                 String::from("create"),
                 String::from("@home"),
             ],
-        ));
+        ), "Create btrfs subvolume @home");
         umount("/mnt");
-        mount(format!("{}2", device), "/mnt/", "subvol=@");
-        files::create_directory("/mnt/boot");
-        files::create_directory("/mnt/boot/efi");
-        files::create_directory("/mnt/home");
-        mount(format!("{}2", device), "/mnt/home", "subvol=@home");
-        mount(format!("{}1", device), "/mnt/boot/efi", "");
+        mount(format!("{}2", 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!("{}2", device).as_str(), "/mnt/home", "subvol=@home");
+        mount(format!("{}1", device).as_str(), "/mnt/boot/efi", "");
     } else {
-        returncode_eval(exec(
-            "mkfs.ext4",
-            vec![format!("{}1", device)],
-        ));
-        returncode_eval(exec(
-            "mkfs.btrfs",
-            vec![format!("{}2", device)],
-        ));
-        mount(format!("{}2", device), "/mnt/", "");
-        returncode_eval(exec_workdir(
+        exec_eval(exec("mkfs.ext4", vec![format!("{}1", device)]), format!("format {}1 as ext4", device).as_str());
+        exec_eval(exec("mkfs.btrfs", vec![format!("{}2", device)]), format!("format {}2 as btrfs", device).as_str());
+        mount(format!("{}2", device).as_str(), "/mnt/", "");
+        exec_eval(exec_workdir(
             "btrfs",
             "/mnt",
             vec![
@@ -206,8 +182,8 @@ fn part_disk(device: &str, efi: bool) {
                 String::from("create"),
                 String::from("@"),
             ],
-        ));
-        returncode_eval(exec_workdir(
+        ), "Create btrfs subvolume @");
+        exec_eval(exec_workdir(
             "btrfs",
             "/mnt",
             vec![
@@ -215,40 +191,29 @@ fn part_disk(device: &str, efi: bool) {
                 String::from("create"),
                 String::from("@home"),
             ],
-        ));
+        ), "create btrfs subvolume @home");
         umount("/mnt");
-        mount(format!("{}2", device), "/mnt/", "subvol=@");
-        files::create_directory("/mnt/boot");
-        files::create_directory("/mnt/home");
-        mount(format!("{}2", device), "/mnt/home", "subvol=@home");
-        mount(format!("{}1", device), "/mnt/boot", "");
+        mount(format!("{}2", 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!("{}2", device).as_str(), "/mnt/home", "subvol=@home");
+        mount(format!("{}1", device).as_str(), "/mnt/boot", "");
     }
 }
 
-fn mount(partition: String, mountpoint: &str, options: &str) {
+fn mount(partition: &str, mountpoint: &str, options: &str) {
     let options = if options.is_empty() { "\"\"" } else { options };
-    returncode_eval(exec(
+    exec_eval(exec(
         "mount",
         vec![
-            partition,
+            String::from(partition),
             String::from(mountpoint),
             String::from("-o"),
             String::from(options),
         ],
-    ));
+    ), format!("mount {} with options {} at {}", partition, options, mountpoint).as_str());
 }
 
 fn umount(mountpoint: &str) {
-    returncode_eval(exec("umount", vec![String::from(mountpoint)]));
-}
-
-fn returncode_eval(return_code: std::result::Result<std::process::Output, std::io::Error>) {
-    match return_code {
-        Ok(_) => {
-            log("Success".to_string());
-        }
-        Err(e) => {
-            crash(format!("Failed with error: {}", e), 1);
-        }
-    }
+    exec_eval(exec("umount", vec![String::from(mountpoint)]), format!("unmount {}", mountpoint).as_str());
 }

src/functions/users.rs

@@ -2,7 +2,7 @@ use crate::internal::exec::*;
 use crate::internal::*;
 
 pub fn new_user(username: &str, hasroot: bool, password: &str) {
-    let return_val = exec_chroot(
+    exec_eval(exec_chroot(
         "useradd",
         vec![
             String::from("-m"),
@@ -10,20 +10,9 @@ pub fn new_user(username: &str, hasroot: bool, password: &str) {
             String::from("/bin/bash"),
             String::from(username),
         ],
-    );
-    match return_val {
-        Ok(_) => {
-            log(format!("Created user {}", username));
-        }
-        Err(e) => {
-            crash(
-                format!("Failed to create user {}, Error: {}", username, e),
-                1,
-            );
-        }
-    }
+    ), format!("Create user {}", username).as_str());
     if hasroot {
-        let return_val = exec_chroot(
+        exec_eval(exec_chroot(
             "usermod",
             vec![
                 String::from("-a"),
@@ -31,17 +20,9 @@ pub fn new_user(username: &str, hasroot: bool, password: &str) {
                 String::from("wheel"),
                 String::from(username),
             ],
-        );
-        match return_val {
-            Ok(_) => {
-                log(format!("Added user {} to group wheel", username));
-            }
-            Err(e) => {
-                crash(format!("Failed to add user {}, Error: {}", username, e), 1);
-            }
-        }
+        ), format!("Add user {} to wheel group", username).as_str());
     }
-    let return_val = exec_chroot(
+    exec_eval(exec_chroot(
         "usermod",
         vec![
             String::from("--password"),
@@ -54,23 +35,12 @@ pub fn new_user(username: &str, hasroot: bool, password: &str) {
             String::from("-stdin)"),
             String::from(username),
         ],
-    );
-    match return_val {
-        Ok(_) => {
-            log(format!("Set password for user {}", username));
-        }
-        Err(e) => {
-            crash(
-                format!("Failed to set password for user {}, Error: {}", username, e),
-                1,
-            );
-        }
-    }
+    ), format!("Set password for user {}", username).as_str());
 }
 
 pub fn root_pass(root_pass: &str) {
     println!("Setting root password to '{}'", root_pass);
-    let return_val = exec_chroot(
+    exec_eval(exec_chroot(
         "usermod",
         vec![
             String::from("--password"),
@@ -83,13 +53,5 @@ pub fn root_pass(root_pass: &str) {
             String::from("-stdin)"),
             String::from("root"),
         ],
-    );
-    match return_val {
-        Ok(_) => {
-            log("Set root password".to_string());
-        }
-        Err(e) => {
-            crash(format!("Failed to set root password, Error: {}", e), 1);
-        }
-    }
+    ), "set root password");
 }

src/internal/exec.rs

@@ -1,18 +1,18 @@
 use std::process::Command;
 
-pub fn exec(command: &str, args: Vec<String>) -> Result<std::process::Output, std::io::Error> {
-    let returncode = Command::new(command).args(args).output();
+pub fn exec(command: &str, args: Vec<String>) -> Result<std::process::ExitStatus, std::io::Error> {
+    let returncode = Command::new(command).args(args).status();
     returncode
 }
 
 pub fn exec_chroot(
     command: &str,
-    args: Vec<String>,
-) -> Result<std::process::Output, std::io::Error> {
+    args: Vec<String>
+) -> Result<std::process::ExitStatus, std::io::Error> {
     let returncode = Command::new("arch-chroot")
         .args(&["/mnt", command])
         .args(args)
-        .output();
+        .status();
     returncode
 }
 
@@ -20,10 +20,10 @@ pub fn exec_workdir(
     command: &str,
     workdir: &str,
     args: Vec<String>,
-) -> Result<std::process::Output, std::io::Error> {
+) -> Result<std::process::ExitStatus, std::io::Error> {
     let returncode = Command::new(command)
         .args(args)
         .current_dir(workdir)
-        .output();
+        .status();
     returncode
 }

src/internal/files.rs

@@ -3,13 +3,13 @@ use std::fs::{File, OpenOptions};
 use std::io::prelude::*;
 
 pub fn create_file(path: &str) {
-    let return_val = File::create(path);
-    match return_val {
-        Ok(_file) => {
-            log(format!("Created file {}", path));
+    let returncode = File::create(path);
+    match returncode {
+        Ok(_) => {
+            log(format!("Create {}: Sucess", path));
         }
         Err(e) => {
-            crash(format!("Failed to create file {}, Error: {}", path, e), 1);
+            crash(format!("Create {}: Failed with error {}", path, e), 1);
         }
     }
 }
@@ -21,18 +21,6 @@ pub fn append_file(path: &str, content: &str) -> std::io::Result<()> {
     Ok(())
 }
 
-pub fn create_directory(path: &str) {
-    let return_val = std::fs::create_dir(path);
-    match return_val {
-        Ok(_) => {
-            log(format!("Created directory {}", path));
-        }
-        Err(e) => {
-            crash(
-                format!("Failed to create directory {}, Error: {}", path, e),
-                1,
-            );
-        }
-    }
+pub fn create_directory(path: &str) -> std::io::Result<()> {
+    std::fs::create_dir(path)
 }
-

src/internal/mod.rs

@@ -2,6 +2,7 @@ pub mod exec;
 pub mod files;
 pub mod install;
 pub mod strings;
+pub mod returncode_eval;
 
 pub fn install(pkgs: Vec<&str>) {
     install::install(pkgs);
@@ -15,6 +16,14 @@ pub fn log(a: String) {
     strings::log(a);
 }
 
+pub fn files_eval(returncode: std::result::Result<(), std::io::Error>, logmsg: &str) {
+    returncode_eval::files_eval(returncode, logmsg);
+}
+
+pub fn exec_eval(returncode: std::result::Result<std::process::ExitStatus, std::io::Error>, logmsg: &str) {
+    returncode_eval::exec_eval(returncode, logmsg);
+}
+
 #[macro_export]
 macro_rules! uwu {
     ($x:expr) => {{

src/internal/returncode_eval.rs

@@ -0,0 +1,23 @@
+use crate::internal::*;
+
+pub fn exec_eval(return_code: std::result::Result<std::process::ExitStatus, std::io::Error>, logmsg: &str) {
+    match &return_code {
+        Ok(_) => {
+            log(format!("{}: Success", logmsg));
+        }
+        Err(e) => {
+            crash(format!("{}: Failed with error: {}", logmsg, e), return_code.unwrap_err().raw_os_error().unwrap());
+        }
+    }
+}
+
+pub fn files_eval(return_code: std::result::Result<(), std::io::Error>, logmsg: &str) {
+    match &return_code {
+        Ok(_) => {
+            log(format!("[ \x1b[2;1;32mOK\x1b[0m ] {}", logmsg));
+        }
+        Err(e) => {
+            crash(format!("[ \x1b[2;1;31mFAILED\x1b[0m ] {}  ERROR: {}", logmsg, e), return_code.unwrap_err().raw_os_error().unwrap());
+        }
+    }
+}

src/main.rs

@@ -8,6 +8,7 @@ fn main() {
     let app = App::new("jade")
         .version(env!("CARGO_PKG_VERSION"))
         .about(env!("CARGO_PKG_DESCRIPTION"))
+        .author(env!("CARGO_PKG_AUTHORS"))
         .subcommand(
             SubCommand::with_name("partition")
                 .about("Partition the install destination")
@@ -29,6 +30,32 @@ fn main() {
                         .takes_value(false),
                 ),
         )
+        .subcommand(
+            SubCommand::with_name("install-base")
+                .about("Install base packages")
+        )
+        .subcommand(
+            SubCommand::with_name("bootloader")
+                .about("Install bootloader")
+                .subcommand(
+                    SubCommand::with_name("grub-efi")
+                        .about("Install grub-efi")
+                        .arg(
+                            Arg::with_name("efidir")
+                                .help("The directory to install the EFI bootloader to")
+                                .required(true),
+                        ),   
+                )
+                .subcommand(
+                    SubCommand::with_name("grub-legacy")
+                        .about("Install grub-legacy")
+                        .arg(
+                            Arg::with_name("device")
+                                .help("The device to install the bootloader to")
+                                .required(true),
+                        ),
+                ),
+        )
         .subcommand(
             SubCommand::with_name("locale")
                 .about("Set locale stuff")
@@ -58,6 +85,12 @@ fn main() {
                         .help("The hostname to use")
                         .required(true),
                 )
+                .arg(
+                    Arg::with_name("create-hosts")
+                        .help("create /etc/hosts")
+                        .long("hosts")
+                        .takes_value(false),
+                )
                 .arg(
                     Arg::with_name("ipv6")
                         .help("Wether ipv6 should be enabled")
@@ -65,7 +98,7 @@ fn main() {
                         .long("ipv6")
                         .required(true)
                         .takes_value(false),
-                )
+                ),
         )
         .subcommand(
             SubCommand::with_name("users")
@@ -128,7 +161,8 @@ fn main() {
         locale::set_keyboard(kbrlayout);
         locale::set_timezone(timezn);
     } else if let Some(app) = app.subcommand_matches("networking") {
-        network::enable_ipv6(app.is_present("ipv6"));
+        if app.is_present("ipv6") { network::enable_ipv6() }
+        if app.is_present("create-hosts") { network::create_hosts() }
         network::set_hostname(app.value_of("hostname").unwrap())
     } else if let Some(app) = app.subcommand_matches("users") {
         if let Some(app) = app.subcommand_matches("newUser") {
@@ -144,6 +178,14 @@ fn main() {
         }
     } else if let Some(app) = app.subcommand_matches("desktops") {
         desktops::choose_pkgs(app.value_of("desktopsetup").unwrap());
+    } else if let Some(app) = app.subcommand_matches("bootloader") {
+        if let Some(app) = app.subcommand_matches("grub-efi") {
+            base::install_bootloader_efi(app.value_of("efidir").unwrap());
+        } else if let Some(app) = app.subcommand_matches("grub-legacy") {
+            base::install_bootloader_legacy(app.value_of("device").unwrap());
+        }
+    } else if let Some(_) = app.subcommand_matches("install-base") {
+        base::install_base_packages();
     } else {
         println!("Running TUI installer");
     }