Skip to main content

elemental_driver/drivers/rift/source/
client.rs

1use elemental_infra::jar::JarBytes;
2use elemental_schema::fabric::ProfileJson;
3
4use crate::{
5    error::{Error, Result},
6    families::version_json::UpstreamUrlRewriter,
7    http::{HttpSource, fetch_bytes, fetch_json},
8};
9
10use super::endpoints::RiftEndpoints;
11use super::profile_normalize::normalize_profile_json;
12use super::profile_parse::parse_profile_json;
13use super::release::{GitHubRelease, RiftRelease, build_rift_release, release_for_loader_version};
14
15#[derive(Debug, Clone)]
16pub struct RiftSource {
17    inner: HttpSource<RiftEndpoints>,
18}
19
20impl Default for RiftSource {
21    fn default() -> Self {
22        Self::new(RiftEndpoints::default())
23    }
24}
25
26impl RiftSource {
27    pub fn new(endpoints: RiftEndpoints) -> Self {
28        Self {
29            inner: HttpSource::new(endpoints, "rift source"),
30        }
31    }
32
33    pub fn with_client(endpoints: RiftEndpoints, client: reqwest::Client) -> Self {
34        Self {
35            inner: HttpSource::with_client(endpoints, client),
36        }
37    }
38
39    pub fn endpoints(&self) -> &RiftEndpoints {
40        self.inner.endpoints()
41    }
42
43    pub async fn releases(&self) -> Result<Vec<RiftRelease>> {
44        let url = self.endpoints().releases_url()?;
45        let releases: Vec<GitHubRelease> =
46            fetch_json(self.inner.client()?, url.as_str(), "rift source").await?;
47
48        releases
49            .into_iter()
50            .filter(|release| !release.draft)
51            .map(build_rift_release)
52            .collect()
53    }
54
55    pub async fn profile_json(&self, loader_version: &str) -> Result<ProfileJson> {
56        let release = release_for_loader_version(loader_version);
57        self.profile_json_for_release(&release).await
58    }
59
60    pub async fn profile_json_for_release(&self, release: &RiftRelease) -> Result<ProfileJson> {
61        let url = self
62            .endpoints()
63            .release_asset_url(release.tag_name.as_str(), release.asset_name.as_str())?;
64        let jar_bytes = fetch_bytes(self.inner.client()?, url.as_str(), "rift source").await?;
65        let raw_profile = read_release_profile_json(release, jar_bytes)?;
66        let profile = parse_profile_json(raw_profile.as_str())?;
67
68        normalize_profile_json(profile, release, self.endpoints())
69    }
70}
71
72impl UpstreamUrlRewriter for RiftEndpoints {
73    fn rewrite_upstream(&self, raw_url: &str) -> Result<String> {
74        RiftEndpoints::rewrite_upstream(self, raw_url)
75    }
76}
77
78fn read_release_profile_json(release: &RiftRelease, jar_bytes: Vec<u8>) -> Result<String> {
79    JarBytes::new(jar_bytes.as_slice())
80        .by_name_string("profile.json")
81        .map_err(|source| Error::ReadRiftProfile {
82            asset_name: release.asset_name.clone(),
83            source,
84        })
85}