main bin to build all packages

1 files changed, 216 insertions, 0 deletions

diff --git a/src/main.rs b/src/main.rs
new file mode 100644
index 0000000..87c21f0
--- /dev/null
+++ b/src/main.rs
@@ -0,0 +1,216 @@
+use alpm::Alpm;
+use pkgbuild::PackageMeta;
+use std::process::{Child, Command};
+
+#[tokio::main]
+async fn main() {
+    let mut package_list = pkgbuild::latest_package_list().await;
+
+    let handle = pkgbuild::setup_alpm();
+
+    package_list.sort_by(|a, b| b.popularity.partial_cmp(&a.popularity).unwrap());
+
+    for package in &package_list {
+        build_pkg(&package.name, &package_list, &handle);
+    }
+}
+
+pub fn build_pkg(package_name: &str, package_list: &[PackageMeta], handle: &Alpm) {
+    let package = package_list.iter().find(|p| p.name == package_name);
+    if package.is_none() {
+        println!("Package {} not found", package_name);
+        return;
+    }
+
+    let package = package.expect("package is None");
+    let dependencies = package.resolve_dependencies(&handle, &package_list);
+    for dependency in dependencies {
+        match dependency {
+            pkgbuild::Dependency::AUR(dep) => build_pkg(&dbg!(dep).name, &package_list, &handle),
+            _ => (),
+        }
+    }
+
+    let pkg_dir = format!(
+        "{}/pkgbuild/{}",
+        dirs::cache_dir().unwrap().to_str().unwrap(),
+        package_name
+    );
+
+    if dbg!(std::path::Path::new(dbg!(&pkg_dir)).exists()) {
+        let mut command = Command::new("git");
+        command.current_dir(&pkg_dir).arg("pull");
+        dbg!(&command);
+        print_status(command.spawn());
+    } else {
+        let mut command = Command::new("mkdir");
+        command.arg("-p").arg(format!(
+            "{}/pkgbuild/",
+            dirs::cache_dir().unwrap().to_str().unwrap()
+        ));
+        dbg!(&command);
+        print_status(command.spawn());
+
+        let mut command = Command::new("git");
+        command
+            .arg("clone")
+            .arg("--single-branch")
+            .arg("--branch")
+            .arg(&package_name)
+            .arg(format!(
+                "{}/aur.git",
+                dirs::home_dir().unwrap().to_str().unwrap()
+            ))
+            .arg(&pkg_dir);
+        dbg!(&command);
+        print_status(command.spawn());
+    }
+
+    let mut command = Command::new("makepkg");
+    command.current_dir(&pkg_dir).arg("--packagelist");
+    dbg!(&command);
+    let output = command.output().expect("Failed to execute command");
+    let package_list = String::from_utf8(output.stdout)
+        .unwrap()
+        .trim()
+        .to_string()
+        .split_whitespace()
+        .map(String::from)
+        .collect::<Vec<String>>();
+    println!("{:?}", package_list);
+
+    if package_list
+        .iter()
+        .all(|p| dbg!(std::path::Path::new(dbg!(&p)).exists()))
+    {
+        println!("{package_name} already built, skipping fresh build");
+    } else {
+        let chroot_dir = std::env::var("PKGBUILD_CHROOT_DIR")
+            .unwrap_or_else(|_| String::from("/var/lib/pkgbuild"))
+            .trim_end_matches('/')
+            .to_string();
+
+        let mut command = Command::new("makechrootpkg");
+        command
+            .current_dir(&pkg_dir)
+            .arg("-u")
+            .arg("-l")
+            .arg(&package_name)
+            .arg("-r")
+            .arg(chroot_dir)
+            .arg("-D")
+            .arg(format!(
+                "{}/pacman.conf:/etc/pacman.conf",
+                std::env::current_dir().unwrap().display()
+            ))
+            .arg("-D")
+            .arg(format!(
+                "{}/makepkg.conf:/etc/makepkg.conf",
+                std::env::current_dir().unwrap().display()
+            ))
+            .arg("-D")
+            .arg(format!(
+                "{}:/mnt/pkgbuild",
+                std::env::var("PKGBUILD_REPO_ROOT")
+                    .expect("PKGBUILD_REPO_ROOT not set")
+                    .trim_end_matches('/')
+            ))
+            .arg("-d")
+            .arg("/var/cache/pacman/pkg/")
+            .arg("--")
+            .args(["--skippgpcheck", "--syncdeps"]);
+        dbg!(&command);
+        print_status(command.spawn());
+    }
+
+    if let Ok(gpg_sign) = std::env::var("PKGBUILD_GPG_SIGN") {
+        if gpg_sign == "true" || gpg_sign == "1" {
+            for package in &package_list {
+                let mut command = Command::new("gpg");
+                if let Ok(gpg_key) = std::env::var("PKGBUILD_GPG_KEY") {
+                    command.arg("--key").arg(gpg_key);
+                }
+                command
+                    .arg("--detach-sign")
+                    .arg("--use-agent")
+                    .arg("--batch")
+                    .arg("--yes")
+                    .arg("--output")
+                    .arg(format!("{}.sig", package))
+                    .arg(package);
+                dbg!(&command);
+                print_status(command.spawn());
+            }
+        }
+    }
+
+    let mut command = Command::new("repo-add");
+    if let Ok(gpg_sign) = std::env::var("PKGBUILD_GPG_SIGN") {
+        if gpg_sign == "true" || gpg_sign == "1" {
+            command.arg("--sign");
+        }
+    }
+    if let Ok(gpg_key) = std::env::var("PKGBUILD_GPG_KEY") {
+        command.arg("--key").arg(gpg_key);
+    }
+    command.arg("--remove");
+    command.arg(format!(
+        "{}/{}.db.tar.zst",
+        std::env::var("PKGBUILD_REPO_ROOT")
+            .expect("PKGBUILD_REPO_ROOT not set")
+            .trim_end_matches('/'),
+        std::env::var("PKGBUILD_REPO_NAME").expect("PKGBUILD_REPO_NAME not set"),
+    ));
+    for package in &package_list {
+        command.arg(package);
+    }
+    dbg!(&command);
+    print_status(command.spawn());
+    for package in &package_list {
+        std::fs::copy(
+            package,
+            format!(
+                "{}/{}",
+                std::env::var("PKGBUILD_REPO_ROOT")
+                    .expect("PKGBUILD_REPO_ROOT not set")
+                    .trim_end_matches('/'),
+                std::path::Path::new(&package)
+                    .file_name()
+                    .unwrap()
+                    .to_string_lossy()
+            ),
+        )
+        .expect("Failed to copy package");
+        let sig = format!("{}.sig", package);
+        std::fs::copy(
+            &sig,
+            format!(
+                "{}/{}",
+                std::env::var("PKGBUILD_REPO_ROOT")
+                    .expect("PKGBUILD_REPO_ROOT not set")
+                    .trim_end_matches('/'),
+                std::path::Path::new(&sig)
+                    .file_name()
+                    .unwrap()
+                    .to_string_lossy()
+            ),
+        )
+        .expect("Failed to copy signature");
+    }
+}
+
+fn print_status(output: Result<Child, std::io::Error>) {
+    match output {
+        Ok(mut child) => match child.wait() {
+            Ok(status) => {
+                println!("STATUS: {}", status.code().unwrap_or(-1));
+            }
+            Err(e) => {
+                println!("ERROR: {e}");
+            }
+        },
+        Err(e) => {
+            println!("ERROR: {e}");
+        }
+    }
+}