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

Merge commit '81ec068747a39e927c42273011252daaa58f1e14' into feature-clean

Browse Source
This commit is contained in:
didirus4
2024-12-26 16:51:17 +03:00
parent 69bbbb30e2 81ec068747
commit 7bbc79c6a1
361 changed files with 25873 additions and 23923 deletions
Download Patch File Download Diff File Expand all files Collapse all files

35
packages/app-lib/src/api/friends.rs Normal file
View File

@@ -0,0 +1,35 @@
use crate::state::{FriendsSocket, UserFriend, UserStatus};
#[tracing::instrument]
pub async fn friends() -> crate::Result<Vec<UserFriend>> {
let state = crate::State::get().await?;
let friends =
FriendsSocket::friends(&state.pool, &state.api_semaphore).await?;
Ok(friends)
}
pub async fn friend_statuses() -> crate::Result<Vec<UserStatus>> {
let state = crate::State::get().await?;
let statuses = state.friends_socket.friend_statuses();
Ok(statuses)
}
#[tracing::instrument]
pub async fn add_friend(user_id: &str) -> crate::Result<()> {
let state = crate::State::get().await?;
FriendsSocket::add_friend(user_id, &state.pool, &state.api_semaphore)
.await?;
Ok(())
}
#[tracing::instrument]
pub async fn remove_friend(user_id: &str) -> crate::Result<()> {
let state = crate::State::get().await?;
FriendsSocket::remove_friend(user_id, &state.pool, &state.api_semaphore)
.await?;
Ok(())
}

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

@@ -289,7 +289,7 @@ pub async fn delete_logs_by_filename(
};
let path = logs_folder.join(filename);
io::remove_dir_all(&path).await?;
io::remove_file(&path).await?;
Ok(())
}

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

@@ -1,5 +1,6 @@
//! API for interacting with Theseus
pub mod cache;
pub mod friends;
pub mod handler;
pub mod jre;
pub mod logs;
@@ -19,7 +20,7 @@ pub mod data {
Hooks, JavaVersion, LinkedData, MemorySettings, ModLoader,
ModrinthCredentials, Organization, ProcessMetadata, ProfileFile,
Project, ProjectType, SearchResult, SearchResults, Settings,
TeamMember, Theme, User, Version, WindowSize,
TeamMember, Theme, User, UserFriend, UserStatus, Version, WindowSize,
};
}

7
packages/app-lib/src/api/mr_auth.rs
View File

@@ -1,7 +1,7 @@
use crate::state::ModrinthCredentials;
#[tracing::instrument]
pub fn authenticate_begin_flow() -> &'static str {
pub fn authenticate_begin_flow() -> String {
crate::state::get_login_url()
}
@@ -19,6 +19,10 @@ pub async fn authenticate_finish_flow(
.await?;
creds.upsert(&state.pool).await?;
state
.friends_socket
.connect(&state.pool, &state.api_semaphore, &state.process_manager)
.await?;
Ok(creds)
}
@@ -30,6 +34,7 @@ pub async fn logout() -> crate::Result<()> {
if let Some(current) = current {
ModrinthCredentials::remove(&current.user_id, &state.pool).await?;
state.friends_socket.disconnect().await?;
}
Ok(())

5
packages/app-lib/src/api/pack/install_from.rs
View File

@@ -44,11 +44,11 @@ pub enum PackFileHash {
impl From<String> for PackFileHash {
fn from(s: String) -> Self {
return match s.as_str() {
match s.as_str() {
"sha1" => PackFileHash::Sha1,
"sha512" => PackFileHash::Sha512,
_ => PackFileHash::Unknown(s),
};
}
}
}
@@ -324,7 +324,6 @@ pub async fn generate_pack_from_file(
/// Sets generated profile attributes to the pack ones (using profile::edit)
/// This includes the pack name, icon, game version, loader version, and loader
pub async fn set_profile_information(
profile_path: String,
description: &CreatePackDescription,

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

@@ -25,7 +25,6 @@ use super::install_from::{
/// Wrapper around install_pack_files that generates a pack creation description, and
/// attempts to install the pack files. If it fails, it will remove the profile (fail safely)
/// Install a modpack from a mrpack file (a modrinth .zip format)
pub async fn install_zipped_mrpack(
location: CreatePackLocation,
profile_path: String,
@@ -68,7 +67,6 @@ pub async fn install_zipped_mrpack(
/// Install all pack files from a description
/// Does not remove the profile if it fails
pub async fn install_zipped_mrpack_files(
create_pack: CreatePack,
ignore_lock: bool,

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

@@ -118,7 +118,7 @@ pub async fn profile_create(
&state.file_watcher,
&state.directories,
)
.await?;
.await;
profile.upsert(&state.pool).await?;

7
packages/app-lib/src/config.rs
View File

@@ -1,6 +1,13 @@
//! Configuration structs
// pub const MODRINTH_URL: &str = "https://staging.modrinth.com/";
// pub const MODRINTH_API_URL: &str = "https://staging-api.modrinth.com/v2/";
// pub const MODRINTH_API_URL_V3: &str = "https://staging-api.modrinth.com/v3/";
pub const MODRINTH_URL: &str = "https://modrinth.com/";
pub const MODRINTH_API_URL: &str = "https://api.modrinth.com/v2/";
pub const MODRINTH_API_URL_V3: &str = "https://api.modrinth.com/v3/";
pub const MODRINTH_SOCKET_URL: &str = "wss://api.modrinth.com/";
pub const META_URL: &str = "https://launcher-meta.modrinth.com/";

18
packages/app-lib/src/event/emit.rs
View File

@@ -1,4 +1,4 @@
use super::LoadingBarId;
use super::{FriendPayload, LoadingBarId};
use crate::event::{
CommandPayload, EventError, LoadingBar, LoadingBarType, ProcessPayloadType,
ProfilePayloadType,
@@ -44,7 +44,6 @@ const CLI_PROGRESS_BAR_TOTAL: u64 = 1000;
/// total is the total amount of work to be done- all emissions will be considered a fraction of this value (should be 1 or 100 for simplicity)
/// title is the title of the loading bar
/// The app will wait for this loading bar to finish before exiting, as it is considered safe.
pub async fn init_loading(
bar_type: LoadingBarType,
total: f64,
@@ -56,7 +55,6 @@ pub async fn init_loading(
/// An unsafe loading bar can be created without adding it to the SafeProcesses list,
/// meaning that the app won't ask to wait for it to finish before exiting.
pub async fn init_loading_unsafe(
bar_type: LoadingBarType,
total: f64,
@@ -298,6 +296,20 @@ pub async fn emit_profile(
Ok(())
}
#[allow(unused_variables)]
pub async fn emit_friend(payload: FriendPayload) -> crate::Result<()> {
#[cfg(feature = "tauri")]
{
let event_state = crate::EventState::get()?;
event_state
.app
.emit("friend", payload)
.map_err(EventError::from)?;
}
Ok(())
}
// loading_join! macro
// loading_join!(key: Option<&LoadingBarId>, total: f64, message: Option<&str>; task1, task2, task3...)
// This will submit a loading event with the given message for each task as they complete

11
packages/app-lib/src/event/mod.rs
View File

@@ -1,4 +1,5 @@
//! Theseus state management system
use crate::state::UserStatus;
use dashmap::DashMap;
use serde::{Deserialize, Serialize};
use std::{path::PathBuf, sync::Arc};
@@ -256,3 +257,13 @@ pub enum EventError {
#[error("Tauri error: {0}")]
TauriError(#[from] tauri::Error),
}
#[derive(Serialize, Clone)]
#[serde(rename_all = "snake_case")]
#[serde(tag = "event")]
pub enum FriendPayload {
FriendRequest { from: String },
UserOffline { id: String },
StatusUpdate { user_status: UserStatus },
StatusSync,
}

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

@@ -681,6 +681,11 @@ pub async fn launch_minecraft(
.set_activity(&format!("{} {}", selected_phrase, profile.name), true)
.await;
let _ = state
.friends_socket
.update_status(Some(profile.name.clone()))
.await;
// Create Minecraft child by inserting it into the state
// This also spawns the process and prepares the subsequent processes
state

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

@@ -474,7 +474,11 @@ impl CacheValue {
| CacheValue::DonationPlatforms(_) => DEFAULT_ID.to_string(),
CacheValue::FileHash(hash) => {
format!("{}-{}", hash.size, hash.path.replace(".disabled", ""))
format!(
"{}-{}",
hash.size,
hash.path.trim_end_matches(".disabled")
)
}
CacheValue::FileUpdate(hash) => {
format!("{}-{}-{}", hash.hash, hash.loader, hash.game_version)

13
packages/app-lib/src/state/db.rs
View File

@@ -1,7 +1,11 @@
use crate::state::DirectoryInfo;
use sqlx::migrate::MigrateDatabase;
use sqlx::sqlite::SqlitePoolOptions;
use sqlx::sqlite::{
SqliteConnectOptions, SqliteJournalMode, SqlitePoolOptions,
};
use sqlx::{Pool, Sqlite};
use std::str::FromStr;
use std::time::Duration;
pub(crate) async fn connect() -> crate::Result<Pool<Sqlite>> {
let settings_dir = DirectoryInfo::get_initial_settings_dir().ok_or(
@@ -20,9 +24,14 @@ pub(crate) async fn connect() -> crate::Result<Pool<Sqlite>> {
Sqlite::create_database(&uri).await?;
}
let conn_options = SqliteConnectOptions::from_str(&uri)?
.busy_timeout(Duration::from_secs(30))
.journal_mode(SqliteJournalMode::Wal)
.optimize_on_close(true, None);
let pool = SqlitePoolOptions::new()
.max_connections(100)
.connect(&uri)
.connect_with(conn_options)
.await?;
sqlx::migrate!().run(&pool).await?;

349
packages/app-lib/src/state/friends.rs Normal file
View File

@@ -0,0 +1,349 @@
use crate::config::{MODRINTH_API_URL_V3, MODRINTH_SOCKET_URL};
use crate::data::ModrinthCredentials;
use crate::event::emit::emit_friend;
use crate::event::FriendPayload;
use crate::state::{ProcessManager, Profile};
use crate::util::fetch::{fetch_advanced, fetch_json, FetchSemaphore};
use async_tungstenite::tokio::{connect_async, ConnectStream};
use async_tungstenite::tungstenite::client::IntoClientRequest;
use async_tungstenite::tungstenite::Message;
use async_tungstenite::WebSocketStream;
use chrono::{DateTime, Utc};
use dashmap::DashMap;
use futures::stream::SplitSink;
use futures::{SinkExt, StreamExt};
use reqwest::header::HeaderValue;
use reqwest::Method;
use serde::{Deserialize, Serialize};
use std::sync::Arc;
use tokio::sync::RwLock;
type WriteSocket =
Arc<RwLock<Option<SplitSink<WebSocketStream<ConnectStream>, Message>>>>;
pub struct FriendsSocket {
write: WriteSocket,
user_statuses: Arc<DashMap<String, UserStatus>>,
}
#[derive(Deserialize, Serialize)]
pub struct UserFriend {
pub id: String,
pub friend_id: String,
pub accepted: bool,
pub created: DateTime<Utc>,
}
#[derive(Serialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum ClientToServerMessage {
StatusUpdate { profile_name: Option<String> },
}
#[derive(Deserialize, Debug)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum ServerToClientMessage {
StatusUpdate { status: UserStatus },
UserOffline { id: String },
FriendStatuses { statuses: Vec<UserStatus> },
FriendRequest { from: String },
}
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct UserStatus {
pub user_id: String,
pub profile_name: Option<String>,
pub last_update: DateTime<Utc>,
}
impl Default for FriendsSocket {
fn default() -> Self {
Self::new()
}
}
impl FriendsSocket {
pub fn new() -> Self {
Self {
write: Arc::new(RwLock::new(None)),
user_statuses: Arc::new(DashMap::new()),
}
}
#[tracing::instrument(skip_all)]
pub async fn connect(
&self,
exec: impl sqlx::Executor<'_, Database = sqlx::Sqlite> + Copy,
semaphore: &FetchSemaphore,
process_manager: &ProcessManager,
) -> crate::Result<()> {
let credentials =
ModrinthCredentials::get_and_refresh(exec, semaphore).await?;
if let Some(credentials) = credentials {
let mut request = format!(
"{MODRINTH_SOCKET_URL}_internal/launcher_socket?code={}",
credentials.session
)
.into_client_request()?;
let user_agent = format!(
"modrinth/theseus/{} (support@modrinth.com)",
env!("CARGO_PKG_VERSION")
);
request.headers_mut().insert(
"User-Agent",
HeaderValue::from_str(&user_agent).unwrap(),
);
let res = connect_async(request).await;
match res {
Ok((socket, _)) => {
tracing::info!("Connected to friends socket");
let (write, read) = socket.split();
{
let mut write_lock = self.write.write().await;
*write_lock = Some(write);
}
if let Some(process) = process_manager.get_all().first() {
let profile =
Profile::get(&process.profile_path, exec).await?;
if let Some(profile) = profile {
let _ =
self.update_status(Some(profile.name)).await;
}
}
let write_handle = self.write.clone();
let statuses = self.user_statuses.clone();
tokio::spawn(async move {
let mut read_stream = read;
while let Some(msg_result) = read_stream.next().await {
match msg_result {
Ok(msg) => {
let server_message = match msg {
Message::Text(text) => {
serde_json::from_str::<
ServerToClientMessage,
>(
&text
)
.ok()
}
Message::Binary(bytes) => {
serde_json::from_slice::<
ServerToClientMessage,
>(
&bytes
)
.ok()
}
Message::Ping(bytes) => {
if let Some(write) = write_handle
.write()
.await
.as_mut()
{
let _ = write
.send(Message::Pong(bytes))
.await;
}
continue;
}
Message::Pong(_)
| Message::Frame(_) => continue,
Message::Close(_) => break,
};
if let Some(server_message) = server_message
{
match server_message {
ServerToClientMessage::StatusUpdate { status } => {
statuses.insert(status.user_id.clone(), status.clone());
let _ = emit_friend(FriendPayload::StatusUpdate { user_status: status }).await;
},
ServerToClientMessage::UserOffline { id } => {
statuses.remove(&id);
let _ = emit_friend(FriendPayload::UserOffline { id }).await;
}
ServerToClientMessage::FriendStatuses { statuses: new_statuses } => {
statuses.clear();
new_statuses.into_iter().for_each(|status| {
statuses.insert(status.user_id.clone(), status);
});
let _ = emit_friend(FriendPayload::StatusSync).await;
}
ServerToClientMessage::FriendRequest { from } => {
let _ = emit_friend(FriendPayload::FriendRequest { from }).await;
}
}
}
}
Err(e) => {
tracing::error!("Error handling message from websocket server: {:?}", e);
}
}
}
let mut w = write_handle.write().await;
*w = None;
});
}
Err(e) => {
tracing::error!(
"Error connecting to friends socket: {e:?}"
);
return Err(crate::Error::from(e));
}
}
}
Ok(())
}
#[tracing::instrument(skip_all)]
pub async fn socket_loop() -> crate::Result<()> {
let state = crate::State::get().await?;
tokio::task::spawn(async move {
let mut last_connection = Utc::now();
let mut last_ping = Utc::now();
loop {
let connected = {
let read = state.friends_socket.write.read().await;
read.is_some()
};
if !connected
&& Utc::now().signed_duration_since(last_connection)
> chrono::Duration::seconds(30)
{
last_connection = Utc::now();
last_ping = Utc::now();
let _ = state
.friends_socket
.connect(
&state.pool,
&state.api_semaphore,
&state.process_manager,
)
.await;
} else if connected
&& Utc::now().signed_duration_since(last_ping)
> chrono::Duration::seconds(10)
{
last_ping = Utc::now();
let mut write = state.friends_socket.write.write().await;
if let Some(write) = write.as_mut() {
let _ = write.send(Message::Ping(Vec::new())).await;
}
}
tokio::time::sleep(std::time::Duration::from_secs(1)).await;
}
});
Ok(())
}
#[tracing::instrument(skip(self))]
pub async fn disconnect(&self) -> crate::Result<()> {
let mut write_lock = self.write.write().await;
if let Some(ref mut write_half) = *write_lock {
write_half.close().await?;
*write_lock = None;
}
Ok(())
}
#[tracing::instrument(skip(self))]
pub async fn update_status(
&self,
profile_name: Option<String>,
) -> crate::Result<()> {
let mut write_lock = self.write.write().await;
if let Some(ref mut write_half) = *write_lock {
write_half
.send(Message::Text(serde_json::to_string(
&ClientToServerMessage::StatusUpdate { profile_name },
)?))
.await?;
}
Ok(())
}
#[tracing::instrument(skip_all)]
pub async fn friends(
exec: impl sqlx::Executor<'_, Database = sqlx::Sqlite> + Copy,
semaphore: &FetchSemaphore,
) -> crate::Result<Vec<UserFriend>> {
fetch_json(
Method::GET,
&format!("{MODRINTH_API_URL_V3}friends"),
None,
None,
semaphore,
exec,
)
.await
}
#[tracing::instrument(skip(self))]
pub fn friend_statuses(&self) -> Vec<UserStatus> {
self.user_statuses
.iter()
.map(|x| x.value().clone())
.collect()
}
#[tracing::instrument(skip(exec, semaphore))]
pub async fn add_friend(
user_id: &str,
exec: impl sqlx::Executor<'_, Database = sqlx::Sqlite> + Copy,
semaphore: &FetchSemaphore,
) -> crate::Result<()> {
fetch_advanced(
Method::POST,
&format!("{MODRINTH_API_URL_V3}friend/{user_id}"),
None,
None,
None,
None,
semaphore,
exec,
)
.await?;
Ok(())
}
#[tracing::instrument(skip(exec, semaphore))]
pub async fn remove_friend(
user_id: &str,
exec: impl sqlx::Executor<'_, Database = sqlx::Sqlite> + Copy,
semaphore: &FetchSemaphore,
) -> crate::Result<()> {
fetch_advanced(
Method::DELETE,
&format!("{MODRINTH_API_URL_V3}friend/{user_id}"),
None,
None,
None,
None,
semaphore,
exec,
)
.await?;
Ok(())
}
}

26
packages/app-lib/src/state/fs_watcher.rs
View File

@@ -87,7 +87,7 @@ pub async fn init_watcher() -> crate::Result<FileWatcher> {
pub(crate) async fn watch_profiles_init(
watcher: &FileWatcher,
dirs: &DirectoryInfo,
) -> crate::Result<()> {
) {
if let Ok(profiles_dir) = std::fs::read_dir(dirs.profiles_dir()) {
for profile_dir in profiles_dir {
if let Ok(file_name) = profile_dir.map(|x| x.file_name()) {
@@ -96,20 +96,18 @@ pub(crate) async fn watch_profiles_init(
continue;
};
watch_profile(file_name, watcher, dirs).await?;
watch_profile(file_name, watcher, dirs).await;
}
}
}
}
Ok(())
}
pub(crate) async fn watch_profile(
profile_path: &str,
watcher: &FileWatcher,
dirs: &DirectoryInfo,
) -> crate::Result<()> {
) {
let profile_path = dirs.profiles_dir().join(profile_path);
if profile_path.exists() && profile_path.is_dir() {
@@ -120,15 +118,25 @@ pub(crate) async fn watch_profile(
let path = profile_path.join(folder);
if !path.exists() && !path.is_symlink() {
crate::util::io::create_dir_all(&path).await?;
if let Err(e) = crate::util::io::create_dir_all(&path).await {
tracing::error!(
"Failed to create directory for watcher {path:?}: {e}"
);
return;
}
}
let mut watcher = watcher.write().await;
watcher.watcher().watch(&path, RecursiveMode::Recursive)?;
if let Err(e) =
watcher.watcher().watch(&path, RecursiveMode::Recursive)
{
tracing::error!(
"Failed to watch directory for watcher {path:?}: {e}"
);
return;
}
}
}
Ok(())
}
fn crash_task(path: String) {

34
packages/app-lib/src/state/mod.rs
View File

@@ -31,6 +31,9 @@ pub use self::minecraft_auth::*;
mod cache;
pub use self::cache::*;
mod friends;
pub use self::friends::*;
pub mod db;
pub mod fs_watcher;
mod mr_auth;
@@ -60,6 +63,9 @@ pub struct State {
/// Process manager
pub process_manager: ProcessManager,
/// Friends socket
pub friends_socket: FriendsSocket,
pub(crate) pool: SqlitePool,
pub(crate) file_watcher: FileWatcher,
@@ -81,6 +87,16 @@ impl State {
if let Err(e) = res {
tracing::error!("Error running discord RPC: {e}");
}
let _ = state
.friends_socket
.connect(
&state.pool,
&state.api_semaphore,
&state.process_manager,
)
.await;
let _ = FriendsSocket::socket_loop().await;
});
Ok(())
@@ -89,7 +105,10 @@ impl State {
/// Get the current launcher state, waiting for initialization
pub async fn get() -> crate::Result<Arc<Self>> {
if !LAUNCHER_STATE.initialized() {
while !LAUNCHER_STATE.initialized() {}
tracing::error!("Attempted to get state before it is initialized - this should never happen!");
while !LAUNCHER_STATE.initialized() {
tokio::time::sleep(std::time::Duration::from_millis(100)).await;
}
}
Ok(Arc::clone(
@@ -103,10 +122,12 @@ impl State {
#[tracing::instrument]
async fn initialize_state() -> crate::Result<Arc<Self>> {
tracing::info!("Connecting to app database");
let pool = db::connect().await?;
legacy_converter::migrate_legacy_data(&pool).await?;
tracing::info!("Fetching app settings");
let mut settings = Settings::get(&pool).await?;
let fetch_semaphore =
@@ -116,6 +137,7 @@ impl State {
let api_semaphore =
FetchSemaphore(Semaphore::new(settings.max_concurrent_downloads));
tracing::info!("Initializing directories");
DirectoryInfo::move_launcher_directory(
&mut settings,
&pool,
@@ -126,8 +148,13 @@ impl State {
let discord_rpc = DiscordGuard::init()?;
tracing::info!("Initializing file watcher");
let file_watcher = fs_watcher::init_watcher().await?;
fs_watcher::watch_profiles_init(&file_watcher, &directories).await?;
fs_watcher::watch_profiles_init(&file_watcher, &directories).await;
let process_manager = ProcessManager::new();
let friends_socket = FriendsSocket::new();
Ok(Arc::new(Self {
directories,
@@ -135,7 +162,8 @@ impl State {
io_semaphore,
api_semaphore,
discord_rpc,
process_manager: ProcessManager::new(),
process_manager,
friends_socket,
pool,
file_watcher,
}))

6
packages/app-lib/src/state/mr_auth.rs
View File

@@ -1,4 +1,4 @@
use crate::config::MODRINTH_API_URL;
use crate::config::{MODRINTH_API_URL, MODRINTH_URL};
use crate::state::{CacheBehaviour, CachedEntry};
use crate::util::fetch::{fetch_advanced, FetchSemaphore};
use chrono::{DateTime, Duration, TimeZone, Utc};
@@ -190,8 +190,8 @@ impl ModrinthCredentials {
}
}
pub fn get_login_url() -> &'static str {
"https:/modrinth.com/auth/sign-in?launcher=true"
pub fn get_login_url() -> String {
format!("{MODRINTH_URL}auth/sign-in?launcher=true")
}
pub async fn finish_login_flow(

2
packages/app-lib/src/state/process.rs
View File

@@ -206,6 +206,8 @@ impl Process {
let _ = state.discord_rpc.clear_to_default(true).await;
let _ = state.friends_socket.update_status(None).await;
// If in tauri, window should show itself again after process exists if it was hidden
#[cfg(feature = "tauri")]
{

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

@@ -193,7 +193,7 @@ impl ProjectType {
ProjectType::Mod => "mod",
ProjectType::DataPack => "datapack",
ProjectType::ResourcePack => "resourcepack",
ProjectType::ShaderPack => "shaderpack",
ProjectType::ShaderPack => "shader",
}
}
@@ -664,7 +664,7 @@ impl Profile {
path: format!(
"{}/{folder}/{}",
self.path,
file_name.replace(".disabled", "")
file_name.trim_end_matches(".disabled")
),
file_name: file_name.to_string(),
project_type,
@@ -725,8 +725,9 @@ impl Profile {
let info_index = file_info.iter().position(|x| x.hash == hash.hash);
let file = info_index.map(|x| file_info.remove(x));
if let Some(initial_file_index) =
keys.iter().position(|x| x.path == hash.path)
if let Some(initial_file_index) = keys
.iter()
.position(|x| x.path == hash.path.trim_end_matches(".disabled"))
{
let initial_file = keys.remove(initial_file_index);
@@ -890,7 +891,7 @@ impl Profile {
let path = crate::api::profile::get_full_path(profile_path).await?;
let new_path = if project_path.ends_with(".disabled") {
project_path.replace(".disabled", "")
project_path.trim_end_matches(".disabled").to_string()
} else {
format!("{project_path}.disabled")
};

35
packages/app-lib/src/state/settings.rs
View File

@@ -1,5 +1,7 @@
//! Theseus settings file
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
// Types
/// Global Theseus settings
@@ -13,10 +15,10 @@ pub struct Settings {
pub collapsed_navigation: bool,
pub advanced_rendering: bool,
pub native_decorations: bool,
pub toggle_sidebar: bool,
pub telemetry: bool,
pub discord_rpc: bool,
pub developer_mode: bool,
pub personalized_ads: bool,
pub onboarded: bool,
@@ -32,6 +34,16 @@ pub struct Settings {
pub custom_dir: Option<String>,
pub prev_custom_dir: Option<String>,
pub migrated: bool,
pub developer_mode: bool,
pub feature_flags: HashMap<FeatureFlag, bool>,
}
#[derive(Serialize, Deserialize, Debug, Clone, Copy, Eq, Hash, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum FeatureFlag {
PagePath,
ProjectBackground,
}
impl Settings {
@@ -48,7 +60,7 @@ impl Settings {
json(extra_launch_args) extra_launch_args, json(custom_env_vars) custom_env_vars,
mc_memory_max, mc_force_fullscreen, mc_game_resolution_x, mc_game_resolution_y, hide_on_process_start,
hook_pre_launch, hook_wrapper, hook_post_exit,
custom_dir, prev_custom_dir, migrated
custom_dir, prev_custom_dir, migrated, json(feature_flags) feature_flags, toggle_sidebar
FROM settings
"
)
@@ -63,6 +75,7 @@ impl Settings {
collapsed_navigation: res.collapsed_navigation == 1,
advanced_rendering: res.advanced_rendering == 1,
native_decorations: res.native_decorations == 1,
toggle_sidebar: res.toggle_sidebar == 1,
telemetry: res.telemetry == 1,
discord_rpc: res.discord_rpc == 1,
developer_mode: res.developer_mode == 1,
@@ -95,6 +108,11 @@ impl Settings {
custom_dir: res.custom_dir,
prev_custom_dir: res.prev_custom_dir,
migrated: res.migrated == 1,
feature_flags: res
.feature_flags
.as_ref()
.and_then(|x| serde_json::from_str(x).ok())
.unwrap_or_default(),
})
}
@@ -108,6 +126,7 @@ impl Settings {
let default_page = self.default_page.as_str();
let extra_launch_args = serde_json::to_string(&self.extra_launch_args)?;
let custom_env_vars = serde_json::to_string(&self.custom_env_vars)?;
let feature_flags = serde_json::to_string(&self.feature_flags)?;
sqlx::query!(
"
@@ -143,7 +162,10 @@ impl Settings {
custom_dir = $23,
prev_custom_dir = $24,
migrated = $25
migrated = $25,
toggle_sidebar = $26,
feature_flags = $27
",
max_concurrent_writes,
max_concurrent_downloads,
@@ -169,7 +191,9 @@ impl Settings {
self.hooks.post_exit,
self.custom_dir,
self.prev_custom_dir,
self.migrated
self.migrated,
self.toggle_sidebar,
feature_flags
)
.execute(exec)
.await?;
@@ -185,6 +209,7 @@ pub enum Theme {
Dark,
Light,
Oled,
System,
}
impl Theme {
@@ -193,6 +218,7 @@ impl Theme {
Theme::Dark => "dark",
Theme::Light => "light",
Theme::Oled => "oled",
Theme::System => "system",
}
}
@@ -201,6 +227,7 @@ impl Theme {
"dark" => Theme::Dark,
"light" => Theme::Light,
"oled" => Theme::Oled,
"system" => Theme::System,
_ => Theme::Dark,
}
}

19
packages/app-lib/src/util/fetch.rs
View File

@@ -112,6 +112,19 @@ pub async fn fetch_advanced(
let result = req.send().await;
match result {
Ok(x) => {
if x.status().is_server_error() {
if attempt <= FETCH_ATTEMPTS {
continue;
} else {
return Err(crate::Error::from(
crate::ErrorKind::OtherError(
"Server error when fetching content"
.to_string(),
),
));
}
}
let bytes = if let Some((bar, total)) = &loading_bar {
let length = x.content_length();
if let Some(total_size) = length {
@@ -145,7 +158,7 @@ pub async fn fetch_advanced(
if let Some(sha1) = sha1 {
let hash = sha1_async(bytes.clone()).await?;
if &*hash != sha1 {
if attempt <= 3 {
if attempt <= FETCH_ATTEMPTS {
continue;
} else {
return Err(crate::ErrorKind::HashError(
@@ -159,13 +172,13 @@ pub async fn fetch_advanced(
tracing::trace!("Done downloading URL {url}");
return Ok(bytes);
} else if attempt <= 3 {
} else if attempt <= FETCH_ATTEMPTS {
continue;
} else if let Err(err) = bytes {
return Err(err.into());
}
}
Err(_) if attempt <= 3 => continue,
Err(_) if attempt <= FETCH_ATTEMPTS => continue,
Err(err) => {
return Err(err.into());
}