Move config into own file, add implementation for StorageFormat

Also make sure there are no unknown fields on metadata to make
sure we know about them.

Author: cozyGalvinism

libmcmeta/src/models/forge.rs

@@ -0,0 +1,88 @@
+use std::collections::HashMap;
+
+use serde::{Deserialize, Serialize};
+
+#[derive(Deserialize, Serialize, Clone, Debug)]
+pub struct ForgeMavenMetadata {
+    #[serde(flatten)]
+    pub versions: HashMap<String, Vec<String>>,
+}
+
+#[derive(Deserialize, Serialize, Clone, Debug)]
+pub struct ForgeMavenPromotions {
+    pub homepage: String,
+    pub promos: HashMap<String, String>,
+}
+
+#[derive(Deserialize, Serialize, Clone, Debug)]
+pub struct ForgeVersionMeta {
+    pub classifiers: ForgeVersionClassifiers,
+}
+
+#[derive(Deserialize, Serialize, Clone, Debug)]
+#[serde(deny_unknown_fields)]
+pub struct ForgeVersionClassifier {
+    pub txt: Option<String>,
+    pub zip: Option<String>,
+    pub jar: Option<String>,
+    pub stash: Option<String>,
+}
+
+#[derive(Deserialize, Serialize, Clone, Debug)]
+#[serde(deny_unknown_fields)]
+pub struct ForgeVersionClassifiers {
+    pub changelog: Option<ForgeVersionClassifier>,
+    pub installer: Option<ForgeVersionClassifier>,
+    pub mdk: Option<ForgeVersionClassifier>,
+    pub universal: Option<ForgeVersionClassifier>,
+    pub userdev: Option<ForgeVersionClassifier>,
+    pub sources: Option<ForgeVersionClassifier>,
+    pub javadoc: Option<ForgeVersionClassifier>,
+    pub client: Option<ForgeVersionClassifier>,
+    pub src: Option<ForgeVersionClassifier>,
+    pub server: Option<ForgeVersionClassifier>,
+    pub launcher: Option<ForgeVersionClassifier>,
+    pub userdev3: Option<ForgeVersionClassifier>,
+    #[serde(rename = "src.zip")]
+    pub src_zip: Option<ForgeVersionClassifier>,
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_deserialization() {
+        // meta dir is ./meta
+        let cwd = std::env::current_dir().unwrap();
+        let meta_dir = cwd.join("../meta/forge");
+        println!("meta_dir: {:?}", meta_dir);
+
+        let metadata_path = meta_dir.join("maven-metadata.json");
+        let metadata = serde_json::from_str::<super::ForgeMavenMetadata>(
+            &std::fs::read_to_string(metadata_path).unwrap(),
+        );
+        if let Err(e) = metadata {
+            panic!("Failed to deserialize metadata: {:?}", e);
+        }
+        let metadata = metadata.unwrap();
+
+        let promotions_path = meta_dir.join("promotions_slim.json");
+        let promotions = serde_json::from_str::<super::ForgeMavenPromotions>(
+            &std::fs::read_to_string(promotions_path).unwrap(),
+        );
+        if let Err(e) = promotions {
+            panic!("Failed to deserialize promotions: {:?}", e);
+        }
+
+        for (_, forge_versions) in metadata.versions {
+            for forge_version in forge_versions {
+                let version_path = meta_dir.join(format!("files_manifests/{}.json", forge_version));
+                let version = serde_json::from_str::<super::ForgeVersionMeta>(
+                    &std::fs::read_to_string(version_path).unwrap(),
+                );
+                if let Err(e) = version {
+                    panic!("Failed to deserialize version {}: {:?}", forge_version, e);
+                }
+            }
+        }
+    }
+}

libmcmeta/src/models/mod.rs

@@ -2,6 +2,7 @@ use std::{fmt::Display, str::FromStr};
 
 use serde::{Deserialize, Serialize};
 
+pub mod forge;
 pub mod mojang;
 
 custom_error! { pub ModelError

libmcmeta/src/models/mojang.rs

@@ -1,7 +1,7 @@
 use serde::{Deserialize, Serialize};
 
 #[derive(Deserialize, Serialize, Debug)]
-#[serde(rename_all = "camelCase")]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
 pub struct MojangVersionManifest {
     /// The latest version of Minecraft.
     pub latest: MojangVersionManifestLatest,
@@ -11,7 +11,7 @@ pub struct MojangVersionManifest {
 
 /// The latest version of Minecraft.
 #[derive(Deserialize, Serialize, Debug)]
-#[serde(rename_all = "camelCase")]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
 pub struct MojangVersionManifestLatest {
     /// The latest release version of Minecraft.
     pub release: String,
@@ -21,7 +21,7 @@ pub struct MojangVersionManifestLatest {
 
 /// A version of Minecraft.
 #[derive(Deserialize, Serialize, Debug)]
-#[serde(rename_all = "camelCase")]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
 pub struct MojangVersionManifestVersion {
     /// The ID of the version.
     pub id: String,
@@ -36,10 +36,12 @@ pub struct MojangVersionManifestVersion {
     pub release_time: String,
     /// Compliance level
     pub compliance_level: i32,
+    /// The sha1 hash of the version's JSON.
+    pub sha1: String,
 }
 
 #[derive(Deserialize, Serialize, Debug)]
-#[serde(rename_all = "camelCase")]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
 pub struct AssetIndex {
     pub id: String,
     pub sha1: String,
@@ -49,29 +51,32 @@ pub struct AssetIndex {
 }
 
 #[derive(Deserialize, Serialize, Debug)]
-#[serde(rename_all = "camelCase")]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
 pub struct VersionDownload {
     pub sha1: String,
     pub size: i32,
     pub url: String,
 }
 
 #[derive(Deserialize, Serialize, Debug)]
-#[serde(rename_all = "camelCase")]
+#[serde(deny_unknown_fields)]
 pub struct VersionDownloads {
     pub client: VersionDownload,
     pub server: Option<VersionDownload>,
+    pub windows_server: Option<VersionDownload>,
+    pub client_mappings: Option<VersionDownload>,
+    pub server_mappings: Option<VersionDownload>,
 }
 
 #[derive(Deserialize, Serialize, Debug)]
-#[serde(rename_all = "camelCase")]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
 pub struct JavaVersion {
     pub component: String,
     pub major_version: i32,
 }
 
 #[derive(Deserialize, Serialize, Debug)]
-#[serde(rename_all = "camelCase")]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
 pub struct VersionLibraryDownloadInfo {
     pub path: String,
     pub sha1: String,
@@ -80,41 +85,49 @@ pub struct VersionLibraryDownloadInfo {
 }
 
 #[derive(Deserialize, Serialize, Debug)]
-#[serde(rename_all = "camelCase")]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
 pub struct VersionLibraryClassifiers {
     pub javadoc: Option<VersionLibraryDownloadInfo>,
     #[serde(rename = "natives-linux")]
     pub natives_linux: Option<VersionLibraryDownloadInfo>,
     #[serde(rename = "natives-macos")]
     pub natives_macos: Option<VersionLibraryDownloadInfo>,
+    #[serde(rename = "natives-osx")]
+    pub natives_osx: Option<VersionLibraryDownloadInfo>,
     #[serde(rename = "natives-windows")]
     pub natives_windows: Option<VersionLibraryDownloadInfo>,
+    #[serde(rename = "natives-windows-32")]
+    pub natives_windows_32: Option<VersionLibraryDownloadInfo>,
+    #[serde(rename = "natives-windows-64")]
+    pub natives_windows_64: Option<VersionLibraryDownloadInfo>,
+    #[serde(rename = "linux-x86_64")]
+    pub linux_x86_64: Option<VersionLibraryDownloadInfo>,
     pub sources: Option<VersionLibraryDownloadInfo>,
 }
 
 #[derive(Deserialize, Serialize, Debug)]
-#[serde(rename_all = "camelCase")]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
 pub struct VersionLibraryNatives {
     pub linux: Option<String>,
     pub osx: Option<String>,
     pub windows: Option<String>,
 }
 
 #[derive(Deserialize, Serialize, Debug)]
-#[serde(rename_all = "camelCase")]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
 pub struct VersionLibraryDownloads {
     pub artifact: Option<VersionLibraryDownloadInfo>,
     pub classifiers: Option<VersionLibraryClassifiers>,
 }
 
 #[derive(Deserialize, Serialize, Debug)]
-#[serde(rename_all = "camelCase")]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
 pub struct VersionLibraryExtract {
     pub exclude: Vec<String>,
 }
 
 #[derive(Deserialize, Serialize, Debug)]
-#[serde(rename_all = "camelCase")]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
 pub struct VersionLibrary {
     pub name: String,
     pub downloads: VersionLibraryDownloads,
@@ -124,36 +137,36 @@ pub struct VersionLibrary {
 }
 
 #[derive(Deserialize, Serialize, Debug)]
-#[serde(rename_all = "camelCase")]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
 pub struct ManifestRule {
     pub action: String,
     pub os: Option<ManifestRuleOS>,
     pub features: Option<ManifestRuleFeatures>,
 }
 
 #[derive(Deserialize, Serialize, Debug)]
-#[serde(rename_all = "camelCase")]
+#[serde(deny_unknown_fields)]
 pub struct ManifestRuleFeatures {
     pub is_demo_user: Option<bool>,
     pub has_custom_resolution: Option<bool>,
 }
 
 #[derive(Deserialize, Serialize, Debug)]
-#[serde(rename_all = "camelCase")]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
 pub struct ManifestRuleOS {
     pub name: Option<String>,
     pub version: Option<String>,
     pub arch: Option<String>,
 }
 
 #[derive(Deserialize, Serialize, Debug)]
-#[serde(rename_all = "camelCase")]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
 pub struct VersionLogging {
     pub client: VersionLoggingClient,
 }
 
 #[derive(Deserialize, Serialize, Debug)]
-#[serde(rename_all = "camelCase")]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
 pub struct VersionLoggingClient {
     pub argument: String,
     pub file: VersionLoggingClientFile,
@@ -162,7 +175,7 @@ pub struct VersionLoggingClient {
 }
 
 #[derive(Deserialize, Serialize, Debug)]
-#[serde(rename_all = "camelCase")]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
 pub struct VersionLoggingClientFile {
     pub id: String,
     pub sha1: String,
@@ -185,21 +198,21 @@ pub enum VersionArgumentValue {
 }
 
 #[derive(Deserialize, Serialize, Debug)]
-#[serde(rename_all = "camelCase")]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
 pub struct VersionArgumentObject {
     pub rules: Vec<ManifestRule>,
     pub value: VersionArgumentValue,
 }
 
 #[derive(Deserialize, Serialize, Debug)]
-#[serde(rename_all = "camelCase")]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
 pub struct VersionArguments {
     pub game: Vec<VersionArgument>,
     pub jvm: Vec<VersionArgument>,
 }
 
 #[derive(Deserialize, Serialize, Debug)]
-#[serde(rename_all = "camelCase")]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
 pub struct MinecraftVersion {
     pub asset_index: AssetIndex,
     pub assets: String,

mcmeta/src/app_config.rs

@@ -0,0 +1,32 @@
+use serde::Deserialize;
+
+use crate::MetaMCError;
+
+#[derive(Deserialize, Debug)]
+#[serde(rename_all = "snake_case", untagged)]
+pub enum StorageFormat {
+    Json { meta_directory: String },
+    Database,
+}
+
+#[derive(Deserialize, Debug)]
+pub struct ServerConfig {
+    pub bind_address: String,
+    pub storage_format: StorageFormat,
+}
+
+impl ServerConfig {
+    pub fn from_config() -> Result<Self, MetaMCError> {
+        let config = config::Config::builder()
+            .add_source(config::Environment::with_prefix("MCMETA"))
+            .set_default("bind_address", "127.0.0.1:8080")
+            .unwrap()
+            .set_default("storage_format", "json")
+            .unwrap()
+            .set_default("meta_directory", "meta")
+            .unwrap()
+            .build()?;
+
+        config.try_deserialize::<'_, Self>().map_err(Into::into)
+    }
+}