download mojang static archived versions.

Signed-off-by: Rachel Powers <[email protected]>

Author: Ryex

libmcmeta/Cargo.toml

@@ -9,6 +9,7 @@ edition = "2021"
 chrono = { version = "0.4.24", features = ["serde"] }
 custom_error = "1.9.2"
 lazy_static = "1.4.0"
+merge = "0.1.0"
 serde = { version = "1.0.160", features = ["derive"] }
 serde_json = "1.0.95"
 serde_valid = "0.15.0"

libmcmeta/src/models/forge.rs

@@ -1,3 +1,5 @@
+use crate::models::merge::{self, Merge};
+
 use serde::{Deserialize, Serialize};
 use serde_valid::Validate;
 use serde_with::skip_serializing_none;
@@ -302,6 +304,71 @@ pub enum ForgeInstallerManifestVersion {
     Modern(Box<ForgeInstallerManifest>),
 }
 
+#[derive(Deserialize, Serialize, Clone, Debug, Validate, Merge)]
+pub struct ForgeFile {
+    #[merge(strategy = merge::overwrite)]
+    pub classifier: String,
+    #[merge(strategy = merge::overwrite)]
+    pub hash: String,
+    #[merge(strategy = merge::overwrite)]
+    pub extension: String,
+}
+
+impl ForgeFile {
+    fn filename(&self, long_version: &str) -> String {
+        format!(
+            "{}-{}-{}.{}",
+            "forge", long_version, self.classifier, self.extension
+        )
+    }
+
+    fn url(&self, long_version: &str) -> String {
+        format!(
+            "https://maven.minecraftforge.net/net/minecraftforge/forge/{}/{}",
+            long_version,
+            self.filename(long_version),
+        )
+    }
+}
+
+#[skip_serializing_none]
+#[derive(Deserialize, Serialize, Clone, Debug, Validate, Merge)]
+pub struct ForgeEntry {
+    #[serde(rename = "longversion")]
+    #[merge(strategy = merge::overwrite)]
+    pub long_version: String,
+    #[serde(rename = "mcversion")]
+    #[merge(strategy = merge::overwrite)]
+    pub mc_version: String,
+    #[merge(strategy = merge::overwrite)]
+    pub version: String,
+    #[merge(strategy = merge::overwrite)]
+    pub build: i64,
+    pub branch: Option<String>,
+    pub latest: Option<bool>,
+    pub recommended: Option<bool>,
+    #[merge(strategy = merge::hashmap::recurse_some)]
+    pub files: Option<HashMap<String, ForgeFile>>,
+}
+
+#[skip_serializing_none]
+#[derive(Deserialize, Serialize, Clone, Debug, Validate, Merge)]
+pub struct ForgeMCVersionInfo {
+    pub latest: Option<String>,
+    pub recommended: Option<String>,
+    #[merge(strategy = merge::vec::append)]
+    pub versions: Vec<String>,
+}
+
+#[derive(Deserialize, Serialize, Clone, Debug, Validate, Merge)]
+pub struct DerivedForgeIndex {
+    #[merge(strategy = merge::hashmap::recurse)]
+    pub versions: HashMap<String, ForgeEntry>,
+    #[serde(rename = "by_mcversion")]
+    #[merge(strategy = merge::hashmap::recurse)]
+    pub by_mc_version: HashMap<String, ForgeMCVersionInfo>,
+}
+
 #[cfg(test)]
 mod tests {
     #[test]

libmcmeta/src/models/mod.rs

@@ -184,3 +184,81 @@ impl<'de> Deserialize<'de> for GradleSpecifier {
         s.parse().map_err(serde::de::Error::custom)
     }
 }
+
+pub mod validation {
+    pub fn is_some<T>(obj: Option<T>) -> Result<(), serde_valid::validation::Error> {
+        if !obj.is_some() {
+            return Err(serde_valid::validation::Error::Custom(
+                "Must be some".to_string(),
+            ));
+        }
+        Ok(())
+    }
+}
+
+pub mod merge {
+    pub use merge::Merge;
+    pub use merge::{bool, num, ord, vec};
+
+    /// generic overwrite stratagy
+    pub fn overwrite<T>(left: &mut T, right: T) {
+        *left = right
+    }
+
+    /// Merge strategies for `Option`
+    pub mod option {
+        /// Overwrite `left` with `right` only if `left` is `None`.
+        pub fn overwrite_none<T>(left: &mut Option<T>, right: Option<T>) {
+            if left.is_none() {
+                *left = right;
+            }
+        }
+
+        /// If both `left` and `right` are `Some`, recursively merge the two.
+        /// Otherwise, fall back to `overwrite_none`.
+        pub fn recurse<T: merge::Merge>(left: &mut Option<T>, right: Option<T>) {
+            if let Some(new) = right {
+                if let Some(original) = left {
+                    original.merge(new);
+                } else {
+                    *left = Some(new);
+                }
+            }
+        }
+    }
+
+    /// Merge strategies for `HashMap`
+    pub mod hashmap {
+        use std::collections::HashMap;
+        use std::hash::Hash;
+
+        pub fn recurse<K: Eq + Hash, V: merge::Merge>(
+            left: &mut HashMap<K, V>,
+            right: HashMap<K, V>,
+        ) {
+            use std::collections::hash_map::Entry;
+
+            for (k, v) in right {
+                match left.entry(k) {
+                    Entry::Occupied(mut existing) => existing.get_mut().merge(v),
+                    Entry::Vacant(empty) => {
+                        empty.insert(v);
+                    }
+                }
+            }
+        }
+
+        pub fn recurse_some<K: Eq + Hash, V: merge::Merge>(
+            left: &mut Option<HashMap<K, V>>,
+            right: Option<HashMap<K, V>>,
+        ) {
+            if let Some(new) = right {
+                if let Some(original) = left {
+                    recurse(original, new);
+                } else {
+                    *left = Some(new);
+                }
+            }
+        }
+    }
+}

libmcmeta/src/models/mojang.rs

@@ -268,7 +268,7 @@ pub struct MinecraftVersion {
     pub asset_index: AssetIndex,
     pub assets: String,
     pub compliance_level: Option<i32>,
-    pub downloads: VersionDownloads,
+    pub downloads: Option<VersionDownloads>,
     pub id: String,
     pub java_version: Option<JavaVersion>,
     #[validate]
@@ -285,6 +285,33 @@ pub struct MinecraftVersion {
     pub release_type: String,
 }
 
+#[derive(Deserialize, Serialize, Debug, Clone, Validate)]
+pub struct ExperimentEntry {
+    pub id: String,
+    pub url: String,
+    pub wiki: Option<String>,
+}
+
+#[derive(Deserialize, Serialize, Debug, Clone, Validate)]
+pub struct ExperimentIndex {
+    pub experiments: Vec<ExperimentEntry>,
+}
+
+#[derive(Deserialize, Serialize, Debug, Clone, Validate)]
+pub struct OldSnapshotEntry {
+    pub id: String,
+    pub url: String,
+    pub wiki: Option<String>,
+    pub jar: String,
+    pub sha1: String,
+    pub size: i32,
+}
+
+#[derive(Deserialize, Serialize, Debug, Clone, Validate)]
+pub struct OldSnapshotIndex {
+    pub old_snapshots: Vec<OldSnapshotEntry>,
+}
+
 #[cfg(test)]
 mod tests {
 

mcmeta/.env.example

@@ -1,13 +1,23 @@
 RUST_LOG=INFO
 
+# all the below varabile are set be default and do not all need to be provided
+# you only need to set the ones you want to change
+
 MCMETA__BIND_ADDRESS=127.0.0.1:9988
 
 MCMETA__STORAGE_FORMAT__TYPE=json
-MCMETA__STORAGE_FORMAT__META_DIRECTORY=../meta
+MCMETA__STORAGE_FORMAT__META_DIRECTORY=./meta
+MCMETA__STORAGE_FORMAT__GENERATED_DIRECTORY=./generated
 
 MCMETA__METADATA__MAX_PARALLEL_FETCH_CONNECTIONS=8
+MCMETA__METADATA__STATIC_DIRECTORY=./static
 
 MCMETA__DEBUG_LOG__ENABLE=true
 MCMETA__DEBUG_LOG__PATH=./logs
 MCMETA__DEBUG_LOG__PREFIX=mcmeta.log
-MCMETA__DEBUG_LOG__LEVEL=DEBUG
+MCMETA__DEBUG_LOG__LEVEL=DEBUG
+
+MCMETA_MOJANG__MANIFEST_URL=https://piston-meta.mojang.com/mc/game/version_manifest_v2.json
+
+MCMETA_FORGE__MAVEN_URL=https://files.minecraftforge.net/net/minecraftforge/forge/maven-metadata.json
+MCMETA_FORGE__PROMOTIONS_URL=https://files.minecraftforge.net/net/minecraftforge/forge/promotions_slim.json

mcmeta/Cargo.toml

@@ -21,8 +21,10 @@ serde = { version = "1.0.160", features = ["derive"] }
 serde_json = "1.0.95"
 serde_valid = "0.15.0"
 serde_with = "2.3.2"
+tempdir = "0.3.7"
 thiserror = "1.0.40"
 tokio = { version = "1.27.0", features = ["full"] }
 tracing = "0.1.37"
 tracing-appender = "0.2.2"
 tracing-subscriber = { version = "0.3.16", features = ["env-filter"] }
+zip = "0.6.4"

mcmeta/src/app_config.rs

@@ -4,13 +4,17 @@ use serde::Deserialize;
 #[derive(Deserialize, Debug)]
 #[serde(rename_all = "snake_case", tag = "type")]
 pub enum StorageFormat {
-    Json { meta_directory: String },
+    Json {
+        meta_directory: String,
+        generated_directory: String,
+    },
     Database,
 }
 
 #[derive(Deserialize, Debug)]
 pub struct MetadataConfig {
     pub max_parallel_fetch_connections: usize,
+    pub static_directory: String,
 }
 
 #[derive(Deserialize, Debug)]
@@ -35,7 +39,9 @@ impl ServerConfig {
             .set_default("bind_address", "127.0.0.1:8080")?
             .set_default("storage_format.type", "json")?
             .set_default("storage_format.meta_directory", "meta")?
+            .set_default("storage_format.generated_directory", "generated")?
             .set_default("metadata.max_parallel_fetch_connections", 4)?
+            .set_default("metadata.static_directory", "static")?
             .set_default("debug_log.enable", false)?
             .set_default("debug_log.path", "./logs")?
             .set_default("debug_log.prefix", "mcmeta.log")?

mcmeta/src/download/mojang.rs

@@ -1,9 +1,10 @@
 use libmcmeta::models::mojang::{MinecraftVersion, MojangVersionManifest};
 use serde::Deserialize;
 use serde_valid::Validate;
+use tempdir::TempDir;
 use tracing::debug;
 
-use anyhow::Result;
+use anyhow::{anyhow, Result};
 
 use crate::download::errors::MetadataError;
 
@@ -62,3 +63,53 @@ pub async fn load_version_manifest(version_url: &str) -> Result<MinecraftVersion
     manifest.validate()?;
     Ok(manifest)
 }
+
+pub async fn load_zipped_version(version_url: &str) -> Result<MinecraftVersion> {
+    use std::io::prelude::*;
+
+    let client = reqwest::Client::new();
+
+    debug!("Fetching zipped version from {:#?}", version_url);
+
+    let file_response = client.get(version_url).send().await?.error_for_status()?;
+
+    let tmp_dir = TempDir::new("mcmeta_mojang_zip")?;
+    let dest_path = {
+        let fname = file_response
+            .url()
+            .path_segments()
+            .and_then(|segments| segments.last())
+            .and_then(|name| if name.is_empty() { None } else { Some(name) })
+            .unwrap_or("tmp.zip");
+
+        tmp_dir.path().join(fname)
+    };
+
+    {
+        // write to file, context drop to flush and close
+        let mut file = std::fs::File::create(&dest_path)?;
+        let mut content = std::io::Cursor::new(file_response.bytes().await?);
+        std::io::copy(&mut content, &mut file)?;
+    }
+
+    let file = std::fs::File::open(&dest_path)?;
+
+    let mut archive = zip::ZipArchive::new(file)?;
+
+    let mut manifest: Option<MinecraftVersion> = None;
+    for i in 0..archive.len() {
+        let mut zfile = archive.by_index(i)?;
+        if zfile.name().ends_with(".json") {
+            debug!("Found {} as version json", zfile.name());
+            let mut contents = String::new();
+            zfile.read_to_string(&mut contents).unwrap();
+
+            manifest = Some(
+                serde_json::from_str(&contents)
+                    .map_err(|err| MetadataError::from_json_err(err, &contents))?,
+            );
+        }
+    }
+
+    Ok(manifest.ok_or(anyhow!("Unable to find version manifest"))?)
+}