Implement better error system and segregate errors and commands (#23)

* chore: Progress on amend_settings command Signed-off-by: quexeky <git@quexeky.dev> * chore(errors): Progress on better error handling with segragation of files * chore: Progress on amend_settings command Signed-off-by: quexeky <git@quexeky.dev> * chore(commands): Separated commands under each subdirectory into respective commands.rs files Signed-off-by: quexeky <git@quexeky.dev> * chore(errors): Almost all errors and commands have been segregated * chore(errors): Added drop server error Signed-off-by: quexeky <git@quexeky.dev> * feat(core): Update to using nightly compiler Signed-off-by: quexeky <git@quexeky.dev> * chore(errors): More progress on error handling Signed-off-by: quexeky <git@quexeky.dev> * chore(errors): Implementing Try and FromResidual for UserValue Signed-off-by: quexeky <git@quexeky.dev> * refactor(errors): Segregated errors and commands from code, and made commands return UserValue struct Signed-off-by: quexeky <git@quexeky.dev> * fix(errors): Added missing files * chore(errors): Convert match statement to map_err * feat(settings): Implemented settings editing from UI * feat(errors): Clarified return values from retry_connect command * chore(errors): Moved autostart commands to autostart.rs * chore(process manager): Converted launch_process function for games to use game_id --------- Signed-off-by: quexeky <git@quexeky.dev>
2025-01-13 21:44:57 +11:00
parent fd3e539205
commit f1bba5cc74
45 changed files with 822 additions and 600 deletions
@@ -0,0 +1,202 @@
+use std::{
+    collections::HashMap,
+    fs::{self, create_dir_all},
+    path::{Path, PathBuf},
+    sync::{LazyLock, Mutex, RwLockWriteGuard},
+};
+
+use chrono::Utc;
+use directories::BaseDirs;
+use log::{debug, info};
+use rustbreak::{DeSerError, DeSerializer, PathDatabase, RustbreakError};
+use serde::{de::DeserializeOwned, Deserialize, Serialize};
+use serde_with::serde_as;
+use tauri::AppHandle;
+use url::Url;
+
+use crate::{
+    database::settings::Settings,
+    download_manager::downloadable_metadata::DownloadableMetadata,
+    games::{library::push_game_update, state::GameStatusManager},
+    process::process_manager::Platform,
+    DB,
+};
+
+#[derive(serde::Serialize, Clone, Deserialize)]
+pub struct DatabaseAuth {
+    pub private: String,
+    pub cert: String,
+    pub client_id: String,
+}
+
+// Strings are version names for a particular game
+#[derive(Serialize, Clone, Deserialize)]
+#[serde(tag = "type")]
+pub enum GameDownloadStatus {
+    Remote {},
+    SetupRequired {
+        version_name: String,
+        install_dir: String,
+    },
+    Installed {
+        version_name: String,
+        install_dir: String,
+    },
+}
+
+// Stuff that shouldn't be synced to disk
+#[derive(Clone, Serialize)]
+pub enum ApplicationTransientStatus {
+    Downloading { version_name: String },
+    Uninstalling {},
+    Updating { version_name: String },
+    Running {},
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct GameVersion {
+    pub version_index: usize,
+    pub version_name: String,
+    pub launch_command: String,
+    pub setup_command: String,
+    pub platform: Platform,
+}
+
+#[serde_as]
+#[derive(Serialize, Clone, Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct DatabaseApplications {
+    pub install_dirs: Vec<PathBuf>,
+    // Guaranteed to exist if the game also exists in the app state map
+    pub game_statuses: HashMap<String, GameDownloadStatus>,
+    pub game_versions: HashMap<String, HashMap<String, GameVersion>>,
+    pub installed_game_version: HashMap<String, DownloadableMetadata>,
+
+    #[serde(skip)]
+    pub transient_statuses: HashMap<DownloadableMetadata, ApplicationTransientStatus>,
+}
+
+#[derive(Serialize, Deserialize, Clone, Default)]
+pub struct Database {
+    #[serde(default)]
+    pub settings: Settings,
+    pub auth: Option<DatabaseAuth>,
+    pub base_url: String,
+    pub applications: DatabaseApplications,
+    pub prev_database: Option<PathBuf>,
+}
+impl Database {
+    fn new<T: Into<PathBuf>>(games_base_dir: T, prev_database: Option<PathBuf>) -> Self {
+        Self {
+            applications: DatabaseApplications {
+                install_dirs: vec![games_base_dir.into()],
+                ..Default::default()
+            },
+            prev_database,
+            ..Default::default()
+        }
+    }
+}
+pub static DATA_ROOT_DIR: LazyLock<Mutex<PathBuf>> =
+    LazyLock::new(|| Mutex::new(BaseDirs::new().unwrap().data_dir().join("drop")));
+
+// Custom JSON serializer to support everything we need
+#[derive(Debug, Default, Clone)]
+pub struct DropDatabaseSerializer;
+
+impl<T: Serialize + DeserializeOwned> DeSerializer<T> for DropDatabaseSerializer {
+    fn serialize(&self, val: &T) -> rustbreak::error::DeSerResult<Vec<u8>> {
+        serde_json::to_vec(val).map_err(|e| DeSerError::Internal(e.to_string()))
+    }
+
+    fn deserialize<R: std::io::Read>(&self, s: R) -> rustbreak::error::DeSerResult<T> {
+        serde_json::from_reader(s).map_err(|e| DeSerError::Internal(e.to_string()))
+    }
+}
+
+pub type DatabaseInterface =
+    rustbreak::Database<Database, rustbreak::backend::PathBackend, DropDatabaseSerializer>;
+
+pub trait DatabaseImpls {
+    fn set_up_database() -> DatabaseInterface;
+    fn database_is_set_up(&self) -> bool;
+    fn fetch_base_url(&self) -> Url;
+}
+impl DatabaseImpls for DatabaseInterface {
+    fn set_up_database() -> DatabaseInterface {
+        let data_root_dir = DATA_ROOT_DIR.lock().unwrap();
+        let db_path = data_root_dir.join("drop.db");
+        let games_base_dir = data_root_dir.join("games");
+        let logs_root_dir = data_root_dir.join("logs");
+
+        debug!("Creating data directory at {:?}", data_root_dir);
+        create_dir_all(data_root_dir.clone()).unwrap();
+        create_dir_all(games_base_dir.clone()).unwrap();
+        create_dir_all(logs_root_dir.clone()).unwrap();
+
+        let exists = fs::exists(db_path.clone()).unwrap();
+
+        match exists {
+            true => match PathDatabase::load_from_path(db_path.clone()) {
+                Ok(db) => db,
+                Err(e) => handle_invalid_database(e, db_path, games_base_dir),
+            },
+            false => {
+                let default = Database::new(games_base_dir, None);
+                debug!(
+                    "Creating database at path {}",
+                    db_path.as_os_str().to_str().unwrap()
+                );
+                PathDatabase::create_at_path(db_path, default)
+                    .expect("Database could not be created")
+            }
+        }
+    }
+
+    fn database_is_set_up(&self) -> bool {
+        !self.borrow_data().unwrap().base_url.is_empty()
+    }
+
+    fn fetch_base_url(&self) -> Url {
+        let handle = self.borrow_data().unwrap();
+        Url::parse(&handle.base_url).unwrap()
+    }
+}
+
+pub fn set_game_status<F: FnOnce(&mut RwLockWriteGuard<'_, Database>, &DownloadableMetadata)>(
+    app_handle: &AppHandle,
+    meta: DownloadableMetadata,
+    setter: F,
+) {
+    let mut db_handle = DB.borrow_data_mut().unwrap();
+    setter(&mut db_handle, &meta);
+    drop(db_handle);
+    DB.save().unwrap();
+
+    let status = GameStatusManager::fetch_state(&meta.id);
+
+    push_game_update(app_handle, &meta.id, status);
+}
+// TODO: Make the error relelvant rather than just assume that it's a Deserialize error
+fn handle_invalid_database(
+    _e: RustbreakError,
+    db_path: PathBuf,
+    games_base_dir: PathBuf,
+) -> rustbreak::Database<Database, rustbreak::backend::PathBackend, DropDatabaseSerializer> {
+    let new_path = {
+        let time = Utc::now().timestamp();
+        let mut base = db_path.clone();
+        base.set_file_name(format!("drop.db.backup-{}", time.to_string()));
+        base
+    };
+    info!("{:?}", new_path);
+    fs::rename(&db_path, &new_path).unwrap();
+
+    let db = Database::new(
+        games_base_dir.into_os_string().into_string().unwrap(),
+        Some(new_path.into()),
+    );
+
+    PathDatabase::create_at_path(db_path, db).expect("Database could not be created")
+}