feat: Sources in build manifest

Author: Taxrosdev

Cargo.toml

@@ -27,10 +27,10 @@ serde = { version = "1.0.219", features = ["derive"] }
 serde_yaml = "0.9.34"
 tar = "0.4.44"
 tokio = { version = "1.47.1", optional = true, features = ["rt"] }
+temp-dir = "0.1.16"
 walkdir = "2.5.0"
 
 [dev-dependencies]
-temp-dir = "0.1.16"
 httpmock = "0.7.0"
 
 [features]

src/build/mod.rs

@@ -1,11 +1,15 @@
+mod sources;
+
 use anyhow::{Context, Result, bail};
 use std::{
     fs,
     path::{Path, PathBuf},
     process::Command,
 };
+use temp_dir::TempDir;
 
 use crate::{
+    build::sources::get_sources,
     chunks::save_tree,
     repo::{self, Metadata, PackageManifest, insert_package, remove_package},
 };
@@ -28,6 +32,18 @@ struct BuildManifest {
     edition: String,
     /// Script to be run before packaging
     build_script: Option<PathBuf>,
+
+    sources: Option<Vec<Source>>,
+}
+
+#[derive(serde::Deserialize, serde::Serialize, Clone)]
+struct Source {
+    /// Should either be git, tar or local
+    kind: String,
+    /// URL to the source.
+    url: String,
+    /// Path to extract.
+    path: Option<String>,
 }
 
 /// Builds and inserts a package into a Repository from a `build_manifest`
@@ -37,6 +53,7 @@ struct BuildManifest {
 /// - Filesystem (Out of Space, Permissions)
 /// - Build Script Failure
 pub fn build(build_manifest_path: &Path, repo_path: &Path) -> Result<PackageManifest> {
+    let build_dir = TempDir::new()?;
     let build_manifest_path = &build_manifest_path.canonicalize()?;
 
     let build_manifest: BuildManifest =
@@ -49,11 +66,15 @@ pub fn build(build_manifest_path: &Path, repo_path: &Path) -> Result<PackageMani
         .parent()
         .unwrap_or_else(|| Path::new("/"));
 
+    if let Some(sources) = build_manifest.sources {
+        get_sources(build_dir.path(), build_manifest_parent, &sources)?;
+    }
+
     if let Some(script) = build_manifest.build_script {
         let result = Command::new("sh")
             .arg("-c")
             .arg(build_manifest_parent.join(script))
-            .current_dir(build_manifest_parent)
+            .current_dir(build_dir.path())
             .status()?;
 
         if !result.success() {
@@ -62,7 +83,7 @@ pub fn build(build_manifest_path: &Path, repo_path: &Path) -> Result<PackageMani
     }
 
     let chunks = save_tree(
-        &build_manifest_parent.join(build_manifest.directory),
+        &build_dir.path().join(&build_manifest.directory),
         &repo_path.join("chunks"),
         repo_manifest.hash_kind,
     )?;

src/build/sources.rs

@@ -0,0 +1,65 @@
+use crate::build::Source;
+use anyhow::Context;
+use anyhow::Result;
+use std::fs;
+use std::path::Path;
+use std::process::Command;
+
+pub fn get_sources(path: &Path, source_path: &Path, sources: &[Source]) -> Result<()> {
+    for source in sources {
+        match source.kind.as_str() {
+            "git" => pull_git(&source.url, path).with_context(|| {
+                format!("Failed to pull git repo from {}", source_path.display())
+            })?,
+            "tar" => todo!("Tar is not implemented"),
+            "local" => pull_local(source_path, path).with_context(|| {
+                format!("Failed to copy local source from {}", source_path.display())
+            })?,
+            _ => {
+                unimplemented!("No handler is implemented for source.kind.{}", source.kind)
+            }
+        }
+    }
+
+    Ok(())
+}
+
+/// Just copy files from a local path into the target.
+/// If target already exists, nuke it first.
+fn pull_local(source_path: &Path, target_path: &Path) -> Result<()> {
+    fs::create_dir_all(target_path)
+        .with_context(|| format!("Failed to create target dir {}", target_path.display()))?;
+
+    // Copy recursively
+    for entry in walkdir::WalkDir::new(source_path) {
+        let entry = entry?;
+        let rel_path = entry.path().strip_prefix(source_path)?;
+        let dest = target_path.join(rel_path);
+
+        if entry.file_type().is_dir() {
+            fs::create_dir_all(&dest)?;
+        } else {
+            fs::copy(entry.path(), &dest)?;
+        }
+    }
+
+    Ok(())
+}
+
+/// Clone or pull a git repo depending on whether it already exists.
+fn pull_git(source_path: &str, target_path: &Path) -> Result<()> {
+    // Clone fresh
+    let status = Command::new("git")
+        .arg("clone")
+        .arg(source_path)
+        .arg(target_path)
+        .status()
+        .with_context(|| "Failed to run git clone")?;
+    if !status.success() {
+        anyhow::bail!("git clone failed");
+    }
+
+    Ok(())
+}
+
+// fn pull_tar(source_path: &Path, target_path: &Path) -> Result<()> {}