145 lines
4.7 KiB
Rust
145 lines
4.7 KiB
Rust
use anyhow::anyhow;
|
|
use std::fs;
|
|
use std::process::Stdio;
|
|
use std::time::SystemTime;
|
|
use tokio::io::{AsyncBufReadExt, BufReader, Lines};
|
|
use tokio::sync::broadcast::Sender;
|
|
|
|
pub async fn build_pkgbuild(
|
|
folder_path: String,
|
|
pkg_vers: &str,
|
|
pkg_name: &str,
|
|
tx: Sender<String>,
|
|
) -> anyhow::Result<String> {
|
|
let mut child = tokio::process::Command::new("pacman")
|
|
.args([
|
|
"-Sy",
|
|
])
|
|
.stdout(Stdio::piped())
|
|
.stderr(Stdio::piped())
|
|
.spawn()?;
|
|
child.wait().await?;
|
|
|
|
let makepkg = include_str!("../../scripts/makepkg");
|
|
|
|
// Create a temporary file to store the bash script content
|
|
let script_file = std::env::temp_dir().join("makepkg_custom.sh");
|
|
fs::write(&script_file, makepkg).expect("Unable to write script to file");
|
|
|
|
let mut child = tokio::process::Command::new("bash")
|
|
.args(&[
|
|
script_file.as_os_str().to_str().unwrap(),
|
|
"-f",
|
|
"--noconfirm",
|
|
"--nocolor",
|
|
"-s", // install required deps
|
|
"-c", // cleanup leftover files and dirs
|
|
"--rmdeps", // remove installed deps with -s
|
|
"--noprogressbar", // pacman shouldn't display a progressbar
|
|
])
|
|
.current_dir(folder_path.clone())
|
|
.stdout(Stdio::piped())
|
|
.stderr(Stdio::piped())
|
|
.spawn()?;
|
|
|
|
let stderr = child
|
|
.stderr
|
|
.take()
|
|
.ok_or(anyhow!("failed to take stderr"))?;
|
|
let stdout = child
|
|
.stdout
|
|
.take()
|
|
.ok_or(anyhow!("failed to take stdout"))?;
|
|
|
|
let stderr = BufReader::new(stderr).lines();
|
|
let stdout = BufReader::new(stdout).lines();
|
|
|
|
let tx1 = tx.clone();
|
|
spawn_broadcast_sender(stderr, tx1);
|
|
spawn_broadcast_sender(stdout, tx);
|
|
|
|
let result = child.wait().await;
|
|
|
|
match result {
|
|
Ok(result) => {
|
|
if !result.success() {
|
|
return Err(anyhow!("failed to build package"));
|
|
}
|
|
}
|
|
Err(err) => {
|
|
eprintln!("Failed to execute makepkg: {}", err);
|
|
return Err(anyhow!("failed to build package"));
|
|
}
|
|
}
|
|
|
|
locate_built_package(pkg_name.to_string(), pkg_vers.to_string(), folder_path)
|
|
}
|
|
|
|
fn spawn_broadcast_sender<R: tokio::io::AsyncRead + Unpin + Send + 'static>(
|
|
mut reader: Lines<BufReader<R>>,
|
|
tx: Sender<String>,
|
|
) {
|
|
tokio::spawn(async move {
|
|
while let Ok(Some(line)) = reader.next_line().await {
|
|
// println!("directerr: {line}");
|
|
let _ = tx.send(line);
|
|
}
|
|
});
|
|
}
|
|
|
|
fn locate_built_package(
|
|
pkg_name: String,
|
|
pkg_vers: String,
|
|
folder_path: String,
|
|
) -> anyhow::Result<String> {
|
|
// check if expected built dir exists
|
|
let built_name = build_expected_repo_packagename(pkg_name.to_string(), pkg_vers.to_string());
|
|
if fs::metadata(format!("{folder_path}/{built_name}")).is_ok() {
|
|
println!("Built {built_name}");
|
|
return Ok(built_name.to_string());
|
|
}
|
|
|
|
// the naming might not always contain the build version
|
|
// eg. mesa-git --> match pkgname and extension if multiple return latest
|
|
if let Ok(paths) = fs::read_dir(folder_path) {
|
|
let mut candidate_filename: Option<String> = None;
|
|
let mut candidate_timestamp = SystemTime::UNIX_EPOCH;
|
|
|
|
for path in paths {
|
|
if let Ok(path) = path {
|
|
let path = path.path();
|
|
if let Some(file_name) = path.file_name() {
|
|
let file_name = file_name.to_str().unwrap();
|
|
|
|
if file_name.ends_with("-x86_64.pkg.tar.zst")
|
|
&& file_name.starts_with(pkg_name.as_str())
|
|
{
|
|
if let Ok(metadata) = path.metadata() {
|
|
if let Ok(modified_time) = metadata.modified() {
|
|
// Update the candidate filename and timestamp if the current file is newer
|
|
if modified_time > candidate_timestamp {
|
|
candidate_filename = Some(file_name.to_string());
|
|
candidate_timestamp = modified_time;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if candidate_filename.is_some() {
|
|
println!("Built {}", candidate_filename.clone().unwrap());
|
|
return Ok(candidate_filename.unwrap());
|
|
}
|
|
}
|
|
|
|
Err(anyhow!("Built package not found"))
|
|
}
|
|
|
|
/// don't trust this pkg name from existing
|
|
/// pkgbuild might build different version name
|
|
pub fn build_expected_repo_packagename(pkg_name: String, pkg_vers: String) -> String {
|
|
format!("{pkg_name}-{pkg_vers}-x86_64.pkg.tar.zst")
|
|
}
|