eightequal/AstralRinth
1
0
Fork 0
forked from didirus/AstralRinth
Code Pull Requests Activity

Merge commit '037cc86c1f520d8e89e721a631c9163d01c61070' into feature-clean

Browse Source
This commit is contained in:
didirus4
2025-02-10 22:15:18 +03:00
parent 4060e842fd 037cc86c1f
commit 5bdbb8b5d5
118 changed files with 4847 additions and 2135 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
packages/app-lib/src/api/pack/import/mmc.rs
View File

@@ -180,9 +180,8 @@ pub async fn import_mmc(
instance_folder: String, // instance folder in mmc_base_path
profile_path: &str, // path to profile
) -> crate::Result<()> {
let mmc_instance_path = mmc_base_path
.join("instances")
.join(instance_folder.clone());
let mmc_instance_path =
mmc_base_path.join("instances").join(instance_folder);
let mmc_pack =
io::read_to_string(&mmc_instance_path.join("mmc-pack.json")).await?;
@@ -209,9 +208,18 @@ pub async fn import_mmc(
profile_path: profile_path.to_string(),
};
// Managed pack
let backup_name = "Imported Modpack".to_string();
let mut minecraft_folder = mmc_instance_path.join("minecraft");
if !minecraft_folder.is_dir() {
minecraft_folder = mmc_instance_path.join(".minecraft");
if !minecraft_folder.is_dir() {
return Err(crate::ErrorKind::InputError(
"Instance is missing Minecraft directory".to_string(),
)
.into());
}
}
// Managed pack
if instance_cfg.managed_pack.unwrap_or(false) {
match instance_cfg.managed_pack_type {
Some(MMCManagedPackType::Modrinth) => {
@@ -220,38 +228,26 @@ pub async fn import_mmc(
// Modrinth Managed Pack
// Kept separate as we may in the future want to add special handling for modrinth managed packs
let backup_name = "Imported Modrinth Modpack".to_string();
let minecraft_folder = mmc_base_path.join("instances").join(instance_folder).join(".minecraft");
import_mmc_unmanaged(profile_path, minecraft_folder, backup_name, description, mmc_pack).await?;
import_mmc_unmanaged(profile_path, minecraft_folder, "Imported Modrinth Modpack".to_string(), description, mmc_pack).await?;
}
Some(MMCManagedPackType::Flame) | Some(MMCManagedPackType::ATLauncher) => {
// For flame/atlauncher managed packs
// Treat as unmanaged, but with 'minecraft' folder instead of '.minecraft'
let minecraft_folder = mmc_base_path.join("instances").join(instance_folder).join("minecraft");
import_mmc_unmanaged(profile_path, minecraft_folder, backup_name, description, mmc_pack).await?;
import_mmc_unmanaged(profile_path, minecraft_folder, "Imported Modpack".to_string(), description, mmc_pack).await?;
},
Some(_) => {
// For managed packs that aren't modrinth, flame, atlauncher
// Treat as unmanaged
let backup_name = "ImportedModpack".to_string();
let minecraft_folder = mmc_base_path.join("instances").join(instance_folder).join(".minecraft");
import_mmc_unmanaged(profile_path, minecraft_folder, backup_name, description, mmc_pack).await?;
import_mmc_unmanaged(profile_path, minecraft_folder, "ImportedModpack".to_string(), description, mmc_pack).await?;
},
_ => return Err(crate::ErrorKind::InputError({
"Instance is managed, but managed pack type not specified in instance.cfg".to_string()
}).into())
_ => return Err(crate::ErrorKind::InputError("Instance is managed, but managed pack type not specified in instance.cfg".to_string()).into())
}
} else {
// Direclty import unmanaged pack
let backup_name = "Imported Modpack".to_string();
let minecraft_folder = mmc_base_path
.join("instances")
.join(instance_folder)
.join(".minecraft");
import_mmc_unmanaged(
profile_path,
minecraft_folder,
backup_name,
"Imported Modpack".to_string(),
description,
mmc_pack,
)

8
packages/app-lib/src/api/pack/install_mrpack.rs
View File

@@ -13,13 +13,13 @@ use crate::util::io;
use crate::{profile, State};
use async_zip::base::read::seek::ZipFileReader;
use std::io::Cursor;
use std::path::{Component, PathBuf};
use super::install_from::{
generate_pack_from_file, generate_pack_from_version_id, CreatePack,
CreatePackLocation, PackFormat,
};
use crate::data::ProjectType;
use std::io::Cursor;
use std::path::{Component, PathBuf};
/// Install a pack
/// Wrapper around install_pack_files that generates a pack creation description, and
@@ -189,6 +189,7 @@ pub async fn install_zipped_mrpack_files(
.hashes
.get(&PackFileHash::Sha1)
.map(|x| &**x),
ProjectType::get_from_parent_folder(&path),
&state.pool,
)
.await?;
@@ -247,6 +248,7 @@ pub async fn install_zipped_mrpack_files(
&profile_path,
&new_path.to_string_lossy(),
None,
ProjectType::get_from_parent_folder(&new_path),
&state.pool,
)
.await?;

15
packages/app-lib/src/api/profile/mod.rs
View File

@@ -9,7 +9,7 @@ use crate::pack::install_from::{
};
use crate::state::{
CacheBehaviour, CachedEntry, Credentials, JavaVersion, ProcessMetadata,
ProfileFile, ProjectType, SideType,
ProfileFile, ProfileInstallStage, ProjectType, SideType,
};
use crate::event::{emit::emit_profile, ProfilePayloadType};
@@ -225,7 +225,18 @@ pub async fn list() -> crate::Result<Vec<Profile>> {
#[tracing::instrument]
pub async fn install(path: &str, force: bool) -> crate::Result<()> {
if let Some(profile) = get(path).await? {
crate::launcher::install_minecraft(&profile, None, force).await?;
let result =
crate::launcher::install_minecraft(&profile, None, force).await;
if result.is_err()
&& profile.install_stage != ProfileInstallStage::Installed
{
edit(path, |prof| {
prof.install_stage = ProfileInstallStage::NotInstalled;
async { Ok(()) }
})
.await?;
}
result?;
} else {
return Err(crate::ErrorKind::UnmanagedProfileError(path.to_string())
.as_error());

2
packages/app-lib/src/api/profile/update.rs
View File

@@ -111,7 +111,7 @@ async fn replace_managed_modrinth(
ignore_lock: bool,
) -> crate::Result<()> {
crate::profile::edit(profile_path, |profile| {
profile.install_stage = ProfileInstallStage::Installing;
profile.install_stage = ProfileInstallStage::MinecraftInstalling;
async { Ok(()) }
})
.await?;

10
packages/app-lib/src/launcher/mod.rs
View File

@@ -7,11 +7,7 @@ use crate::state::{
Credentials, JavaVersion, ProcessMetadata, ProfileInstallStage,
};
use crate::util::io;
use crate::{
process,
state::{self as st},
State,
};
use crate::{process, state as st, State};
use chrono::Utc;
use daedalus as d;
use daedalus::minecraft::{RuleAction, VersionInfo};
@@ -202,7 +198,7 @@ pub async fn install_minecraft(
.await?;
crate::api::profile::edit(&profile.path, |prof| {
prof.install_stage = ProfileInstallStage::Installing;
prof.install_stage = ProfileInstallStage::MinecraftInstalling;
async { Ok(()) }
})
@@ -434,7 +430,7 @@ pub async fn launch_minecraft(
profile: &Profile,
) -> crate::Result<ProcessMetadata> {
if profile.install_stage == ProfileInstallStage::PackInstalling
|| profile.install_stage == ProfileInstallStage::Installing
|| profile.install_stage == ProfileInstallStage::MinecraftInstalling
{
return Err(crate::ErrorKind::LauncherError(
"Profile is still installing".to_string(),

40
packages/app-lib/src/state/cache.rs
View File

@@ -1,4 +1,5 @@
use crate::config::{META_URL, MODRINTH_API_URL, MODRINTH_API_URL_V3};
use crate::state::ProjectType;
use crate::util::fetch::{fetch_json, sha1_async, FetchSemaphore};
use chrono::{DateTime, Utc};
use dashmap::DashSet;
@@ -194,7 +195,7 @@ pub struct SearchEntry {
pub struct CachedFileUpdate {
pub hash: String,
pub game_version: String,
pub loader: String,
pub loaders: Vec<String>,
pub update_version_id: String,
}
@@ -203,6 +204,7 @@ pub struct CachedFileHash {
pub path: String,
pub size: u64,
pub hash: String,
pub project_type: Option<ProjectType>,
}
#[derive(Serialize, Deserialize, Clone, Debug)]
@@ -481,7 +483,12 @@ impl CacheValue {
)
}
CacheValue::FileUpdate(hash) => {
format!("{}-{}-{}", hash.hash, hash.loader, hash.game_version)
format!(
"{}-{}-{}",
hash.hash,
hash.loaders.join("+"),
hash.game_version
)
}
CacheValue::SearchResults(search) => search.search.clone(),
}
@@ -1240,6 +1247,9 @@ impl CachedEntry {
path: path.to_string(),
size,
hash,
project_type: ProjectType::get_from_parent_folder(
&full_path,
),
})
.get_entry(),
true,
@@ -1270,18 +1280,21 @@ impl CachedEntry {
if key.len() == 3 {
let hash = key[0];
let loader = key[1];
let loaders_key = key[1];
let game_version = key[2];
if let Some(values) =
filtered_keys.iter_mut().find(|x| {
x.0 .0 == loader && x.0 .1 == game_version
x.0 .0 == loaders_key && x.0 .1 == game_version
})
{
values.1.push(hash.to_string());
} else {
filtered_keys.push((
(loader.to_string(), game_version.to_string()),
(
loaders_key.to_string(),
game_version.to_string(),
),
vec![hash.to_string()],
))
}
@@ -1297,7 +1310,7 @@ impl CachedEntry {
format!("{}version_files/update", MODRINTH_API_URL);
let variations =
futures::future::try_join_all(filtered_keys.iter().map(
|((loader, game_version), hashes)| {
|((loaders_key, game_version), hashes)| {
fetch_json::<HashMap<String, Version>>(
Method::POST,
&version_update_url,
@@ -1305,7 +1318,7 @@ impl CachedEntry {
Some(serde_json::json!({
"algorithm": "sha1",
"hashes": hashes,
"loaders": [loader],
"loaders": loaders_key.split('+').collect::<Vec<_>>(),
"game_versions": [game_version]
})),
fetch_semaphore,
@@ -1317,7 +1330,7 @@ impl CachedEntry {
for (index, mut variation) in variations.into_iter().enumerate()
{
let ((loader, game_version), hashes) =
let ((loaders_key, game_version), hashes) =
&filtered_keys[index];
for hash in hashes {
@@ -1334,7 +1347,10 @@ impl CachedEntry {
CacheValue::FileUpdate(CachedFileUpdate {
hash: hash.clone(),
game_version: game_version.clone(),
loader: loader.clone(),
loaders: loaders_key
.split('+')
.map(|x| x.to_string())
.collect(),
update_version_id: version_id,
})
.get_entry(),
@@ -1343,7 +1359,9 @@ impl CachedEntry {
} else {
vals.push((
CacheValueType::FileUpdate.get_empty_entry(
format!("{hash}-{loader}-{game_version}"),
format!(
"{hash}-{loaders_key}-{game_version}"
),
),
true,
))
@@ -1450,6 +1468,7 @@ pub async fn cache_file_hash(
profile_path: &str,
path: &str,
known_hash: Option<&str>,
project_type: Option<ProjectType>,
exec: impl sqlx::Executor<'_, Database = sqlx::Sqlite>,
) -> crate::Result<()> {
let size = bytes.len();
@@ -1465,6 +1484,7 @@ pub async fn cache_file_hash(
path: format!("{}/{}", profile_path, path),
size: size as u64,
hash,
project_type,
})
.get_entry()],
exec,

9
packages/app-lib/src/state/legacy_converter.rs
View File

@@ -1,4 +1,4 @@
use crate::data::{Dependency, User, Version};
use crate::data::{Dependency, ProjectType, User, Version};
use crate::jre::check_jre;
use crate::prelude::ModLoader;
use crate::state;
@@ -226,6 +226,7 @@ where
path: file_name,
size: metadata.len(),
hash: sha1.clone(),
project_type: ProjectType::get_from_parent_folder(&full_path),
},
));
}
@@ -249,9 +250,9 @@ where
.metadata
.game_version
.clone(),
loader: mod_loader
loaders: vec![mod_loader
.as_str()
.to_string(),
.to_string()],
update_version_id:
update_version.id.clone(),
},
@@ -307,7 +308,7 @@ where
ProfileInstallStage::Installed
}
LegacyProfileInstallStage::Installing => {
ProfileInstallStage::Installing
ProfileInstallStage::MinecraftInstalling
}
LegacyProfileInstallStage::PackInstalling => {
ProfileInstallStage::PackInstalling

22
packages/app-lib/src/state/minecraft_auth.rs
View File

@@ -178,19 +178,16 @@ pub async fn login_finish(
minecraft_entitlements(&minecraft_token.access_token).await?;
let profile = minecraft_profile(&minecraft_token.access_token).await?;
let profile_id = profile.id.unwrap_or_default();
let credentials = Credentials {
id: profile_id,
username: profile.name,
let mut credentials = Credentials {
id: Uuid::default(),
username: String::default(),
access_token: minecraft_token.access_token,
refresh_token: oauth_token.value.refresh_token,
expires: oauth_token.date
+ Duration::seconds(oauth_token.value.expires_in as i64),
active: true,
};
credentials.get_profile().await?;
credentials.upsert(exec).await?;
@@ -268,11 +265,22 @@ impl Credentials {
self.expires = oauth_token.date
+ Duration::seconds(oauth_token.value.expires_in as i64);
self.get_profile().await?;
self.upsert(exec).await?;
Ok(())
}
async fn get_profile(&mut self) -> crate::Result<()> {
let profile = minecraft_profile(&self.access_token).await?;
self.id = profile.id.unwrap_or_default();
self.username = profile.name;
Ok(())
}
#[tracing::instrument]
pub async fn get_default_credential(
exec: impl sqlx::Executor<'_, Database = sqlx::Sqlite> + Copy,

92
packages/app-lib/src/state/profiles.rs
View File

@@ -1,5 +1,7 @@
use super::settings::{Hooks, MemorySettings, WindowSize};
use crate::state::{cache_file_hash, CacheBehaviour, CachedEntry};
use crate::state::{
cache_file_hash, CacheBehaviour, CachedEntry, CachedFileHash,
};
use crate::util;
use crate::util::fetch::{write_cached_icon, FetchSemaphore, IoSemaphore};
use crate::util::io::{self};
@@ -9,7 +11,7 @@ use serde::{Deserialize, Serialize};
use sqlx::SqlitePool;
use std::convert::TryFrom;
use std::convert::TryInto;
use std::path::{Path, PathBuf};
use std::path::Path;
// Represent a Minecraft instance.
#[derive(Serialize, Deserialize, Clone, Debug)]
@@ -51,7 +53,9 @@ pub enum ProfileInstallStage {
/// Profile is installed
Installed,
/// Profile's minecraft game is still installing
Installing,
MinecraftInstalling,
/// Pack is installed, but Minecraft installation has not begun
PackInstalled,
/// Profile created for pack, but the pack hasn't been fully installed yet
PackInstalling,
/// Profile is not installed
@@ -62,7 +66,8 @@ impl ProfileInstallStage {
pub fn as_str(&self) -> &'static str {
match *self {
Self::Installed => "installed",
Self::Installing => "installing",
Self::MinecraftInstalling => "minecraft_installing",
Self::PackInstalled => "pack_installed",
Self::PackInstalling => "pack_installing",
Self::NotInstalled => "not_installed",
}
@@ -71,7 +76,9 @@ impl ProfileInstallStage {
pub fn from_str(val: &str) -> Self {
match val {
"installed" => Self::Installed,
"installing" => Self::Installing,
"minecraft_installing" => Self::MinecraftInstalling,
"installing" => Self::MinecraftInstalling, // Backwards compatibility
"pack_installed" => Self::PackInstalled,
"pack_installing" => Self::PackInstalling,
"not_installed" => Self::NotInstalled,
_ => Self::NotInstalled,
@@ -146,7 +153,7 @@ pub struct FileMetadata {
pub version_id: String,
}
#[derive(Serialize, Deserialize, Clone, Debug, Copy)]
#[derive(Serialize, Deserialize, Clone, Debug, Copy, PartialEq, Eq)]
#[serde(rename_all = "lowercase")]
pub enum ProjectType {
Mod,
@@ -176,7 +183,7 @@ impl ProjectType {
}
}
pub fn get_from_parent_folder(path: PathBuf) -> Option<Self> {
pub fn get_from_parent_folder(path: &Path) -> Option<Self> {
// Get parent folder
let path = path.parent()?.file_name()?;
match path.to_str()? {
@@ -206,6 +213,15 @@ impl ProjectType {
}
}
pub fn get_loaders(&self) -> &'static [&'static str] {
match self {
ProjectType::Mod => &["fabric", "forge", "quilt", "neoforge"],
ProjectType::DataPack => &["datapack"],
ProjectType::ResourcePack => &["vanilla", "canvas", "minecraft"],
ProjectType::ShaderPack => &["iris", "optifine"],
}
}
pub fn iterator() -> impl Iterator<Item = ProjectType> {
[
ProjectType::Mod,
@@ -538,11 +554,11 @@ impl Profile {
pub(crate) async fn refresh_all() -> crate::Result<()> {
let state = crate::State::get().await?;
let all = Self::get_all(&state.pool).await?;
let mut all = Self::get_all(&state.pool).await?;
let mut keys = vec![];
for profile in &all {
for profile in &mut all {
let path =
crate::api::profile::get_full_path(&profile.path).await?;
@@ -575,6 +591,17 @@ impl Profile {
}
}
}
if profile.install_stage == ProfileInstallStage::MinecraftInstalling
{
profile.install_stage = ProfileInstallStage::PackInstalled;
profile.upsert(&state.pool).await?;
} else if profile.install_stage
== ProfileInstallStage::PackInstalling
{
profile.install_stage = ProfileInstallStage::NotInstalled;
profile.upsert(&state.pool).await?;
}
}
let file_hashes = CachedEntry::get_file_hash_many(
@@ -587,17 +614,10 @@ impl Profile {
let file_updates = file_hashes
.iter()
.filter_map(|x| {
all.iter().find(|prof| x.path.contains(&prof.path)).map(
|profile| {
format!(
"{}-{}-{}",
x.hash,
profile.loader.as_str(),
profile.game_version
)
},
)
.filter_map(|file| {
all.iter()
.find(|prof| file.path.contains(&prof.path))
.map(|profile| Self::get_cache_key(file, profile))
})
.collect::<Vec<_>>();
@@ -690,14 +710,7 @@ impl Profile {
let file_updates = file_hashes
.iter()
.map(|x| {
format!(
"{}-{}-{}",
x.hash,
self.loader.as_str(),
self.game_version
)
})
.map(|x| Self::get_cache_key(x, self))
.collect::<Vec<_>>();
let file_hashes_ref =
@@ -773,6 +786,18 @@ impl Profile {
Ok(files)
}
fn get_cache_key(file: &CachedFileHash, profile: &Profile) -> String {
format!(
"{}-{}-{}",
file.hash,
file.project_type
.filter(|x| *x != ProjectType::Mod)
.map(|x| x.get_loaders().join("+"))
.unwrap_or_else(|| profile.loader.as_str().to_string()),
profile.game_version
)
}
#[tracing::instrument(skip(pool))]
pub async fn add_project_version(
profile_path: &str,
@@ -873,8 +898,15 @@ impl Profile {
let project_path =
format!("{}/{}", project_type.get_folder(), file_name);
cache_file_hash(bytes.clone(), profile_path, &project_path, hash, exec)
.await?;
cache_file_hash(
bytes.clone(),
profile_path,
&project_path,
hash,
Some(project_type),
exec,
)
.await?;
util::fetch::write(&path.join(&project_path), &bytes, io_semaphore)
.await?;