mc-snap 0.6.0

Declarative Minecraft server management. Pin Minecraft, loader, mods, Java, and configs in one YAML file; resolve, install, run, and ship a reproducible bundle.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

use crate::ResolvedMod;
use serde::Deserialize;
use std::collections::BTreeMap;

const SITE: &str = "https://vanillatweaks.net";

/// VanillaTweaks datapack generator. Unlike Modrinth/CurseForge there is no
/// project to resolve: the user picks a set of packs grouped by category and the
/// site bundles them into a single zip on demand. We POST the selection, follow
/// the returned link to download the generated zip, then content-address it.
///
/// The generated download link is ephemeral (it points at a freshly built zip on
/// the VanillaTweaks side), so the locked `url` may stop working once the build is
/// garbage-collected. That is fine in practice: the content-addressed cache keeps
/// the zip by sha256, so reinstalls on the same machine never refetch.
pub struct VanillaTweaks {
    client: reqwest::Client,
    base: String,
}

impl Default for VanillaTweaks {
    fn default() -> Self {
        Self::new()
    }
}

impl VanillaTweaks {
    pub fn new() -> Self {
        Self {
            client: crate::download::http_client().expect("client"),
            base: SITE.to_string(),
        }
    }

    pub fn with_base(base: impl Into<String>) -> Self {
        Self {
            base: base.into(),
            ..Self::new()
        }
    }

    /// Generate and download a datapack bundle for `version` (a VanillaTweaks
    /// game version such as `1.21`) from the selected `packs`.
    pub async fn resolve(
        &self,
        version: &str,
        packs: &BTreeMap<String, Vec<String>>,
    ) -> anyhow::Result<ResolvedMod> {
        if packs.values().all(|v| v.is_empty()) {
            anyhow::bail!("vanillatweaks datapack selection is empty");
        }
        let packs_json = serde_json::to_string(packs)?;
        let gen_url = format!("{}/assets/server/zipdatapacks.php", self.base);
        let resp: ZipResponse = self
            .client
            .post(&gen_url)
            .form(&[("version", version), ("packs", packs_json.as_str())])
            .send()
            .await?
            .error_for_status()?
            .json()
            .await?;

        if resp.status != "success" {
            anyhow::bail!(
                "vanillatweaks generation failed (status {}): {}",
                resp.status,
                resp.message.unwrap_or_default()
            );
        }
        let link = resp
            .link
            .ok_or_else(|| anyhow::anyhow!("vanillatweaks response missing download link"))?;
        let url = if link.starts_with("http") {
            link
        } else {
            format!("{}{}", self.base, link)
        };

        let bytes = crate::download::fetch_bytes(&self.client, &url).await?;
        let sha256 = crate::download::prime_cache(&bytes);

        let filename = url
            .rsplit('/')
            .next()
            .and_then(|s| s.split('?').next())
            .filter(|s| !s.is_empty())
            .unwrap_or("vanillatweaks-datapacks.zip")
            .to_string();

        Ok(ResolvedMod {
            id: "vanillatweaks".into(),
            provider: "vanillatweaks".into(),
            version: version.to_string(),
            filename,
            url,
            sha256,
        })
    }
}

#[derive(Debug, Deserialize)]
struct ZipResponse {
    status: String,
    #[serde(default)]
    link: Option<String>,
    #[serde(default)]
    message: Option<String>,
}