AeroLinux/AeroPkg
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix building skip at non-updated build-script

Browse Source
This commit is contained in:
TraceLumen
2026-09-10 18:23:25 +03:00
parent c13fbb6312
commit 50bd819dfd
1 changed files with 96 additions and 63 deletions
Download Patch File Download Diff File Expand all files Collapse all files

151
src/commands/run/build.rs
View File

@ -1,81 +1,114 @@
use std::fs; use std::fs;
use crate::commands::link::link;
use crate::utils::parser::{self, env::get_install_env}; use crate::utils::parser::{self, env::get_install_env};
use crate::utils::shell::{run_install_script, run_install_script_hook}; use crate::utils::shell::{run_install_script, run_install_script_hook};
use crate::commands::link::link; use super::{download, patch};
use super::download::download;
use super::patch::patch;
pub fn build(repo: &String, pkgname: &String) { pub fn build(repo: &String, pkgname: &String) {
let pkgpath = &crate::commands::get_aeropkg_base().join(repo).join(pkgname); let base = crate::commands::get_aeropkg_base();
fs::create_dir_all(&pkgpath).ok(); let var = crate::commands::get_aeropkg_var();
let src = &pkgpath.join("src");
let pkg_md_path = &crate::commands::get_aeropkg_var().join(format!("{}/{}.md", repo, pkgname)); let pkg_dir = base.join(repo).join(pkgname);
let builded_pkg_md_path = &crate::commands::get_aeropkg_base().join(repo).join(pkgname).join("build-script.md"); let src_dir = pkg_dir.join("src");
fs::create_dir_all(&pkg_dir).ok();
let build_script = match parser::get_build_script(pkg_md_path) { let md_path = var.join(format!("{}/{}.md", repo, pkgname));
Ok(script) => script, let built_md_path = pkg_dir.join("build-script.md");
Err(error) => {
panic!("Failed to parse build script: {}", error); let build_script = parser::get_build_script(&md_path)
} .unwrap_or_else(|e| panic!("Failed to parse build script: {}", e));
}; let full_env = get_install_env(repo, pkgname, &md_path, "build");
if builded_pkg_md_path.exists() {
let builded_script = match parser::get_build_script(builded_pkg_md_path) { if is_build_up_to_date(&built_md_path, &build_script, &full_env, repo, pkgname) {
Ok(script) => script, return;
Err(error) => {
panic!("Failed to parse build block from {}: {}", builded_pkg_md_path.to_string_lossy(), error);
}
};
if build_script == builded_script { return }
} }
if src.join(".aeropkg.applied-build").exists() { let applied_build = src_dir.join(".aeropkg.applied-build");
let src_build = fs::read_to_string(src.join(".aeropkg.applied-build")).unwrap_or("".to_string()); let applied_env = src_dir.join(".aeropkg.install-env");
if build_script == src_build {
return if is_source_up_to_date(&applied_build, &applied_env, &build_script, &full_env) {
} else { return;
fs::remove_dir_all(src).unwrap(); } else if applied_build.exists() {
download(repo, pkgname); fs::remove_dir_all(&src_dir).unwrap();
patch(repo, pkgname) download::download(repo, pkgname);
} patch::patch(repo, pkgname);
} }
let full_env = get_install_env(repo, pkgname, pkg_md_path, "build"); save_env(&applied_env, &full_env);
run_install_script(&build_script, src, &full_env);
run_install_script(&build_script, &src_dir, &full_env);
run_install_script_hook(repo, "build", &full_env); run_install_script_hook(repo, "build", &full_env);
let dest_dir = crate::commands::get_aeropkg_base().join(repo).join(pkgname); fs::create_dir_all(&pkg_dir).ok();
if let Err(e) = fs::create_dir_all(&dest_dir) { panic!("Failed to create destination directory: {}", e) } let _ = fs::remove_file(&built_md_path);
let dest_path = &dest_dir.join("build-script.md"); fs::hard_link(&md_path, &built_md_path)
fs::remove_file(dest_path).ok(); .unwrap_or_else(|e| panic!("Failed to link build script: {}", e));
if let Err(e) = fs::hard_link(pkg_md_path, dest_path) { panic!("Failed to copy build script to destination: {}", e) } fs::write(&applied_build, &build_script).unwrap();
fs::write(src.join(".aeropkg.applied-build"), &build_script).unwrap();
// Очистка и пост-хуки
let save_source_flag = full_env.get("save_source").is_some(); if full_env.get("save_source").is_none() {
if !save_source_flag { fs::remove_dir_all(&src_dir).ok();
if let Err(e) = fs::remove_dir_all(&src) { panic!("Failed to remove source directory: {}", e) }
} }
hook(repo, pkgname); hook(&pkg_dir);
if !full_env.get("disable").is_some() { if full_env.get("disable").is_some() {
let _ = fs::File::create(crate::commands::get_aeropkg_base().join(repo).join(pkgname).join("disabled")); link(repo, pkgname);
} else { } else {
link(repo, pkgname) let _ = fs::File::create(pkg_dir.join("disabled"));
} }
} }
fn hook(pkg_dir: &std::path::Path) {
fn hook(repo: &String, pkgname: &String) { let lib = pkg_dir.join("lib");
let pkg_dir = crate::commands::get_aeropkg_base().join(repo).join(pkgname); for d in ["lib64", "lib32"] {
let lib_dir = &pkg_dir.join("lib"); let dir = pkg_dir.join(d);
let lib64_dir = &pkg_dir.join("lib64"); crate::utils::fs::mv::mv(&dir, &lib).ok();
let lib32_dir = &pkg_dir.join("lib32"); fs::remove_dir_all(&dir).ok();
crate::utils::fs::mv::mv(&lib64_dir, &lib_dir).ok(); }
crate::utils::fs::mv::mv(&lib32_dir, &lib_dir).ok(); }
fs::remove_dir_all(&lib64_dir).ok();
fs::remove_dir_all(&lib32_dir).ok(); fn is_build_up_to_date(
md_path: &std::path::Path,
script: &str,
env: &std::collections::HashMap<String, String>,
repo: &String,
pkgname: &String
) -> bool {
if !md_path.exists() { return false; }
let old_script = match parser::get_build_script(md_path) {
Ok(s) => s,
Err(_) => return false,
};
script == old_script &&
env == &get_install_env(repo, pkgname, md_path, "build")
}
fn is_source_up_to_date(
build_path: &std::path::Path,
env_path: &std::path::Path,
script: &str,
env: &std::collections::HashMap<String, String>
) -> bool {
if !build_path.exists() { return false; }
let old_script = fs::read_to_string(build_path).unwrap_or_default();
let old_env = load_env(env_path);
script == old_script && env == &old_env
}
fn save_env(path: &std::path::Path, env: &std::collections::HashMap<String, String>) {
let mut lines: Vec<_> = env.iter().map(|(k, v)| format!("{}={}", k, v)).collect();
lines.sort();
fs::write(path, lines.join("\n")).ok();
}
fn load_env(path: &std::path::Path) -> std::collections::HashMap<String, String> {
let content = fs::read_to_string(path).unwrap_or_default();
content.lines()
.filter_map(|l| l.split_once('=').map(|(k, v)| (k.to_string(), v.to_string())))
.collect()
} }