before index-conflict changes

src/commands/install.rs

@@ -1,123 +1,27 @@
-use std::fs;
-use std::path::{Path, PathBuf};
-use std::process::{Command, Stdio};
+use std::path::Path;
 use std::process;
-use std::os::unix::fs::MetadataExt;
 
-use crate::utils::parser;
-use crate::commands::link::link;
+use crate::utils::parser::{self, pkginfo};
+use super::run::download::download;
+use super::run::patch::patch;
+use super::run::build::build;
+use super::run::config::config;
 
 
 pub fn install(repo: &String, pkgname: &String) -> Result<(), bool> {
-    let var_path = super::get_var_path();
-    let pkg_md_path = var_path.join(format!("{}/{}.md", &repo, &pkgname));
-    let builded_pkg_md_path = PathBuf::from("/pkg").join(&repo).join(&pkgname).join("build-script.md");
-
-    if !pkg_md_path.exists() {
-        upload_from_repo(&repo, &pkgname, &pkg_md_path)?;
-    }
-
-    if builded_pkg_md_path.exists() {
-        if fs::metadata(&builded_pkg_md_path).unwrap().ino() == fs::metadata(&pkg_md_path).unwrap().ino() {
-            println!("package {} already installed in {} repo", &pkgname, &repo);
-            return Ok(())
-        }
-    }
+    let pkg_md_path = crate::commands::get_var_path().join(format!("{}/{}.md", &repo, &pkgname));
 
     check_build_dependency(&repo, &pkg_md_path)?;
     check_run_dependency(&pkg_md_path)?;
-    download(&pkgname, &pkg_md_path)?;
-
-    let src_dir = PathBuf::from("/pkg/src").join(&pkgname);
-    patch(&pkgname, &src_dir, &pkg_md_path)?;
-    build(&repo, &pkgname, &src_dir, &pkg_md_path)?;
-    link(&repo, &pkgname).expect("Failed link package");
-    hook(&repo, &pkgname);
-    config(&src_dir, &pkg_md_path)?;
-
-    let src_remove_flag = match std::env::var("src_remove") {
-        Ok(value) => value != "false",
-        Err(_) => true,
-    };
-
-    if src_remove_flag {
-        if let Err(e) = fs::remove_dir_all(&src_dir) {
-            eprintln!("Failed to remove source directory: {}", e);
-            return Err(false);
-        }
-    }
+    download(&repo, &pkgname)?;
+    patch(&repo, &pkgname)?;
+    build(&repo, &pkgname)?;
+    config(&repo, &pkgname)?;
 
     println!("Package {} installed successfully from repo {}", pkgname, repo);
     Ok(())
 }
 
-
-pub fn install_all(pkgname: &String) {
-    let repos = match parser::get_repo_list() {
-        Ok(repos) => repos,
-        Err(e) => {
-            eprintln!("Failed to get repository list: {}", e);
-            return;
-        }
-    };
-
-    let mut success = false;
-    for repo in repos {
-        println!("Trying to install {} from repo {}...", pkgname, repo);
-
-        match install(&repo, pkgname) {
-            Ok(()) => {
-                success = true;
-                break;
-            }
-            Err(no_repo_package) => {
-                if no_repo_package {
-                    continue;
-                } else {
-                    process::exit(1)
-                }
-            }
-        }
-    }
-    if !success {
-        eprintln!("Package {} not found in any available repository", pkgname);
-    }
-}
-
-
-fn upload_from_repo(repo: &String, pkgname: &String, pkg_md_path: &Path) -> Result<(), bool> {
-    match parser::get_repo_addr(repo) {
-        Ok(repo_addr) => {
-            let rsync_command = format!(
-                "rsync --include='{}.md' --exclude='*' {} {}",
-                pkgname,
-                repo_addr,
-                pkg_md_path.to_str().unwrap()
-            );
-            let rsync_output = Command::new("sh")
-                .arg("-c")
-                .arg(rsync_command)
-                .output()
-                .expect("Failed to execute rsync");
-
-            if !rsync_output.status.success()  {
-                eprintln!("broken repo: {}", repo);
-                return Err(false);
-            }
-            if !pkg_md_path.exists()  {
-                eprintln!("not found {} in {} repo", pkgname, repo);
-                return Err(true);
-            }
-
-            Ok(())
-        }
-        Err(e) => {
-            eprintln!("Repository {} not found: {}", repo, e);
-            return Err(true);
-        }
-    }
-}
-
 fn check_build_dependency(repo: &String, pkg_md_path: &Path) -> Result<(), bool> {
     let deps = match parser::get_build_deps(&pkg_md_path) {
         Ok(deps) => deps,
@@ -126,7 +30,7 @@ fn check_build_dependency(repo: &String, pkg_md_path: &Path) -> Result<(), bool>
 
     for dependency in deps.lines() {
         if !dependency.trim().is_empty() {
-            if !Path::new("/pkg").join(repo).join(dependency).exists() {
+            if !super::get_aeropkg_base().join(repo).join(dependency).exists() {
                 match install(repo, &dependency.to_string()) {
                     Ok(()) => {}
                     Err(_) => {process::exit(1) }
@@ -144,290 +48,23 @@ fn check_run_dependency(pkg_md_path: &Path) -> Result<(), bool> {
         Err(_) => { return Ok(()) }
     };
 
-    let repo_list = match parser::get_repo_list() {
-        Ok(repos) => repos,
-        Err(e) => {
-            eprintln!("Failed to get repository list: {}", e);
-            return Err(false)
-        }
-    };
-    for dependency in deps.split_whitespace() {
+    let repo_list = parser::repoinfo::get_repo_list();
+
+    for pkgname in deps.split_whitespace() {
         let mut found = false;
 
         for repo_name in &repo_list {
-            let path = format!("/pkg/{}/{}/", repo_name, dependency);
-            if Path::new(&path).exists() {
+            let path = super::get_aeropkg_base().join(repo_name).join(pkgname);
+            if path.exists() {
                 found = true;
                 break;
             }
         }
 
         if !found {
-            install_all(&dependency.to_string());
+            install(&pkginfo::get_priority_repo(pkgname.to_string()), &pkgname.to_string());
         }
     }
 
     Ok(())
 }
-
-
-fn download(pkgname: &String, pkg_md_path: &Path) -> Result<(), bool> {
-    let url = match parser::get_url(pkg_md_path) {
-        Ok(url) => url,
-        Err(e) => {
-            eprintln!("Failed to parse URL: {}", e);
-            return Err(false);
-        }
-    };
-
-    let src = PathBuf::from("/pkg/src").join(pkgname);
-    if src.exists() {
-        let src_url = fs::read_to_string(src.join("aeropkg.download-url")).unwrap_or("".to_string());
-        if url == src_url {
-            return Ok(())
-        } else {
-            println!("url:\n{}\nend url", url);
-            println!("src url:\n{}\nend src url", src_url);
-            fs::remove_dir_all(&src).unwrap();
-        }
-    }
-
-    if let Err(e) = fs::create_dir_all(&src) {
-        eprintln!("Failed to create directory {}: {}", &src.display(), e);
-        return Err(false);
-    }
-
-    if !url.ends_with(".git") {
-        let compress_flag = if url.ends_with(".bz2") {
-            "--bzip2"
-        } else if url.ends_with(".xz") {
-            "--xz"
-        } else if url.ends_with(".lz") {
-            "--lzip"
-        } else if url.ends_with(".lzma") {
-            "--lzma"
-        } else if url.ends_with(".lzo") {
-            "--lzop"
-        } else if url.ends_with(".zst") {
-            "--zstd"
-        } else if url.ends_with(".gz") {
-            "--gzip"
-        } else {
-            eprintln!("Unsupported compression format for URL: {}", url);
-            return Err(false);
-        };
-
-        let wget_output = Command::new("wget")
-            .arg("-O-")
-            .arg("-q")
-            .arg("--show-progress")
-            .arg(&url)
-            .stdout(Stdio::piped())
-            .spawn();
-
-        let tar_input = match wget_output {
-            Ok(child) => child.stdout.unwrap(),
-            Err(e) => {
-                eprintln!("Failed to execute wget: {}", e);
-                return Err(false);
-            }
-        };
-
-        let tar_status = Command::new("tar")
-            .arg("-x")
-            .arg(compress_flag)
-            .arg("-C")
-            .arg(&src)
-            .stdin(tar_input)
-            .status();
-
-        if tar_status.is_err() || !tar_status.unwrap().success() {
-            eprintln!("Failed to extract archive from URL: {}", url);
-            return Err(false);
-        }
-
-        let entries = fs::read_dir(&src).unwrap();
-        let dirs: Vec<_> = entries
-            .filter_map(|entry| entry.ok())
-            .filter(|entry| entry.file_type().map_or(false, |ft| ft.is_dir()))
-            .collect();
-
-        if dirs.len() == 1 {
-            let single_dir = dirs[0].path();
-
-            for entry in fs::read_dir(&single_dir).unwrap() {
-                let entry = entry.unwrap();
-                let dest = src.join(entry.file_name());
-                fs::rename(entry.path(), dest).unwrap();
-            }
-
-            fs::remove_dir(single_dir).unwrap();
-        }
-    } else {
-        let git_status = Command::new("git")
-            .arg("clone")
-            .arg(&url)
-            .arg(&src)
-            .status();
-
-        if git_status.is_err() || !git_status.unwrap().success() {
-            eprintln!("Failed to clone git repository from URL: {}", url);
-            return Err(false);
-        }
-    }
-
-    fs::write(src.join("aeropkg.download-url"), &url).unwrap();
-
-    Ok(())
-}
-
-
-fn patch(
-    pkgname: &String,
-    src_dir: &Path,
-    pkg_md_path: &Path,
-) -> Result<(), bool> {
-    let patch_script = parser::get_patch_script(pkg_md_path).unwrap_or("".to_string());
-
-    if src_dir.join("aeropkg.applied-patch").exists() {
-        let src_patch = fs::read_to_string(src_dir.join("aeropkg.applied-patch")).unwrap_or("".to_string());
-        if patch_script == src_patch {
-            return Ok(())
-        } else {
-            println!("patch:\n{}\nend patch", patch_script);
-            println!("src patch:\n{}\nend src patch", src_patch);
-            fs::remove_dir_all(src_dir).unwrap();
-            download(&pkgname, &pkg_md_path)?;
-        }
-    }
-
-    if patch_script == "" { return Ok(()) }
-    let output = Command::new("zsh")
-        .arg("-c")
-        .arg(&patch_script)
-        .current_dir(src_dir)
-        .output();
-
-    if let Err(e) = output {
-        eprintln!("Failed to execute patch script: {}", e);
-        return Err(false);
-    }
-
-    let output = output.unwrap();
-    if !output.status.success() {
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        eprintln!("Script failed with error: {}", stderr);
-        return Err(false);
-    }
-
-    fs::write(src_dir.join("aeropkg.applied-patch"), &patch_script).unwrap();
-
-    Ok(())
-}
-
-
-
-fn build(
-    repo: &String,
-    pkgname: &String,
-    src_dir: &Path,
-    pkg_md_path: &Path,
-) -> Result<(), bool> {
-    let build_script = match parser::get_build_script(pkg_md_path) {
-        Ok(script) => script,
-        Err(error) => {
-            eprintln!("Failed to parse build script: {}", error);
-            return Err(false);
-        }
-    };
-
-    if src_dir.join("aeropkg.applied-build").exists() {
-        let src_build = fs::read_to_string(src_dir.join("aeropkg.applied-build")).unwrap_or("".to_string());
-        if build_script == src_build {
-            return Ok(())
-        } else {
-            println!("build:\n{}\nend build", build_script);
-            println!("src build:\n{}\nend src build", src_build);
-            fs::remove_dir_all(src_dir).unwrap();
-            download(&pkgname, &pkg_md_path)?;
-            patch(&pkgname, &src_dir, &pkg_md_path)?;
-        }
-    }
-
-    let output = Command::new("zsh")
-        .arg("-c")
-        .arg(&build_script)
-        .current_dir(src_dir)
-        .output();
-
-    if let Err(e) = output {
-        eprintln!("Failed to execute build script: {}", e);
-        return Err(false);
-    }
-
-    let output = output.unwrap();
-    if !output.status.success() {
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        eprintln!("Script failed with error:\n{}", stderr);
-        std::process::exit(1);
-    }
-
-    let dest_dir = PathBuf::from("/pkg").join(repo).join(pkgname);
-    if let Err(e) = fs::create_dir_all(&dest_dir) {
-        eprintln!("Failed to create destination directory: {}", e);
-        return Err(false);
-    }
-
-    let dest_path = dest_dir.join("build-script.md");
-    fs::remove_file(&dest_path).expect("");
-    if let Err(e) = fs::hard_link(pkg_md_path, &dest_path) {
-        eprintln!("Failed to copy build script to destination: {}", e);
-        return Err(false);
-    }
-
-    fs::write(src_dir.join("aeropkg.build-script"), &build_script).unwrap();
-
-    Ok(())
-}
-
-
-fn config(
-    src_dir: &Path,
-    pkg_md_path: &Path
-) -> Result<(), bool> {
-    let config_script = match parser::get_config_script(pkg_md_path) {
-        Ok(script) => script,
-        Err(_) => { return Ok(()) }
-    };
-
-    let output = Command::new("zsh")
-        .arg("-c")
-        .arg(&config_script)
-        .current_dir(src_dir)
-        .output();
-
-    if let Err(e) = output {
-        eprintln!("Failed to execute config script: {}", e);
-        return Err(false);
-    }
-
-    let output = output.unwrap();
-    if !output.status.success() {
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        eprintln!("Script failed with error: {}", stderr);
-        return Err(false);
-    }
-
-    Ok(())
-}
-
-fn hook(repo: &String, pkgname: &String) {
-    let pkg_dir = PathBuf::from("/pkg").join(&repo).join(&pkgname);
-    let lib_dir = &pkg_dir.join("lib");
-    let lib64_dir = &pkg_dir.join("lib64");
-    let lib32_dir = &pkg_dir.join("lib32");
-    crate::utils::mv::mv(&lib64_dir, &lib_dir).unwrap();
-    crate::utils::mv::mv(&lib32_dir, &lib_dir).unwrap();
-    fs::remove_dir_all(&lib64_dir).unwrap();
-    fs::remove_dir_all(&lib32_dir).unwrap();
-}