v0.1.0 code structure improved

Author: git-user-cpp

src/functionality.rs

@@ -1,3 +1,10 @@
+pub mod commands;
+pub mod configs;
+pub mod env;
+pub mod iptables;
 pub mod prog_fun;
-pub mod setup_fun;
+pub mod shell;
+pub mod software;
+pub mod task;
 pub mod user_cfg;
+pub mod zram;

src/functionality/commands.rs

@@ -0,0 +1,77 @@
+use colored::Colorize;
+use std::{io::Write, process::Command, process::Stdio};
+
+/// runs sudo commands
+pub fn run_sudo_command(command: &str, args: &[&str]) -> Result<(), String> {
+    let output = Command::new("sudo")
+        .arg(command)
+        .args(args)
+        .output()
+        .map_err(|e| format!("{} {}: {}", "failed to execute command:".red(), command, e))?;
+
+    if output.status.success() {
+        Ok(())
+    } else {
+        Err(format!(
+            "command `{}` failed:\nstdout: {}\nstderr: {}",
+            command.red(),
+            String::from_utf8_lossy(&output.stdout).trim(),
+            String::from_utf8_lossy(&output.stderr).trim()
+        ))
+    }
+} // run_sudo_command
+
+/// runs user commands
+pub fn run_user_command(command: &str, args: &[&str]) -> Result<(), String> {
+    let output = Command::new(command)
+        .args(args)
+        .output()
+        .map_err(|e| format!("{} {}: {}", "failed to execute command:".red(), command, e))?;
+
+    if output.status.success() {
+        Ok(())
+    } else {
+        Err(format!(
+            "command `{}` failed:\nstdout: {}\nstderr: {}",
+            command.red(),
+            String::from_utf8_lossy(&output.stdout).trim(),
+            String::from_utf8_lossy(&output.stderr).trim()
+        ))
+    }
+} // run_user_command
+
+/// runs sudo commands with stdin
+pub fn run_sudo_command_with_stdin(
+    command: &str,
+    args: &[&str],
+    stdin_content: String,
+) -> Result<(), String> {
+    let mut cmd = Command::new("sudo")
+        .arg(command)
+        .args(args)
+        .stdin(Stdio::piped())
+        .stdout(Stdio::null())
+        .spawn()
+        .map_err(|e| format!("failed to spawn command `{}`: {}", command, e))?;
+
+    if let Some(mut stdin) = cmd.stdin.take() {
+        stdin
+            .write_all(stdin_content.as_bytes())
+            .map_err(|e| format!("failed to write to stdin of `{}`: {}", command, e))?;
+    }
+
+    let output = cmd
+        .wait_with_output()
+        .map_err(|e| format!("failed to wait for command `{}`: {}", command, e))?;
+
+    if output.status.success() {
+        Ok(())
+    } else {
+        Err(format!(
+            "command `{}` failed:\nStdout: {}\nStderr: {}",
+            command.red(),
+            String::from_utf8_lossy(&output.stdout).trim(),
+            String::from_utf8_lossy(&output.stderr).trim()
+        ))
+    }
+} // run_sudo_command_with_stdin

src/functionality/configs.rs

@@ -0,0 +1,91 @@
+use super::commands::run_sudo_command;
+use colored::Colorize;
+use std::path::Path;
+
+/// sets up config files in home directory
+pub fn user_config_setup(config_path: String, home_dir: String, cfg_name: &str) -> i8 {
+    let source = Path::new(&config_path);
+    let filename = source.file_name();
+
+    match filename {
+        Some(name) => {
+            let destination_path = Path::new(&home_dir).join(name);
+            match std::fs::copy(config_path, &destination_path) {
+                Ok(_) => {
+                    println!("{} {}", cfg_name, "custom config was installed".green());
+                    return 0;
+                }
+                Err(e) => {
+                    eprintln!(
+                        "error: custom config failed to install {} to '{}': {}",
+                        cfg_name,
+                        destination_path.display(),
+                        e
+                    );
+                    return 1;
+                }
+            }
+        }
+        None => {
+            eprintln!(
+                "error: could not determine filename from path: {}",
+                config_path.red()
+            );
+            return 1;
+        }
+    }
+} // user_config_setup
+
+/// sets up root config in /root directory
+pub fn setup_root_config(home_dir: String) -> i8 {
+    let oh_my_zsh_src = format!("{}{}", home_dir, "/.oh-my-zsh");
+    let oh_my_zsh_dest = String::from("/root/.oh-my-zsh");
+    let zshrc_src = format!("{}{}", home_dir, "/.zshrc");
+    let zshrc_dest = String::from("/root/.zshrc");
+    let vimrc_src = format!("{}{}", home_dir, "/.vimrc");
+    let vimrc_dest = String::from("/root/.vimrc");
+
+    // Create symbolic link for .oh-my-zsh
+    match run_sudo_command(
+        "cp",
+        &["-r", oh_my_zsh_src.as_str(), oh_my_zsh_dest.as_str()],
+    ) {
+        Ok(_) => println!("/root/.oh-my-zsh {}", "created configuration".green()),
+        Err(e) => {
+            eprintln!(
+                "{}{}",
+                "error creating configuration /root/.oh-my-zsh:".red(),
+                e.red()
+            );
+            return 1;
+        }
+    }
+
+    // Create symbolic link for .zshrc
+    match run_sudo_command("cp", &["-r", zshrc_src.as_str(), zshrc_dest.as_str()]) {
+        Ok(_) => println!("/root/.zshrc {}", "created configuration".green()),
+        Err(e) => {
+            eprintln!(
+                "{}{}",
+                "error creating configuration /root/.zshrc:".red(),
+                e.red()
+            );
+            return 2;
+        }
+    }
+
+    // Create symbolic link for .vimrc
+    match run_sudo_command("cp", &["-r", vimrc_src.as_str(), vimrc_dest.as_str()]) {
+        Ok(_) => println!("/root/.vimrc {}", "created configuration".green()),
+        Err(e) => {
+            eprintln!(
+                "{}{}",
+                "error creating configuration /root/.vimrc:".red(),
+                e.red()
+            );
+            return 3;
+        }
+    }
+
+    return 0;
+} // setup_root_config

src/functionality/env.rs

@@ -0,0 +1,24 @@
+use colored::Colorize;
+use std::env::var;
+
+/// gets environment variables
+fn get_env_var(env_var: &str) -> Option<String> {
+    match var(env_var) {
+        Ok(username) => Some(username),
+        Err(_) => {
+            eprintln!(
+                "{}\n",
+                "error: could not determine the environment variables.".red()
+            );
+            None
+        }
+    }
+} // get_env_var
+
+/// validates environment variables
+pub fn validate_env_var(env_var: &str) -> String {
+    match get_env_var(env_var) {
+        Some(env_var) => env_var,
+        None => "".to_string(),
+    }
+} // validate_env_var

src/functionality/iptables.rs

@@ -0,0 +1,49 @@
+use super::commands::{run_sudo_command, run_sudo_command_with_stdin};
+use colored::Colorize;
+use std::{fs::read_to_string, path::Path};
+
+/// sets up iptables
+pub fn iptables_file_setup() -> i8 {
+    let source_path = Path::new("../configs/iptables.rules");
+    let dest_path = Path::new("/etc/iptables/iptables.rules");
+
+    match read_to_string(source_path) {
+        Ok(rules) => {
+            let command = "tee";
+            let args = &[dest_path.as_os_str().to_str().unwrap()];
+
+            match run_sudo_command_with_stdin(command, args, rules) {
+                Ok(_) => {
+                    println!("iptables.rules {}", "created successfully".green());
+                    return 0;
+                }
+                Err(e) => {
+                    eprintln!("error setting up iptables file: {}", e);
+                    1
+                }
+            }
+        }
+        Err(e) => {
+            eprintln!("failed to read iptables rules from source file: {}", e);
+            2
+        }
+    }
+} // iptables_setup()
+
+/// immediately sets up iptables rules
+pub fn iptables_rules_setup() -> i8 {
+    let rules_path = String::from("/etc/iptables/iptables.rules");
+    let command = "bash";
+    let args = &["-c", &format!("iptables-restore < {}", rules_path)];
+
+    match run_sudo_command(command, args) {
+        Ok(_) => {
+            println!("iptables.rules {}", "set successfully".green());
+            0
+        }
+        Err(e) => {
+            eprintln!("error applying iptables rules: {}", e);
+            1
+        }
+    }
+} // iptables_rules_setup()

src/functionality/prog_fun.rs

@@ -11,6 +11,7 @@ pub fn default_sw_package() -> Vec<String> {
         "gimp".to_string(),
         "mpv".to_string(),
         "spectacle".to_string(),
+        "curl".to_string(),
     ]
 } // default_package()