build: add base build system

Author: jwpjrdev

.cargo/config.toml

@@ -1,2 +1,2 @@
 [alias]
-aero = "run --release --manifest-path ./aero_build/Cargo.toml --"
+aero = "run --manifest-path ./src/aero_build/Cargo.toml --"

src/Cargo.toml

@@ -1,5 +1,7 @@
 [workspace]
 members = ["aero_kernel", "aero_syscall", "aero_proc"]
+# if aero_build is part of the workspace, cargo will attempt to build it as no_std
+exclude = ["aero_build"]
 
 [profile.release]
 debug = true

src/aero_build/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "aero_build"
+version = "0.1.0"
+authors = ["Joshua Price <[email protected]>"]
+edition = "2021"
+
+[dependencies]
+# clap = "3.2.22"

src/aero_build/src/build.rs

@@ -0,0 +1,41 @@
+use std::path::Path;
+use std::process::Command;
+
+use crate::utils;
+use crate::constants;
+
+struct BuildInfo {
+    args: Vec<String>,
+    target_arch: String,
+}
+
+pub fn build() {
+    utils::log_info("build test");
+
+    let output = utils::run_command(&std::env::current_dir().unwrap(), "/usr/bin/ls", vec![String::from("-l"), String::from("-a")]);
+    println!("{:?}", output);
+    output.log_if_exists();
+}
+
+fn build_cargo_workspace(cwd: &Path, command: &str, args: Vec<String>, cargo: Option<&str>) {
+    // let cargo_cmd = cargo.unwrap_or("cargo");
+
+    // Command::new(cargo_cmd)
+    //     .arg(command)
+    //     .args(args)
+    //     .current_dir(cwd)
+    //     .spawn()
+    //     .expect("cargo failed to run");
+
+    // let code, _, _ = run_command([cargo.unwrap_or("cargo"), command, *args], cwd=cwd);
+
+    // if code != 0:
+    //     return None
+
+    // _, stdout, _ = run_command([cargo, command, *args, '--message-format=json'],
+    //                            stdout=subprocess.PIPE,
+    //                            stderr=subprocess.DEVNULL,
+    //                            cwd=cwd)
+
+    // return extract_artifacts(stdout);
+}

src/aero_build/src/constants.rs

@@ -0,0 +1,36 @@
+use std::path::Path;
+
+#[macro_export]
+macro_rules! const_str {
+    ($name:ident, $value:expr) => {
+        pub const $name: &'static str = $value;
+    };
+}
+
+const_str!(OVMF_URL, "https://github.com/aero-os/ovmf-prebuilt");
+
+// pub const OVMF_URL = "https://github.com/aero-os/ovmf-prebuilt";
+const_str!(LIMINE_URL, "https://github.com/limine-bootloader/limine");
+
+const_str!(BUILD_DIR, "build");
+const_str!(BUNDLED_DIR, "bundled");
+const_str!(SYSROOT_DIR, "sysroot");
+const_str!(SYSROOT_CARGO_HOME, "sysroot/cargo-home");
+const_str!(EXTRA_FILES, "extra-files");
+const_str!(BASE_FILES_DIR, "base-files");
+const_str!(LIMINE_TEMPLATE, r#"
+TIMEOUT=0
+VERBOSE=yes
+
+:aero
+PROTOCOL=limine
+KASLR=no
+KERNEL_PATH=boot:///aero.elf
+CMDLINE=term-background=background theme-background=0x50000000
+
+MODULE_PATH=boot:///term_background.bmp
+MODULE_CMDLINE=background
+
+MODULE_PATH=boot:///initramfs.cpio
+MODULE_CMDLINE=initramfs
+"#);

src/aero_build/src/main.rs

@@ -0,0 +1,16 @@
+use std::env;
+
+mod build;
+mod constants;
+mod test;
+mod utils;
+
+fn main() {
+    let arg = env::args().nth(1);
+    match arg.as_ref().map(|x| x.as_str()) {
+        Some("build") => build::build(),
+        Some("test") => test::test(),
+        None => eprintln!("no task specified\navailable tasks: build, test"),
+        _ => eprintln!("specified task does not exist\navailable tasks: build, test"),
+    }
+}

src/aero_build/src/test.rs

@@ -0,0 +1,3 @@
+pub fn test() {
+    println!("test");
+}

src/aero_build/src/utils.rs

@@ -0,0 +1,59 @@
+use std::process::{Command, ExitStatus};
+use std::path::Path;
+
+const ANSI_ESCAPE: &str = "\x1b[";
+const ANSI_BOLD_RED: &str = "1;31m";
+const ANSI_BOLD_GREEN: &str = "1;32m";
+const ANSI_RESET: &str = "0m";
+
+pub fn log_info(message: &str) {
+    println!("{ANSI_ESCAPE}{ANSI_BOLD_GREEN}info: {ANSI_ESCAPE}{ANSI_RESET}{message}");
+}
+
+pub fn log_error(message: &str) {
+    println!("{ANSI_ESCAPE}{ANSI_BOLD_RED}red: {ANSI_ESCAPE}{ANSI_RESET}{message}");
+}
+
+#[derive(Debug)]
+pub struct CommandOutput {
+    pub exit_status: ExitStatus,
+    pub stdout: Option<String>,
+    pub stderr: Option<String>,
+}
+
+impl CommandOutput {
+    pub fn log_if_exists(&self) {
+        if let Some(stdout) = &self.stdout {
+            log_info(&stdout);
+        }
+        if let Some(stderr) = &self.stderr {
+            log_error(&stderr);
+        }
+    }
+}
+
+pub fn run_command(pwd: &Path, command: &str, args: Vec<String>) -> CommandOutput {
+    let output = Command::new(command)
+        .arg(command)
+        .args(args)
+        // .current_dir(pwd)
+        .output()
+        .expect("todo");
+
+    let stdout = if !&output.stdout.is_empty() {
+        Some(String::from_utf8(output.stdout).unwrap())
+    } else {
+        None
+    };
+    let stderr = if !&output.stderr.is_empty() {
+        Some(String::from_utf8(output.stderr).unwrap())
+    } else {
+        None
+    };
+
+    CommandOutput {
+        exit_status: output.status,
+        stdout: stdout,
+        stderr: stderr,
+    }
+}