feat: cached builds & meta

Author: radstevee

Cargo.lock

@@ -22,3 +22,5 @@ bsdiff = "0.2.0"
 zip = "2.2.0"
 bzip2 = { version = "0.4", features = [] }
 toml = "0.8.19"
+sha1 = "0.10.6"
+hex = "0.4.3"

Cargo.toml

@@ -25,4 +25,17 @@ pub fn serial_snake(_attr: TokenStream, item: TokenStream) -> TokenStream {
     };
 
     TokenStream::from(expanded)
-}
+}
+
+#[proc_macro_attribute]
+pub fn serial_pascal(_attr: TokenStream, item: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(item as DeriveInput);
+
+    let expanded = quote! {
+        #[derive(serde::Serialize, serde::Deserialize, Clone, Debug, PartialEq)]
+        #[serde(rename_all = "PascalCase")]
+        #input
+    };
+
+    TokenStream::from(expanded)
+}

proc_macros/src/lib.rs

@@ -2,6 +2,8 @@ use std::{fs, io, path::{Path, PathBuf}};
 
 use proc_macros::serial_snake;
 
+use crate::version::schema::spigot::SpigotVersionRefs;
+
 #[serial_snake]
 #[derive(Default)]
 pub struct Config {
@@ -29,3 +31,25 @@ pub fn read_config<P: AsRef<Path>>(path: P) -> io::Result<Config> {
         |e| io::Error::new(io::ErrorKind::Other, e.to_string())
     )
 }
+
+#[serial_snake]
+pub struct PatchedVersionMeta {
+    pub patch_file: String,
+    pub commit_hashes: SpigotVersionRefs,
+    pub patch_hash: String,
+    pub patched_jar_hash: String
+}
+
+impl PatchedVersionMeta {
+    pub fn read<P: AsRef<Path>>(path: P) -> io::Result<Self> {
+        let content = fs::read_to_string(path)?;
+
+        serde_json::from_str(&content).map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))
+    }
+
+    pub fn write<P: AsRef<Path>>(&self, path: P) -> io::Result<()> {
+        let json = serde_json::to_string_pretty(self)?;
+
+        fs::write(path, json)
+    }
+}

src/config.rs

@@ -1,13 +1,16 @@
 use bin_patch_gen::build_tools::{
     download_buildtools, find_file, run_buildtools, VANILLA_JAR_REGEX,
 };
-use bin_patch_gen::config::Config;
+use bin_patch_gen::config::{Config, PatchedVersionMeta};
 use bin_patch_gen::jar::extract_jar;
 use bin_patch_gen::util::dir::create_temp_dir;
-use bin_patch_gen::util::TimeFormatter;
-use bin_patch_gen::version::fetch_versions;
-use bin_patch_gen::{config, jar, prepare_extraction_path, write_patch, MinecraftVersion, JAR_VERSIONS_PATH};
+use bin_patch_gen::util::{sha1, TimeFormatter};
+use bin_patch_gen::version::{fetch_spigot_version_meta, fetch_versions};
+use bin_patch_gen::{
+    config, jar, prepare_extraction_path, write_patch, MinecraftVersion, JAR_VERSIONS_PATH,
+};
 use regex::Regex;
+use std::env::current_dir;
 use std::fs;
 use std::path::{Path, PathBuf};
 use tracing::info;
@@ -44,6 +47,16 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     let vanilla_jar_regex = Regex::new(VANILLA_JAR_REGEX)?;
 
+    let run_dir = if current_dir()?.ends_with("run") {
+        current_dir()?
+    } else {
+        current_dir()?.join("run")
+    };
+
+    if !run_dir.exists() {
+        fs::create_dir_all(&run_dir)?;
+    }
+
     for version in versions {
         info!("Building Spigot for version {}...", version);
         let version_path = temp_dir.join(Path::new(&*version));
@@ -52,6 +65,17 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
         let mc_version = MinecraftVersion::of(version.clone());
         let java_home = config.java_home(mc_version.get_java_version());
+        let remote_meta = fetch_spigot_version_meta(version.clone()).await?;
+
+        let version_file = &run_dir.join(format!("{version}.json"));
+        if version_file.exists() {
+            let patched_meta = PatchedVersionMeta::read(version_file)?;
+
+            if remote_meta.refs == patched_meta.commit_hashes {
+                info!("Already built version {version}, skipping");
+                continue;
+            }
+        }
 
         let result = run_buildtools(
             java_home,
@@ -115,9 +139,21 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             result
         };
 
+        let patch_file = &run_dir.join(format!("{version}.patch"));
+
         info!("Generating diff...");
-        write_patch(vanilla_jar, spigot_jar, "bsdiff.patch")?;
+        write_patch(&vanilla_jar, &spigot_jar, patch_file)?;
         info!("Diff generated!");
+
+        let patched_meta = PatchedVersionMeta {
+            patch_file: patch_file.to_str().unwrap().to_string(),
+            commit_hashes: remote_meta.refs,
+            patch_hash: sha1(patch_file)?,
+            patched_jar_hash: sha1(spigot_jar)?,
+        };
+
+        patched_meta.write(version_file)?;
+        info!("Wrote version metadata file!");
     }
 
     Ok(())

src/main.rs

@@ -1,6 +1,11 @@
 //! Module containing utilities.
 
+use std::fs::File;
+use std::io::{self, Read};
+use std::path::Path;
+
 use chrono::Local;
+use sha1::{Digest, Sha1};
 use tracing_subscriber::fmt::format::Writer;
 use tracing_subscriber::fmt::time::FormatTime;
 
@@ -12,4 +17,15 @@ impl FormatTime for TimeFormatter {
         let date = Local::now();
         write!(w, "{}", date.format("%H:%M:%S"))
     }
-}
+}
+
+pub fn sha1<P: AsRef<Path>>(path: P) -> io::Result<String> {
+    let mut bytes = vec![];
+    let mut file = File::open(path)?;
+    file.read_exact(&mut bytes)?;
+
+    let mut hasher = Sha1::new();
+    hasher.update(bytes);
+
+    Ok(hex::encode(hasher.finalize()))
+}

src/util/mod.rs

@@ -1,10 +1,11 @@
 //! Fetches Minecraft versions from SpigotMC.
 
-mod schema;
+pub mod schema;
 
-use crate::version::schema::{Version, VersionMeta, VersionsResponse};
+use crate::version::schema::piston::{PistonVersion, PistonVersionMeta, PistonVersionsResponse};
 use crate::{download_url, fetch_url, get_url, Reqwsult};
 use regex::Regex;
+use schema::spigot::SpigotVersionMeta;
 use scraper::{Html, Selector};
 use std::path::Path;
 use tracing::warn;
@@ -55,14 +56,14 @@ pub async fn fetch_versions() -> Vec<String> {
     }))
 }
 
-pub async fn fetch_piston_meta() -> Reqwsult<VersionsResponse> {
+pub async fn fetch_piston_meta() -> Reqwsult<PistonVersionsResponse> {
     let text = get_url(PISTON_META_URL).await?;
     Ok(serde_json::from_str(&text).unwrap_or_else(|err| {
         panic!("failed deserializing piston meta: {err:#?}")
     }))
 }
 
-pub async fn fetch_version_meta(versions: VersionsResponse, version: String) -> Reqwsult<VersionMeta> {
+pub async fn fetch_piston_version_meta(versions: PistonVersionsResponse, version: String) -> Reqwsult<PistonVersionMeta> {
     let version = versions
         .versions
         .iter()
@@ -84,6 +85,16 @@ pub async fn fetch_version_meta(versions: VersionsResponse, version: String) ->
     )
 }
 
-pub async fn download_version<P: AsRef<Path>>(version: Version, path: P) -> Reqwsult<()> {
+pub async fn download_version<P: AsRef<Path>>(version: PistonVersion, path: P) -> Reqwsult<()> {
     download_url(version.url, path).await
 }
+
+pub async fn fetch_spigot_version_meta(version: String) -> Reqwsult<SpigotVersionMeta> {
+    let url = format!("{VERSIONS_URL}/{version}.json");
+
+    Ok(
+        serde_json::from_str(&(get_url(url).await?)).unwrap_or_else(|err| {
+            panic!("failed deserializing version meta: {err:#?}")
+        })
+    )
+}