chore: Major refactoring

Still needs a massive go-over because there shouldn't be anything referencing tauri in any of the workspaces except the original one. Process manager has been refactored as an example

Signed-off-by: quexeky <git@quexeky.dev>

process/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "process"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+chrono = "0.4.42"
+client = { version = "0.1.0", path = "../client" }
+database = { version = "0.1.0", path = "../database" }
+dynfmt = "0.1.5"
+games = { version = "0.1.0", path = "../games" }
+log = "0.4.28"
+page_size = "0.6.0"
+serde = "1.0.228"
+serde_with = "3.15.0"
+shared_child = "1.1.1"
+tauri = "2.8.5"
+tauri-plugin-opener = "2.5.0"
+utils = { version = "0.1.0", path = "../utils" }

process/src/error.rs

@@ -0,0 +1,39 @@
+use std::{fmt::Display, io::Error};
+
+use serde_with::SerializeDisplay;
+
+#[derive(SerializeDisplay)]
+pub enum ProcessError {
+    NotInstalled,
+    AlreadyRunning,
+    InvalidID,
+    InvalidVersion,
+    IOError(Error),
+    FormatError(String), // String errors supremacy
+    InvalidPlatform,
+    OpenerError(tauri_plugin_opener::Error),
+    InvalidArguments(String),
+    FailedLaunch(String),
+}
+
+impl Display for ProcessError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let s = match self {
+            ProcessError::NotInstalled => "Game not installed",
+            ProcessError::AlreadyRunning => "Game already running",
+            ProcessError::InvalidID => "Invalid game ID",
+            ProcessError::InvalidVersion => "Invalid game version",
+            ProcessError::IOError(error) => &error.to_string(),
+            ProcessError::InvalidPlatform => "This game cannot be played on the current platform",
+            ProcessError::FormatError(error) => &format!("Could not format template: {error:?}"),
+            ProcessError::OpenerError(error) => &format!("Could not open directory: {error:?}"),
+            ProcessError::InvalidArguments(arguments) => {
+                &format!("Invalid arguments in command {arguments}")
+            }
+            ProcessError::FailedLaunch(game_id) => {
+                &format!("Drop detected that the game {game_id} may have failed to launch properly")
+            }
+        };
+        write!(f, "{s}")
+    }
+}

process/src/format.rs

@@ -0,0 +1,33 @@
+use std::collections::HashMap;
+
+use dynfmt::{Argument, FormatArgs};
+
+pub struct DropFormatArgs {
+    positional: Vec<String>,
+    map: HashMap<&'static str, String>,
+}
+
+impl DropFormatArgs {
+    pub fn new(launch_string: String, working_dir: &String, executable_name: &String, absolute_executable_name: String) -> Self {
+        let mut positional = Vec::new();
+        let mut map: HashMap<&'static str, String> = HashMap::new();
+
+        positional.push(launch_string);
+
+        map.insert("dir", working_dir.to_string());
+        map.insert("exe", executable_name.to_string());
+        map.insert("abs_exe", absolute_executable_name);
+
+        Self { positional, map }
+    }
+}
+
+impl FormatArgs for DropFormatArgs {
+    fn get_index(&self, index: usize) -> Result<Option<dynfmt::Argument<'_>>, ()> {
+        Ok(self.positional.get(index).map(|arg| arg as Argument<'_>))
+    }
+
+    fn get_key(&self, key: &str) -> Result<Option<dynfmt::Argument<'_>>, ()> {
+        Ok(self.map.get(key).map(|arg| arg as Argument<'_>))
+    }
+}

process/src/lib.rs

@@ -0,0 +1,13 @@
+#![feature(nonpoison_mutex)]
+#![feature(sync_nonpoison)]
+
+use std::sync::{LazyLock, nonpoison::Mutex};
+
+use crate::process_manager::ProcessManager;
+
+pub static PROCESS_MANAGER: LazyLock<Mutex<ProcessManager>> =
+    LazyLock::new(|| Mutex::new(ProcessManager::new()));
+pub mod error;
+pub mod format;
+pub mod process_handlers;
+pub mod process_manager;

process/src/process_handlers.rs

@@ -0,0 +1,121 @@
+use std::{
+    ffi::OsStr,
+    path::PathBuf,
+    process::{Command, Stdio},
+    sync::LazyLock,
+};
+
+use client::compat::{COMPAT_INFO, UMU_LAUNCHER_EXECUTABLE};
+use database::{platform::Platform, Database, DownloadableMetadata, GameVersion};
+use log::{debug, info};
+
+
+use crate::{error::ProcessError, process_manager::ProcessHandler};
+
+pub struct NativeGameLauncher;
+impl ProcessHandler for NativeGameLauncher {
+    fn create_launch_process(
+        &self,
+        _meta: &DownloadableMetadata,
+        launch_command: String,
+        args: Vec<String>,
+        _game_version: &GameVersion,
+        _current_dir: &str,
+    ) -> Result<String, ProcessError> {
+        Ok(format!("\"{}\" {}", launch_command, args.join(" ")))
+    }
+
+    fn valid_for_platform(&self, _db: &Database, _target: &Platform) -> bool {
+        true
+    }
+}
+
+pub struct UMULauncher;
+impl ProcessHandler for UMULauncher {
+    fn create_launch_process(
+        &self,
+        _meta: &DownloadableMetadata,
+        launch_command: String,
+        args: Vec<String>,
+        game_version: &GameVersion,
+        _current_dir: &str,
+    ) -> Result<String, ProcessError> {
+        debug!("Game override: \"{:?}\"", &game_version.umu_id_override);
+        let game_id = match &game_version.umu_id_override {
+            Some(game_override) => {
+                if game_override.is_empty() {
+                    game_version.game_id.clone()
+                } else {
+                    game_override.clone()
+                }
+            }
+            None => game_version.game_id.clone(),
+        };
+        Ok(format!(
+            "GAMEID={game_id} {umu:?} \"{launch}\" {args}",
+            umu = UMU_LAUNCHER_EXECUTABLE.as_ref().expect("Failed to get UMU_LAUNCHER_EXECUTABLE as ref"),
+            launch = launch_command,
+            args = args.join(" ")
+        ))
+    }
+
+    fn valid_for_platform(&self, _db: &Database, _target: &Platform) -> bool {
+        let Some(compat_info) = &*COMPAT_INFO else {
+            return false;
+        };
+        compat_info.umu_installed
+    }
+}
+
+pub struct AsahiMuvmLauncher;
+impl ProcessHandler for AsahiMuvmLauncher {
+    fn create_launch_process(
+        &self,
+        meta: &DownloadableMetadata,
+        launch_command: String,
+        args: Vec<String>,
+        game_version: &GameVersion,
+        current_dir: &str,
+    ) -> Result<String, ProcessError> {
+        let umu_launcher = UMULauncher {};
+        let umu_string = umu_launcher.create_launch_process(
+            meta,
+            launch_command,
+            args,
+            game_version,
+            current_dir,
+        )?;
+        let mut args_cmd = umu_string
+            .split("umu-run")
+            .collect::<Vec<&str>>()
+            .into_iter();
+        let args = args_cmd
+            .next()
+            .ok_or(ProcessError::InvalidArguments(umu_string.clone()))?
+            .trim();
+        let cmd = format!("umu-run{}", args_cmd.next().ok_or(ProcessError::InvalidArguments(umu_string.clone()))?);
+
+        Ok(format!("{args} muvm -- {cmd}"))
+    }
+
+    #[allow(unreachable_code)]
+    #[allow(unused_variables)]
+    fn valid_for_platform(&self, _db: &Database, _target: &Platform) -> bool {
+        #[cfg(not(target_os = "linux"))]
+        return false;
+
+        #[cfg(not(target_arch = "aarch64"))]
+        return false;
+
+        let page_size = page_size::get();
+        if page_size != 16384 {
+            return false;
+        }
+
+        let Some(compat_info) = &*COMPAT_INFO else {
+            return false;
+        };
+
+        compat_info.umu_installed
+    }
+}

process/src/process_manager.rs

@@ -0,0 +1,402 @@
+use std::{
+    collections::HashMap,
+    fs::{OpenOptions, create_dir_all},
+    io::{self},
+    path::PathBuf,
+    process::{Command, ExitStatus},
+    str::FromStr,
+    sync::{Arc, Mutex},
+    thread::spawn,
+    time::{Duration, SystemTime},
+};
+
+use database::{borrow_db_checked, borrow_db_mut_checked, db::DATA_ROOT_DIR, platform::Platform, ApplicationTransientStatus, Database, DownloadType, DownloadableMetadata, GameDownloadStatus, GameVersion};
+use dynfmt::Format;
+use dynfmt::SimpleCurlyFormat;
+use games::{library::push_game_update, state::GameStatusManager};
+use log::{debug, info, warn};
+use serde::{Deserialize, Serialize};
+use shared_child::SharedChild;
+use tauri::{AppHandle, Emitter, Manager};
+use tauri_plugin_opener::OpenerExt;
+use utils::lock;
+
+use crate::{error::ProcessError, format::DropFormatArgs, process_handlers::{AsahiMuvmLauncher, NativeGameLauncher, UMULauncher}, PROCESS_MANAGER};
+
+
+pub struct RunningProcess {
+    handle: Arc<SharedChild>,
+    start: SystemTime,
+    manually_killed: bool,
+}
+
+pub struct ProcessManager<'a> {
+    current_platform: Platform,
+    log_output_dir: PathBuf,
+    processes: HashMap<String, RunningProcess>,
+    game_launchers: Vec<(
+        (Platform, Platform),
+        &'a (dyn ProcessHandler + Sync + Send + 'static),
+    )>,
+}
+
+impl ProcessManager<'_> {
+    pub fn new() -> Self {
+        let log_output_dir = DATA_ROOT_DIR.join("logs");
+
+        ProcessManager {
+            #[cfg(target_os = "windows")]
+            current_platform: Platform::Windows,
+
+            #[cfg(target_os = "macos")]
+            current_platform: Platform::MacOs,
+
+            #[cfg(target_os = "linux")]
+            current_platform: Platform::Linux,
+
+            processes: HashMap::new(),
+            log_output_dir,
+            game_launchers: vec![
+                // Current platform to target platform
+                (
+                    (Platform::Windows, Platform::Windows),
+                    &NativeGameLauncher {} as &(dyn ProcessHandler + Sync + Send + 'static),
+                ),
+                (
+                    (Platform::Linux, Platform::Linux),
+                    &NativeGameLauncher {} as &(dyn ProcessHandler + Sync + Send + 'static),
+                ),
+                (
+                    (Platform::MacOs, Platform::MacOs),
+                    &NativeGameLauncher {} as &(dyn ProcessHandler + Sync + Send + 'static),
+                ),
+                (
+                    (Platform::Linux, Platform::Windows),
+                    &AsahiMuvmLauncher {} as &(dyn ProcessHandler + Sync + Send + 'static),
+                ),
+                (
+                    (Platform::Linux, Platform::Windows),
+                    &UMULauncher {} as &(dyn ProcessHandler + Sync + Send + 'static),
+                ),
+            ],
+        }
+    }
+
+    pub fn kill_game(&mut self, game_id: String) -> Result<(), io::Error> {
+        match self.processes.get_mut(&game_id) {
+            Some(process) => {
+                process.manually_killed = true;
+                process.handle.kill()?;
+                process.handle.wait()?;
+                Ok(())
+            }
+            None => Err(io::Error::new(
+                io::ErrorKind::NotFound,
+                "Game ID not running",
+            )),
+        }
+    }
+
+    fn get_log_dir(&self, game_id: String) -> PathBuf {
+        self.log_output_dir.join(game_id)
+    }
+
+    fn on_process_finish(&mut self, game_id: String, result: Result<ExitStatus, std::io::Error>) -> Result<(), ProcessError> {
+        if !self.processes.contains_key(&game_id) {
+            warn!(
+                "process on_finish was called, but game_id is no longer valid. finished with result: {result:?}"
+            );
+            return Ok(());
+        }
+
+        debug!("process for {:?} exited with {:?}", &game_id, result);
+
+        let process = match self.processes.remove(&game_id) {
+            Some(process) => process,
+            None => {
+                info!("Attempted to stop process {game_id} which didn't exist");
+                return Ok(());
+            }
+        };
+
+        let mut db_handle = borrow_db_mut_checked();
+        let meta = db_handle
+            .applications
+            .installed_game_version
+            .get(&game_id)
+            .cloned()
+            .unwrap_or_else(|| panic!("Could not get installed version of {}", &game_id));
+        db_handle.applications.transient_statuses.remove(&meta);
+
+        let current_state = db_handle.applications.game_statuses.get(&game_id).cloned();
+        if let Some(GameDownloadStatus::SetupRequired {
+            version_name,
+            install_dir,
+        }) = current_state
+            && let Ok(exit_code) = result
+            && exit_code.success()
+        {
+            db_handle.applications.game_statuses.insert(
+                game_id.clone(),
+                GameDownloadStatus::Installed {
+                    version_name: version_name.to_string(),
+                    install_dir: install_dir.to_string(),
+                },
+            );
+        }
+
+        let elapsed = process.start.elapsed().unwrap_or(Duration::ZERO);
+        // If we started and ended really quickly, something might've gone wrong
+        // Or if the status isn't 0
+        // Or if it's an error
+        if !process.manually_killed
+            && (elapsed.as_secs() <= 2 || result.map_or(true, |r| !r.success()))
+        {
+            warn!("drop detected that the game {game_id} may have failed to launch properly");
+            return Err(ProcessError::FailedLaunch(game_id));
+            // let _ = self.app_handle.emit("launch_external_error", &game_id);
+        }
+
+        let version_data = match db_handle.applications.game_versions.get(&game_id) {
+            // This unwrap here should be resolved by just making the hashmap accept an option rather than just a String
+            Some(res) => res.get(&meta.version.unwrap()).expect("Failed to get game version from installed game versions. Is the database corrupted?"),
+            None => todo!(),
+        };
+
+        let status = GameStatusManager::fetch_state(&game_id, &db_handle);
+
+        // TODO
+        // push_game_update(
+        //     &self.app_handle,
+        //     &game_id,
+        //     Some(version_data.clone()),
+        //     status,
+        // );
+        Ok(())
+    }
+
+    fn fetch_process_handler(
+        &self,
+        db_lock: &Database,
+        target_platform: &Platform,
+    ) -> Result<&(dyn ProcessHandler + Send + Sync), ProcessError> {
+        Ok(self
+            .game_launchers
+            .iter()
+            .find(|e| {
+                let (e_current, e_target) = e.0;
+                e_current == self.current_platform
+                    && e_target == *target_platform
+                    && e.1.valid_for_platform(db_lock, target_platform)
+            })
+            .ok_or(ProcessError::InvalidPlatform)?
+            .1)
+    }
+
+    pub fn valid_platform(&self, platform: &Platform) -> bool {
+        let db_lock = borrow_db_checked();
+        let process_handler = self.fetch_process_handler(&db_lock, platform);
+        process_handler.is_ok()
+    }
+
+    pub fn launch_process(
+        &mut self,
+        game_id: String,
+    ) -> Result<(), ProcessError> {
+        if self.processes.contains_key(&game_id) {
+            return Err(ProcessError::AlreadyRunning);
+        }
+
+        let version = match borrow_db_checked()
+            .applications
+            .game_statuses
+            .get(&game_id)
+            .cloned()
+        {
+            Some(GameDownloadStatus::Installed { version_name, .. }) => version_name,
+            Some(GameDownloadStatus::SetupRequired { version_name, .. }) => version_name,
+            _ => return Err(ProcessError::NotInstalled),
+        };
+        let meta = DownloadableMetadata {
+            id: game_id.clone(),
+            version: Some(version.clone()),
+            download_type: DownloadType::Game,
+        };
+
+        let mut db_lock = borrow_db_mut_checked();
+
+        let game_status = db_lock
+            .applications
+            .game_statuses
+            .get(&game_id)
+            .ok_or(ProcessError::NotInstalled)?;
+
+        let (version_name, install_dir) = match game_status {
+            GameDownloadStatus::Installed {
+                version_name,
+                install_dir,
+            } => (version_name, install_dir),
+            GameDownloadStatus::SetupRequired {
+                version_name,
+                install_dir,
+            } => (version_name, install_dir),
+            _ => return Err(ProcessError::NotInstalled),
+        };
+
+        debug!(
+            "Launching process {:?} with version {:?}",
+            &game_id,
+            db_lock.applications.game_versions.get(&game_id)
+        );
+
+        let game_version = db_lock
+            .applications
+            .game_versions
+            .get(&game_id)
+            .ok_or(ProcessError::InvalidID)?
+            .get(version_name)
+            .ok_or(ProcessError::InvalidVersion)?;
+
+        // TODO: refactor this path with open_process_logs
+        let game_log_folder = &self.get_log_dir(game_id);
+        create_dir_all(game_log_folder).map_err(ProcessError::IOError)?;
+
+        let current_time = chrono::offset::Local::now();
+        let log_file = OpenOptions::new()
+            .write(true)
+            .truncate(true)
+            .read(true)
+            .create(true)
+            .open(game_log_folder.join(format!("{}-{}.log", &version, current_time.timestamp())))
+            .map_err(ProcessError::IOError)?;
+
+        let error_file = OpenOptions::new()
+            .write(true)
+            .truncate(true)
+            .read(true)
+            .create(true)
+            .open(game_log_folder.join(format!(
+                "{}-{}-error.log",
+                &version,
+                current_time.timestamp()
+            )))
+            .map_err(ProcessError::IOError)?;
+
+        let target_platform = game_version.platform;
+
+        let process_handler = self.fetch_process_handler(&db_lock, &target_platform)?;
+
+        let (launch, args) = match game_status {
+            GameDownloadStatus::Installed {
+                version_name: _,
+                install_dir: _,
+            } => (&game_version.launch_command, &game_version.launch_args),
+            GameDownloadStatus::SetupRequired {
+                version_name: _,
+                install_dir: _,
+            } => (&game_version.setup_command, &game_version.setup_args),
+            GameDownloadStatus::PartiallyInstalled {
+                version_name: _,
+                install_dir: _,
+            } => unreachable!("Game registered as 'Partially Installed'"),
+            GameDownloadStatus::Remote {} => unreachable!("Game registered as 'Remote'"),
+        };
+
+        #[allow(clippy::unwrap_used)]
+        let launch = PathBuf::from_str(install_dir).unwrap().join(launch);
+        let launch = launch.display().to_string();
+
+        let launch_string = process_handler.create_launch_process(
+            &meta,
+            launch.to_string(),
+            args.clone(),
+            game_version,
+            install_dir,
+        )?;
+
+        let format_args = DropFormatArgs::new(
+            launch_string,
+            install_dir,
+            &game_version.launch_command,
+            launch.to_string(),
+        );
+
+        let launch_string = SimpleCurlyFormat
+            .format(&game_version.launch_command_template, format_args)
+            .map_err(|e| ProcessError::FormatError(e.to_string()))?
+            .to_string();
+
+        #[cfg(target_os = "windows")]
+        use std::os::windows::process::CommandExt;
+        #[cfg(target_os = "windows")]
+        let mut command = Command::new("cmd");
+        #[cfg(target_os = "windows")]
+        command.raw_arg(format!("/C \"{}\"", &launch_string));
+
+        info!("launching (in {install_dir}): {launch_string}",);
+
+        #[cfg(unix)]
+        let mut command: Command = Command::new("sh");
+        #[cfg(unix)]
+        command.args(vec!["-c", &launch_string]);
+
+        debug!("final launch string:\n\n{launch_string}\n");
+
+        command
+            .stderr(error_file)
+            .stdout(log_file)
+            .env_remove("RUST_LOG")
+            .current_dir(install_dir);
+
+        let child = command.spawn().map_err(ProcessError::IOError)?;
+
+        let launch_process_handle =
+            Arc::new(SharedChild::new(child).map_err(ProcessError::IOError)?);
+
+        db_lock
+            .applications
+            .transient_statuses
+            .insert(meta.clone(), ApplicationTransientStatus::Running {});
+
+        // TODO
+        // push_game_update(
+        //     &self.app_handle,
+        //     &meta.id,
+        //     None,
+        //     (None, Some(ApplicationTransientStatus::Running {})),
+        // );
+
+        let wait_thread_handle = launch_process_handle.clone();
+        let wait_thread_game_id = meta.clone();
+
+        spawn(move || {
+            let result: Result<ExitStatus, std::io::Error> = launch_process_handle.wait();
+
+
+            PROCESS_MANAGER.lock().on_process_finish(wait_thread_game_id.id, result);
+        });
+
+        self.processes.insert(
+            meta.id,
+            RunningProcess {
+                handle: wait_thread_handle,
+                start: SystemTime::now(),
+                manually_killed: false,
+            },
+        );
+        Ok(())
+    }
+}
+
+pub trait ProcessHandler: Send + 'static {
+    fn create_launch_process(
+        &self,
+        meta: &DownloadableMetadata,
+        launch_command: String,
+        args: Vec<String>,
+        game_version: &GameVersion,
+        current_dir: &str,
+    ) -> Result<String, ProcessError>;
+
+    fn valid_for_platform(&self, db: &Database, target: &Platform) -> bool;
+}