feat(build): build_hash

Prevents constant rebuilding

Author: Taxrosdev

src/build/hash.rs

@@ -0,0 +1,58 @@
+use anyhow::{Context, Result};
+use std::fs;
+use std::io::Write;
+use std::path::Path;
+
+use super::BuildManifest;
+use crate::repo::{get_package, read_manifest};
+
+/// Get the `build_hash` of a `build_manifest`
+/// Requires all dependencies to be built and in the Repository beforehand.
+///
+/// # Errors
+///
+/// - Scripts do not exist
+/// - Invalid build manifest
+pub fn calc_build_hash(build_manifest_path: &Path, repo_path: &Path) -> Result<String> {
+    let build_manifest_path = build_manifest_path.canonicalize().with_context(
+        || "could not canoncicalize build manifest path. Does the build manifest exist?",
+    )?;
+    let build_manifest_raw = fs::read_to_string(build_manifest_path)?;
+    let build_manifest: BuildManifest = serde_yaml::from_str(&build_manifest_raw)?;
+
+    let repo_manifest = read_manifest(repo_path)?;
+
+    let mut hash = blake3::Hasher::new();
+
+    hash.write_all(build_manifest_raw.as_bytes())?;
+
+    // Hash the `includes`
+    if let Some(deps) = build_manifest.include {
+        for dep in deps {
+            let package = get_package(&repo_manifest, &dep)?;
+            hash.write_all(package.build_hash.as_bytes())?;
+        }
+    }
+
+    // Hash the `sdks`
+    if let Some(deps) = build_manifest.sdks {
+        for dep in deps {
+            let package = get_package(&repo_manifest, &dep)?;
+            hash.write_all(package.build_hash.as_bytes())?;
+        }
+    }
+
+    // Hash the `build_script`
+    if let Some(build_script) = build_manifest.build_script {
+        let script = fs::read_to_string(build_script)?;
+        hash.write_all(script.as_bytes())?;
+    }
+
+    // Hash the `post_script`
+    if let Some(post_script) = build_manifest.post_script {
+        let script = fs::read_to_string(post_script)?;
+        hash.write_all(script.as_bytes())?;
+    }
+
+    Ok(hash.finalize().to_string())
+}

src/build/mod.rs

@@ -1,4 +1,5 @@
 pub mod bundle;
+pub mod hash;
 mod sources;
 
 use anyhow::{Context, Result, bail};
@@ -11,10 +12,11 @@ use std::{
 use temp_dir::TempDir;
 
 use crate::{
-    build::sources::get_sources,
     chunks::{load_tree, save_tree},
     repo::{self, Metadata, PackageManifest, get_package, insert_package, read_manifest},
 };
+use hash::calc_build_hash;
+use sources::get_sources;
 
 #[derive(serde::Deserialize, serde::Serialize, Clone, Hash)]
 struct BuildManifest {
@@ -71,6 +73,38 @@ pub async fn build(
     repo_path: &Path,
     config_path: Option<&Path>,
     chunk_store_path: &Path,
+) -> Result<PackageManifest> {
+    let repo = read_manifest(repo_path)?;
+    let build_manifest: BuildManifest =
+        serde_yaml::from_str(&fs::read_to_string(build_manifest_path)?)?;
+
+    if let Ok(package) = get_package(&repo, &build_manifest.id) {
+        let next_build_hash = calc_build_hash(build_manifest_path, repo_path)?;
+        if package.build_hash == next_build_hash {
+            return Ok(package);
+        }
+    }
+
+    force_build(
+        build_manifest_path,
+        repo_path,
+        config_path,
+        chunk_store_path,
+    )
+    .await
+}
+
+/// Builds and inserts a package into a Repository from a `build_manifest`
+///
+/// # Errors
+///
+/// - Filesystem (Out of Space, Permissions)
+/// - Build Script Failure
+pub async fn force_build(
+    build_manifest_path: &Path,
+    repo_path: &Path,
+    config_path: Option<&Path>,
+    chunk_store_path: &Path,
 ) -> Result<PackageManifest> {
     let build_dir = TempDir::new()?;
     let build_manifest_path = &build_manifest_path.canonicalize()?;
@@ -114,14 +148,13 @@ pub async fn build(
     }
 
     if let Some(script) = build_manifest.build_script {
-        run_script(build_dir.path(), build_manifest_path, &script)
-            .with_context(|| "build_script")?;
+        run_script(build_dir.path(), search_path, &script).with_context(|| "build_script")?;
     }
 
     let out_dir = build_dir.path().join(&build_manifest.directory);
 
     if let Some(script) = build_manifest.post_script {
-        run_script(&out_dir, build_manifest_path, &script).with_context(|| "post_script")?;
+        run_script(&out_dir, search_path, &script).with_context(|| "post_script")?;
     }
 
     let mut included_chunks = Vec::new();
@@ -148,8 +181,7 @@ pub async fn build(
         metadata: build_manifest.metadata,
         chunks: included_chunks,
         env: None,
-        // TODO!
-        build_hash: "TODO".to_string(),
+        build_hash: calc_build_hash(build_manifest_path, repo_path)?,
     };
 
     if !envs.is_empty() {