//! Thin Tauri command layer. Every mutating command takes an installation *id* and resolves the path from the //! registry; the frontend can never ask the backend to touch an arbitrary path (scan is read-only). use std::collections::HashSet; use std::path::PathBuf; use std::sync::{Arc, Mutex}; mod browse_preferences; mod docker_install; mod window_preferences; use coa_core::backup::{self, Kind, RecoveryPoint, Trigger, VerifyReport}; use coa_core::config::{self, Scope, SettingsView}; use coa_core::download::Cancel; use coa_core::driver::{self, DriverOutcome, Verb}; use coa_core::error::UiError; use coa_core::install::{self, Preflight, Source}; use coa_core::layout::{self, Classification, ScanReport}; use coa_core::platform::{self, Flavor}; use coa_core::portable::service::{self as portable_service, PortableRuntime, ServiceError}; use coa_core::process::{self, Observed}; use coa_core::ra::Ra; use coa_core::registry::{metadata_dir_for, InstallKind, InstallMeta, MetaDir, Registry}; use coa_core::update::{self, Resolution}; use coa_core::{Error, Result}; use serde::Serialize; use serde_json::Value; use std::collections::BTreeMap; use tauri::{AppHandle, Emitter, Manager, State}; mod control_cmds; /// Informational release notes only; never used to select or authorize an update. #[tauri::command] async fn release_history(component: String, target: Option) -> std::result::Result { tauri::async_runtime::spawn_blocking(move || { coa_core::release_history::load_for_target(&component, &data_dir().join("release-history"), target.as_deref()) }) .await .map_err(|e| e.to_string())? } struct AppState { registry: Registry, /// Installation ids with a start/stop currently running (one action at a time per server). busy: Mutex>, /// Cancel handle of the installation currently running, if any. install_cancel: Mutex>, /// Cancel handle of the game-client check or download currently running, if any. client_cancel: Mutex>, /// The portable play runtime (the Host loop): started with the application, stopped with it. portable: Option>, /// Publishing this Manager's realms to the central Registry (Phase 10): its own loop, independent of Player Mode. realm_registry: Option>, /// The player's side of the control plane (Phase 12): identity, protected credentials, joining servers. control: Option>, /// The host's side: one control link per published realm. host_control: Option>, } /// Starting and stopping the servers this Manager installed, for the portable runtime. struct InstallControl { registry: Registry, } impl InstallControl { fn run(&self, install_id: &str, verb: Verb) -> Result<()> { let root = self .registry .list()? .into_iter() .find(|(i, _)| i == install_id) .map(|(_, p)| p) .ok_or_else(|| Error::UnknownInstallation(install_id.to_string()))?; let out = driver::run(&root, verb)?; if out.ok { Ok(()) } else { Err(Error::Invalid( out.output .lines() .last() .unwrap_or("The server did not answer.") .to_string(), )) } } } impl portable_service::ServerControl for InstallControl { fn stop_all(&self, install_id: &str) -> Result<()> { self.run(install_id, Verb::StopAll) } fn start_database(&self, install_id: &str) -> Result<()> { self.run(install_id, Verb::StartMysql) } fn start_all(&self, install_id: &str) -> Result<()> { self.run(install_id, Verb::StartAll) } } fn runtime(state: &State<'_, AppState>) -> std::result::Result, ServiceError> { state.portable.clone().ok_or_else(|| ServiceError { code: "stopped".into(), message: "The portable play service could not start; see the Manager's log.".into(), notes: vec![], }) } /// Run one action of the portable play service on its own thread without blocking the interface. async fn portable_call( state: &State<'_, AppState>, f: impl FnOnce(&mut portable_service::PortableService) -> std::result::Result + Send + 'static, ) -> std::result::Result { let rt = runtime(state)?; tauri::async_runtime::spawn_blocking(move || rt.call(f)) .await .map_err(|e| ServiceError { code: "other".into(), message: e.to_string(), notes: vec![], })? .and_then(|r| r) } #[tauri::command] fn portable_state(state: State<'_, AppState>) -> portable_service::PortableState { state .portable .as_ref() .map(|r| r.state()) .unwrap_or_default() } #[tauri::command] async fn portable_preflight( state: State<'_, AppState>, character: String, realm: String, ) -> std::result::Result { portable_call(&state, move |s| s.preflight(&character, &realm)).await } #[tauri::command] async fn portable_play( state: State<'_, AppState>, character: String, realm: String, account: Option, ) -> std::result::Result { portable_call(&state, move |s| { s.play(&character, &realm, account.as_deref()) }) .await } #[tauri::command] async fn portable_local_characters( state: State<'_, AppState>, realm: String, ) -> std::result::Result, ServiceError> { portable_call(&state, move |s| s.local_characters(&realm)).await } #[tauri::command] async fn portable_make( state: State<'_, AppState>, realm: String, token: u32, ) -> std::result::Result { portable_call(&state, move |s| s.make_portable(&realm, token)).await } #[tauri::command] async fn portable_resolve( state: State<'_, AppState>, character: String, realm: String, action: portable_service::Resolve, ) -> std::result::Result<(), ServiceError> { portable_call(&state, move |s| s.resolve(&character, &realm, action)).await } #[tauri::command] async fn portable_history( state: State<'_, AppState>, character: String, ) -> std::result::Result, ServiceError> { portable_call(&state, move |s| s.history(&character)).await } #[tauri::command] async fn portable_add_realm( state: State<'_, AppState>, path: String, ) -> std::result::Result { portable_call(&state, move |s| { s.add_prepared_realm(std::path::Path::new(&path)) }) .await } #[tauri::command] async fn portable_remove_realm( state: State<'_, AppState>, realm: String, ) -> std::result::Result<(), ServiceError> { portable_call(&state, move |s| s.remove_prepared_realm(&realm)).await } #[tauri::command] async fn portable_diagnostics( state: State<'_, AppState>, ) -> std::result::Result { portable_call(&state, |s| Ok(s.diagnostics())).await } /// Start the game for a realm that is ready: an installed server uses its own client, any other realm the Player Mode client pointed at /// the realm's address. #[tauri::command] async fn portable_launch( state: State<'_, AppState>, realm: String, ) -> std::result::Result<(), ServiceError> { let realm_launch = realm.clone(); let (install, address) = portable_call(&state, move |s| s.realm_launch_info(&realm_launch)).await?; let other = |e: UiError| ServiceError { code: "launch".into(), message: e.technical, notes: vec![], }; match install { Some(id) => play(state, id).await.map(|_| ()).map_err(other), None => { { let dir = remote_dir(); let mut profile = coa_core::remote_client::load(&dir).map_err(|e| other(e.into()))?; profile.host = address; profile.realm = Some(realm.clone()); coa_core::remote_client::save(&dir, &profile).map_err(|e| other(e.into()))?; if let Some(ref cp) = profile.client_path { if let Ok(pc) = control_cmds::player(&state) { if let Ok(rid) = control_cmds::realm_id(&realm) { if let Ok(Some(creds)) = pc.credentials(&rid) { let _ = coa_core::glue_config::prefill_login( std::path::Path::new(cp), &creds.username, &creds.password, ); } } } } } play(state, REMOTE_CLIENT_ID.to_string()) .await .map(|_| ()) .map_err(other) } } } /// Where official server packages are published (created by the release pipeline, Phase 6). /// Where signed update packages are published; override with COA_UPDATE_SOURCE (URL or local package folder). const DEFAULT_UPDATE_URL: &str = "https://github.com/Corfirean/coa-server-build/releases/download/stable"; fn update_source(custom: Option) -> Result { let pick = custom .filter(|s| !s.trim().is_empty()) .or_else(|| std::env::var("COA_UPDATE_SOURCE").ok()); match pick { Some(p) if p.to_ascii_lowercase().starts_with("http") => Ok(Source::Url(p)), Some(p) => Ok(Source::Dir(PathBuf::from(p))), None => match coa_core::channels::resolve("stable") { Ok(source) => Ok(source), Err(Error::PackageNotPublished(_)) => Ok(Source::Url(DEFAULT_UPDATE_URL.into())), Err(error) => Err(error), }, } } const DEFAULT_PACKAGE_URL: &str = "https://github.com/Corfirean/coa-server-build/releases/download/base"; fn package_source(custom: Option) -> Source { let pick = custom .filter(|s| !s.trim().is_empty()) .or_else(|| std::env::var("COA_PACKAGE_SOURCE").ok()); match pick { Some(p) if p.to_ascii_lowercase().starts_with("http") => Source::Url(p), Some(p) => Source::Dir(PathBuf::from(p)), None => Source::Url(DEFAULT_PACKAGE_URL.into()), } } fn installation_source(custom: Option) -> Result { let custom = custom.filter(|value| !value.trim().is_empty()).or_else(|| { std::env::var("COA_PACKAGE_SOURCE") .ok() .filter(|value| !value.trim().is_empty()) }); select_installation_source(custom, || update_source(None)) } fn select_installation_source( custom: Option, latest: impl FnOnce() -> Result, ) -> Result { if custom.is_some() { return Ok(package_source(custom)); } Ok(Source::Installation(Box::new(latest()?))) } #[cfg(test)] mod installation_source_tests { use super::*; #[test] fn fresh_install_uses_the_selected_current_release_full_image() { let source = select_installation_source(None, || { Ok(Source::Url("https://example.test/releases/current".into())) }).unwrap(); assert!(matches!(source, Source::Installation(inner) if matches!(*inner, Source::Url(ref url) if url.ends_with("/current")))); } #[test] fn unavailable_current_release_does_not_fall_back_to_an_old_base() { let result = select_installation_source(None, || { Err(Error::PackageNotPublished("current unavailable".into())) }); assert!(matches!(result, Err(Error::PackageNotPublished(_)))); } } #[derive(Serialize)] struct ServerSummary { id: String, name: String, path: String, } #[derive(Serialize)] struct StatusView { observed: Observed, busy: bool, path_exists: bool, /// A scheduled restart is under way: a world that is down for a few minutes did not crash. scheduled_restart: bool, } /// Where the Manager keeps its own state (server list, logs). `%LOCALAPPDATA%` on Windows, the XDG data folder elsewhere. fn data_dir() -> PathBuf { // a separate data folder for tests and diagnostics, so that a development build never reads or writes the installed Manager's own state if let Some(dir) = std::env::var_os("COA_MANAGER_DATA_DIR") .map(PathBuf::from) .filter(|p| p.is_absolute()) { return dir; } #[cfg(windows)] let base = std::env::var_os("LOCALAPPDATA") .map(PathBuf::from) .unwrap_or_else(std::env::temp_dir); #[cfg(not(windows))] let base = unix_data_home(std::env::var_os("XDG_DATA_HOME"), std::env::var_os("HOME")); base.join("CoAServerManager") } /// `$XDG_DATA_HOME` when it is an absolute path (the spec says to ignore relative ones), else `~/.local/share`. #[cfg(not(windows))] fn unix_data_home(xdg: Option, home: Option) -> PathBuf { xdg.map(PathBuf::from) .filter(|p| p.is_absolute()) .or_else(|| home.map(|h| PathBuf::from(h).join(".local/share"))) .unwrap_or_else(std::env::temp_dir) } fn path_of(state: &AppState, id: &str) -> Result { state .registry .list()? .into_iter() .find(|(i, _)| i == id) .map(|(_, p)| p) .ok_or_else(|| Error::UnknownInstallation(id.to_string())) } fn summary(id: String, path: PathBuf) -> ServerSummary { let name = path .file_name() .map(|n| n.to_string_lossy().into_owned()) .unwrap_or_else(|| "Server".into()); ServerSummary { id, name, path: path.to_string_lossy().into_owned(), } } /// The game data folder of a Docker server; none for a repack, whose data is inside its own folder. #[tauri::command] fn game_data_folder( state: State<'_, AppState>, id: String, ) -> std::result::Result, UiError> { let root = path_of(&state, &id)?; if !coa_core::docker::is_docker(&root) { return Ok(None); } Ok(Some( coa_core::docker::game_data_dir(&root)? .to_string_lossy() .into_owned(), )) } /// Point a Docker server at another game data folder. The servers must be stopped. #[tauri::command] async fn set_game_data_folder( state: State<'_, AppState>, id: String, path: String, ) -> std::result::Result { let root = path_of(&state, &id)?; let _guard = BusyGuard::acquire(&state, &id)?; blocking(move || { if !coa_core::docker::is_docker(&root) { return Err(Error::Invalid( "The game data of this server is inside its folder.".into(), )); } coa_core::docker::set_game_data(&root, std::path::Path::new(&path))?; Ok(path) }) .await } #[tauri::command] fn default_install_dir() -> String { if platform::flavor() == Flavor::Docker { return docker_install::default_dir(); } "C:\\Games\\CoA Server".into() } /// What the install screen needs to know about this computer: the kind of server it installs, the suggested folder, and /// whether Docker can be used. #[tauri::command] async fn install_environment() -> docker_install::Environment { tauri::async_runtime::spawn_blocking(docker_install::environment) .await .unwrap_or_else(|_| docker_install::Environment { flavor: platform::flavor(), default_dir: default_install_dir(), docker_problem: None, }) } #[tauri::command] async fn scan_server(path: String) -> std::result::Result { tauri::async_runtime::spawn_blocking(move || layout::scan(std::path::Path::new(&path))) .await .map_err(|e| Error::Invalid(e.to_string()))? .map_err(Into::into) } /// Import: writes only `.manager` and the registry entry. The server folder is never modified. #[tauri::command] async fn add_server( state: State<'_, AppState>, path: String, ) -> std::result::Result { let root = PathBuf::from(&path); let report = tauri::async_runtime::spawn_blocking({ let root = root.clone(); move || layout::scan(&root) }) .await .map_err(|e| Error::Invalid(e.to_string()))??; if report.classification == Classification::Incompatible { return Err(Error::Invalid("This folder is not a CoA server folder.".into()).into()); } if let Some(existing) = state.registry.find_by_path(&root)? { return Ok(summary(existing, PathBuf::from(report.path))); } let mut meta = InstallMeta::new(InstallKind::Imported, std::path::Path::new(&report.path)); meta.core.commit = report .release .as_ref() .and_then(|r| r.main_revision.clone()); meta.core.version = report.banner_revision.clone(); meta.database.port = Some(report.ports.mysql); meta.database.schemas = report.database_schemas.clone(); // The executables are `worldserver.exe` in a repack and `worldserver` in a Docker server; the file check reads these names. let exe_names = if coa_core::docker::is_docker(std::path::Path::new(&report.path)) { ("Core/worldserver", "Core/authserver") } else { ("Core/worldserver.exe", "Core/authserver.exe") }; for (rel, exe) in [ (exe_names.0, &report.worldserver), (exe_names.1, &report.authserver), ] { if let Some(e) = exe { meta.original_hashes.insert(rel.into(), e.sha256.clone()); } } let server = PathBuf::from(&report.path); let dir = metadata_dir_for(&server)?; let (meta, _dir) = if dir.join("install.json").is_file() { MetaDir::open(&dir).map(|(d, m)| (m, d))? } else { let d = MetaDir::create(&server, &meta)?; (meta, d) }; state.registry.register(&meta.id, &server)?; tracing::info!(id = %meta.id, path = %server.display(), "server imported (read-only)"); Ok(summary(meta.id, server)) } #[tauri::command] fn list_servers(state: State<'_, AppState>) -> std::result::Result, UiError> { Ok(state .registry .list()? .into_iter() .map(|(id, p)| summary(id, p)) .collect()) } #[tauri::command] fn forget_server(state: State<'_, AppState>, id: String) -> std::result::Result<(), UiError> { // Removes only the registry entry; no files are deleted. Ok(state.registry.unregister(&id)?) } #[tauri::command] async fn server_status( state: State<'_, AppState>, id: String, ) -> std::result::Result { let root = path_of(&state, &id)?; let busy = state.busy.lock().map(|b| b.contains(&id)).unwrap_or(false); let path_exists = root.is_dir(); let (observed, scheduled_restart) = tauri::async_runtime::spawn_blocking(move || { let ports = layout::read_ports(&root); ( process::observe(&root, &ports), coa_core::launcher::schedule::under_way(&root), ) }) .await .map_err(|e| Error::Invalid(e.to_string()))?; Ok(StatusView { observed, busy, path_exists, scheduled_restart, }) } async fn run_verb( state: &AppState, id: String, verb: Verb, ) -> std::result::Result { let root = path_of(state, &id)?; if !state .busy .lock() .map_err(|_| Error::Invalid("state poisoned".into()))? .insert(id.clone()) { return Ok(DriverOutcome { ok: false, exit_code: None, code: Some(coa_core::ErrorCode::OperationInProgress), human: Some(coa_core::ErrorCode::OperationInProgress.human()), output: String::new(), }); } let result = tauri::async_runtime::spawn_blocking(move || driver::run(&root, verb)).await; if let Ok(mut b) = state.busy.lock() { b.remove(&id); } result .map_err(|e| Error::Invalid(e.to_string()))? .map_err(Into::into) } #[tauri::command] async fn start_server( state: State<'_, AppState>, id: String, ) -> std::result::Result { let _guard = BusyGuard::acquire(&state, &id)?; // Servers installed before module configs were created automatically get them now (missing files only). Imported // servers only get the module files they lack (see below); nothing they have is changed. if let Ok(root) = path_of(&state, &id) { let _ = tauri::async_runtime::spawn_blocking(move || { let (_, meta) = install_meta(&root)?; if meta.kind == coa_core::registry::InstallKind::New { coa_core::config::materialize_module_configs(&root)?; } else { // Imported: only the module files that are missing (a module without its file logs every setting it reads). let _ = coa_core::config::create_missing_module_configs(&root); } let dir = meta_dir(&root)?; coa_core::friends::ensure_bind(&root, &dir)?; if meta.kind == coa_core::registry::InstallKind::New { coa_core::config::ensure_performance_defaults(&root, &dir)?; } Ok::<(), Error>(()) }) .await; } let root = path_of(&state, &id)?; let out = blocking(move || driver::run(&root, Verb::StartAll)).await?; if out.ok { if let Ok(root) = path_of(&state, &id) { // Companions requested while the server was stopped are reconciled and created now per realm. let r = root.clone(); let instance_id = id.clone(); let _ = tauri::async_runtime::spawn_blocking(move || -> Result<()> { if coa_core::realms::guard_module(&r, "companions").is_err() { return Ok(()); } let meta = meta_dir(&r)?; if let Err(e) = coa_core::companions::migrate_legacy_pending_job(&meta, &instance_id) { tracing::warn!("failed to migrate legacy pending companions job: {e}"); } for mode in [ coa_core::realms::Mode::Coa, coa_core::realms::Mode::Wildcard, coa_core::realms::Mode::Reborn, ] { let target = match coa_core::multiworld::resolve_bot_operation_target(&r, mode) { Ok(t) => t, Err(e) => { tracing::warn!("cannot resolve target for realm {}: {e}", mode.name()); continue; } }; let r_snap = r.clone(); let chars_db = target.chars_db; let r_ra = r.clone(); let res = coa_core::companions::process_pending_job_with( &meta, mode, &instance_id, target.running, |since_guid| { let admin_db = coa_core::db::Db::from_repack(&r_snap, coa_core::db::Account::Admin)?; let _ = coa_core::companions::ensure_templates_for_schema(&admin_db, chars_db); coa_core::companions::query_bot_db_snapshot(&r_snap, &admin_db, chars_db, since_guid) }, |delta, job| { let mut ra = Ra::connect_target(&r_ra, Some(mode))?; if let Some(lvl) = job.level { ra.spawn_custom(delta, lvl, job.class_id, job.spec_id, job.build_id.as_deref()) } else { ra.spawn_bots(delta) } }, ); if let Err(e) = res { tracing::warn!("pending companions for realm {} failed during reconciliation: {e}", mode.name()); } } Ok(()) }) .await; let _ = tauri::async_runtime::spawn_blocking(move || { let meta = meta_dir(&root)?; coa_core::friends::reapply(&root, &meta)?; // A world switched on after the server was opened to friends has no firewall rule yet. Rules are only // added when missing (one Windows confirmation); a refusal must not undo a start that worked. if platform::flavor() == Flavor::Repack && coa_core::friends::load(&meta).mode != coa_core::friends::Mode::Local { let extra = coa_core::realms::state(&root)?.extra_world_ports(); if let Err(e) = coa_core::firewall::ensure_rules_with_extra( &layout::read_ports(&root), &extra, ) { tracing::warn!("firewall rules for the running worlds were not added: {e}"); } } Ok::<(), Error>(()) }) .await; } } Ok(out) } #[tauri::command] async fn force_stop_server( state: State<'_, AppState>, id: String, ) -> std::result::Result { let root = path_of(&state, &id)?; let _guard = BusyGuard::acquire(&state, &id)?; blocking(move || driver::force_stop(&root)).await } #[tauri::command] async fn stop_server( state: State<'_, AppState>, id: String, ) -> std::result::Result { run_verb(&state, id, Verb::StopAll).await } #[derive(Serialize)] struct PresetInfo { id: String, title: String, description: String, } async fn blocking( f: impl FnOnce() -> Result + Send + 'static, ) -> std::result::Result { tauri::async_runtime::spawn_blocking(f) .await .map_err(|e| Error::Invalid(e.to_string()))? .map_err(Into::into) } fn meta_dir(root: &std::path::Path) -> Result { let dir = metadata_dir_for(root)?; if dir.join("install.json").is_file() { Ok(dir) } else { Err(Error::Invalid( "This server has not been added to the Manager yet.".into(), )) } } #[tauri::command] async fn get_settings( state: State<'_, AppState>, id: String, scope: Scope, ) -> std::result::Result { let root = path_of(&state, &id)?; blocking(move || config::load(&root, scope)).await } #[tauri::command] async fn server_logging_preset( state: State<'_, AppState>, id: String, preset: String, ) -> std::result::Result<(), UiError> { let root = path_of(&state, &id)?; let _guard = BusyGuard::acquire(&state, &id)?; blocking(move || { let meta = meta_dir(&root)?; coa_core::server_logging::apply(&root, &meta, &preset) }).await } #[tauri::command] async fn save_settings( state: State<'_, AppState>, id: String, scope: Scope, changes: BTreeMap, ) -> std::result::Result { let root = path_of(&state, &id)?; let _guard = BusyGuard::acquire(&state, &id)?; blocking(move || { let meta = meta_dir(&root)?; config::save(&root, &meta, scope, &changes) }) .await } #[tauri::command] fn list_presets(scope: Scope) -> Vec { scope .presets() .iter() .map(|p| PresetInfo { id: p.id.clone(), title: p.title.clone(), description: p.description.clone(), }) .collect() } #[tauri::command] async fn preview_preset( state: State<'_, AppState>, id: String, scope: Scope, preset: String, ) -> std::result::Result { let root = path_of(&state, &id)?; blocking(move || { if preset == "defaults" { config::preview_defaults(&root, scope) } else { config::preview_preset(&root, scope, &preset) } }) .await } #[tauri::command] fn list_config_snapshots( state: State<'_, AppState>, id: String, ) -> std::result::Result, UiError> { let root = path_of(&state, &id)?; Ok(config::list_snapshots(&meta_dir(&root)?)) } #[tauri::command] async fn restore_config_snapshot( state: State<'_, AppState>, id: String, snapshot: String, ) -> std::result::Result<(), UiError> { let root = path_of(&state, &id)?; blocking(move || config::restore_snapshot(&meta_dir(&root)?, &snapshot)).await } /// Marks the installation busy for the duration of a long operation, and always clears it. struct BusyGuard<'a> { state: &'a AppState, id: String, } impl<'a> BusyGuard<'a> { fn acquire(state: &'a AppState, id: &str) -> Result { let mut b = state .busy .lock() .map_err(|_| Error::Invalid("state poisoned".into()))?; if !b.insert(id.to_string()) { return Err(Error::Invalid( "Another action is still in progress for this server.".into(), )); } Ok(Self { state, id: id.to_string(), }) } } impl Drop for BusyGuard<'_> { fn drop(&mut self) { if let Ok(mut b) = self.state.busy.lock() { b.remove(&self.id); } } } #[tauri::command] fn backup_location( state: State<'_, AppState>, id: String, ) -> std::result::Result { let root = path_of(&state, &id)?; Ok(backup::location(&meta_dir(&root)?)) } #[tauri::command] async fn set_backup_location( state: State<'_, AppState>, id: String, path: Option, ) -> std::result::Result { let root = path_of(&state, &id)?; blocking(move || backup::set_location(&root, &meta_dir(&root)?, path.as_deref())).await } #[tauri::command] async fn dashboard_status( state: State<'_, AppState>, id: String, ) -> std::result::Result { let root = path_of(&state, &id)?; blocking(move || Ok(coa_core::dashboard::status(&root))).await } #[tauri::command] async fn dashboard_install( app: AppHandle, state: State<'_, AppState>, id: String, ) -> std::result::Result { let root = path_of(&state, &id)?; blocking(move || { coa_core::dashboard::install(&root, &|step| { let _ = app.emit("dashboard-progress", step); }) }) .await } #[tauri::command] async fn dashboard_open( state: State<'_, AppState>, id: String, ) -> std::result::Result<(), UiError> { let root = path_of(&state, &id)?; let status = blocking(move || Ok(coa_core::dashboard::status(&root))).await?; if !status.running { return Err(Error::Invalid("The dashboard is not running.".into()).into()); } tauri_plugin_opener::open_url(&status.url, None::<&str>) .map_err(|e| Error::Invalid(e.to_string()))?; Ok(()) } #[tauri::command] async fn dashboard_start( state: State<'_, AppState>, id: String, ) -> std::result::Result { let root = path_of(&state, &id)?; blocking(move || coa_core::dashboard::start(&root)).await } #[tauri::command] async fn dashboard_stop( state: State<'_, AppState>, id: String, ) -> std::result::Result { let root = path_of(&state, &id)?; blocking(move || { coa_core::dashboard::stop(&root)?; Ok(coa_core::dashboard::status(&root)) }) .await } #[tauri::command] fn list_backups( state: State<'_, AppState>, id: String, ) -> std::result::Result, UiError> { let root = path_of(&state, &id)?; Ok(backup::list(&meta_dir(&root)?)) } #[tauri::command] async fn create_backup( app: AppHandle, state: State<'_, AppState>, id: String, kind: Kind, label: Option, ) -> std::result::Result { let root = path_of(&state, &id)?; let _guard = BusyGuard::acquire(&state, &id)?; blocking(move || { let meta = meta_dir(&root)?; backup::create(&root, &meta, kind, Trigger::Manual, label, &|step| { let _ = app.emit("backup-progress", step); }) }) .await } #[tauri::command] async fn verify_backup( state: State<'_, AppState>, id: String, backup_id: String, ) -> std::result::Result { let root = path_of(&state, &id)?; blocking(move || backup::verify(&meta_dir(&root)?, &backup_id)).await } #[tauri::command] fn delete_backup( state: State<'_, AppState>, id: String, backup_id: String, ) -> std::result::Result<(), UiError> { let root = path_of(&state, &id)?; Ok(backup::delete(&meta_dir(&root)?, &backup_id)?) } #[tauri::command] async fn restore_backup_configs( state: State<'_, AppState>, id: String, backup_id: String, ) -> std::result::Result { let root = path_of(&state, &id)?; let _guard = BusyGuard::acquire(&state, &id)?; blocking(move || backup::restore_configs(&root, &meta_dir(&root)?, &backup_id)).await } #[tauri::command] async fn restore_backup_database( state: State<'_, AppState>, id: String, backup_id: String, database: String, ) -> std::result::Result { let root = path_of(&state, &id)?; let _guard = BusyGuard::acquire(&state, &id)?; blocking(move || backup::restore_database(&root, &meta_dir(&root)?, &backup_id, &database)) .await } #[tauri::command] fn install_preflight( state: State<'_, AppState>, dest: String, needed: Option, game_data: Option, ) -> Preflight { if platform::flavor() == Flavor::Docker { return docker_install::preflight(&dest, game_data, needed, &state.registry); } // `needed` is the real size from the signed package list when the screen already has it; the real size is checked // again at install time either way. install::preflight( std::path::Path::new(&dest), needed.unwrap_or(6 * 1024 * 1024 * 1024), &state.registry, ) } #[derive(Serialize)] struct InstallRequirements { /// What is downloaded. download_bytes: u64, /// What the unpacked server takes on the drive (the downloaded parts are removed afterwards). unpacked_bytes: u64, version: String, } /// How big the server is, read from the package's signed list before anything is downloaded. #[tauri::command] async fn install_requirements( package: Option, ) -> std::result::Result { if platform::flavor() == Flavor::Docker { return docker_install::requirements(package).await; } blocking(move || { let (m, _) = coa_core::pkgsource::fetch_manifest( &installation_source(package)?, coa_core::signing::EMBEDDED_PUBLIC_KEY, )?; let archive = m .archive .ok_or_else(|| Error::InvalidManifest("no archive".into()))?; Ok(InstallRequirements { download_bytes: archive.parts.iter().map(|p| p.size).sum(), unpacked_bytes: archive.unpacked_size, version: m.version, }) }) .await } #[tauri::command] async fn install_new( app: AppHandle, state: State<'_, AppState>, dest: String, package: Option, game_data: Option, ) -> std::result::Result { if platform::flavor() == Flavor::Docker { return docker_install::install(app, state, dest, package, game_data).await; } let cancel = Cancel::default(); *state .install_cancel .lock() .map_err(|_| Error::Invalid("state poisoned".into()))? = Some(cancel.clone()); let registry = Registry::at(data_dir().join("installs.json")); let dest_path = PathBuf::from(dest); let result = tauri::async_runtime::spawn_blocking(move || { let source = installation_source(package)?; install::install_base( &install::Params { source, dest: dest_path, trusted_key: coa_core::signing::EMBEDDED_PUBLIC_KEY, registry: ®istry, cancel, }, &|step| { let _ = app.emit("install-progress", step); }, ) }) .await; if let Ok(mut c) = state.install_cancel.lock() { *c = None; } let done = result.map_err(|e| Error::Invalid(e.to_string()))??; Ok(summary(done.id, PathBuf::from(done.path))) } #[tauri::command] fn cancel_install(state: State<'_, AppState>) { if let Ok(c) = state.install_cancel.lock() { if let Some(c) = c.as_ref() { c.cancel(); } } } #[tauri::command] async fn create_account( state: State<'_, AppState>, id: String, username: String, password: String, administrator: bool, ) -> std::result::Result<(), UiError> { let _guard = BusyGuard::acquire(&state, &id)?; let root = path_of(&state, &id)?; blocking(move || { coa_core::accounts::create(&root, &username, &password, administrator)?; tracing::info!(%username, administrator, "account created"); Ok(()) }) .await } #[tauri::command] async fn realmlist_profiles( state: State<'_, AppState>, id: String, ) -> std::result::Result { let root = path_of(&state, &id)?; blocking(move || { let (dir, _) = install_meta(&root)?; Ok(coa_core::realmlist::view( &dir, linked_client(&root)?.as_deref(), )) }) .await } #[tauri::command] async fn realmlist_save( state: State<'_, AppState>, id: String, profile_id: Option, name: String, data: String, ) -> std::result::Result { let root = path_of(&state, &id)?; blocking(move || { let (dir, _) = install_meta(&root)?; coa_core::realmlist::save_profile( &dir, linked_client(&root)?.as_deref(), profile_id.as_deref(), &name, &data, ) }) .await } #[tauri::command] async fn realmlist_delete( state: State<'_, AppState>, id: String, profile_id: String, ) -> std::result::Result<(), UiError> { let root = path_of(&state, &id)?; blocking(move || { let (dir, _) = install_meta(&root)?; coa_core::realmlist::delete_profile(&dir, linked_client(&root)?.as_deref(), &profile_id) }) .await } /// Write the chosen realmlist into the linked game client. #[tauri::command] async fn realmlist_activate( state: State<'_, AppState>, id: String, profile_id: String, ) -> std::result::Result, UiError> { let root = path_of(&state, &id)?; blocking(move || { let (dir, _) = install_meta(&root)?; let client = linked_client(&root)?.ok_or_else(|| { Error::Invalid("No game client is set up for this server yet.".into()) })?; let changed = coa_core::realmlist::activate(&dir, &client, &profile_id)?; tracing::info!(profile = %profile_id, files = changed.len(), "realmlist switched"); Ok(changed) }) .await } #[tauri::command] async fn modules_list( state: State<'_, AppState>, id: String, ) -> std::result::Result, UiError> { let root = path_of(&state, &id)?; blocking(move || Ok(coa_core::modules::list(&root))).await } #[tauri::command] async fn realm_profiles( state: State<'_, AppState>, id: String, ) -> std::result::Result { let root = path_of(&state, &id)?; blocking(move || coa_core::realms::view(&root)).await } #[tauri::command] async fn realm_select( state: State<'_, AppState>, id: String, mode: coa_core::realms::Mode, restart: bool, ) -> std::result::Result { let root = path_of(&state, &id)?; let _guard = BusyGuard::acquire(&state, &id)?; let result = blocking(move || { if restart { let out = driver::run(&root, Verb::StopAll)?; if !out.ok { return Err(Error::Invalid(out.output)); } } let view = coa_core::realms::select(&root, mode)?; let (dir, meta) = install_meta(&root)?; if let Some(client) = meta.client_path { coa_core::client::sync_realm_named( std::path::Path::new(&client), &dir, &coa_core::realm_names::for_mode(&root, view.active), )?; } if restart { let out = driver::run(&root, Verb::StartAll)?; if !out.ok { return Err(Error::Invalid(format!( "Realm selected, but startup failed: {}", out.output ))); } } Ok(view) }) .await; result } #[derive(serde::Serialize)] struct RestartScheduleView { schedule: coa_core::launcher::schedule::RestartSchedule, /// The server ships the Rust world supervisor that carries out the schedule. supported: bool, } #[tauri::command] async fn restart_schedule( state: State<'_, AppState>, id: String, ) -> std::result::Result { let root = path_of(&state, &id)?; blocking(move || { Ok(RestartScheduleView { schedule: coa_core::launcher::schedule::load(&root), supported: root.join("Scripts/coa-launcher.exe").is_file(), }) }) .await } /// Restart the world every day at the owner's local time; the running supervisor reads it within a minute. #[tauri::command] async fn restart_schedule_save( state: State<'_, AppState>, id: String, schedule: coa_core::launcher::schedule::RestartSchedule, ) -> std::result::Result { let root = path_of(&state, &id)?; let _guard = BusyGuard::acquire(&state, &id)?; blocking(move || { Ok(RestartScheduleView { schedule: coa_core::launcher::schedule::save(&root, &schedule)?, supported: root.join("Scripts/coa-launcher.exe").is_file(), }) }) .await } #[tauri::command] async fn mysql_custom( state: State<'_, AppState>, id: String, ) -> std::result::Result { let root = path_of(&state, &id)?; blocking(move || Ok(coa_core::launcher::render::read_custom_mysql(&root))).await } /// The owner's own MySQL options (Settings/mysql-custom.ini); they apply at the next start of the database. #[tauri::command] async fn mysql_custom_save( state: State<'_, AppState>, id: String, text: String, ) -> std::result::Result { let root = path_of(&state, &id)?; let _guard = BusyGuard::acquire(&state, &id)?; blocking(move || coa_core::launcher::render::write_custom_mysql(&root, &text)).await } #[tauri::command] async fn realm_names( state: State<'_, AppState>, id: String, ) -> std::result::Result, UiError> { let root = path_of(&state, &id)?; blocking(move || coa_core::realm_names::list(&root)).await } /// Rename a realm (`None` brings back its default name). The realm list changes at once when the database runs, /// and the linked game client selects the new name on the next Play. #[tauri::command] async fn realm_rename( state: State<'_, AppState>, id: String, realm_id: u32, name: Option, ) -> std::result::Result, UiError> { let root = path_of(&state, &id)?; let _guard = BusyGuard::acquire(&state, &id)?; blocking(move || coa_core::realm_names::rename(&root, realm_id, name.as_deref())).await } #[tauri::command] async fn realm_simultaneous( state: State<'_, AppState>, id: String, enabled: bool, ) -> std::result::Result { let root = path_of(&state, &id)?; let _guard = BusyGuard::acquire(&state, &id)?; blocking(move || coa_core::multiworld::set_enabled(&root, enabled)).await } #[tauri::command] async fn realm_with_reborn( state: State<'_, AppState>, id: String, enabled: bool, ) -> std::result::Result { let root = path_of(&state, &id)?; let _guard = BusyGuard::acquire(&state, &id)?; blocking(move || coa_core::multiworld::set_reborn_enabled(&root, enabled)).await } #[tauri::command] async fn check_database( state: State<'_, AppState>, id: String, ) -> std::result::Result, UiError> { let root = path_of(&state, &id)?; let _guard = BusyGuard::acquire(&state, &id)?; blocking(move || coa_core::repair::check(&root, &meta_dir(&root)?)).await } #[tauri::command] async fn repair_server( app: AppHandle, state: State<'_, AppState>, id: String, ) -> std::result::Result { let root = path_of(&state, &id)?; let _guard = BusyGuard::acquire(&state, &id)?; blocking(move || { let dir = meta_dir(&root)?; coa_core::repair::run( &root, &dir, &package_source(None), &update_source(None)?, coa_core::signing::EMBEDDED_PUBLIC_KEY, &|step, percent| { let _ = app.emit( "repair-progress", serde_json::json!({ "id": id, "step": step, "percent": percent }), ); }, ) }) .await } #[tauri::command] async fn module_set_enabled( state: State<'_, AppState>, id: String, module: String, enabled: bool, ) -> std::result::Result<(), UiError> { let root = path_of(&state, &id)?; let _guard = BusyGuard::acquire(&state, &id)?; blocking(move || { let (dir, _) = install_meta(&root)?; coa_core::modules::set_enabled(&root, &dir, &module, enabled) }) .await } #[tauri::command] async fn custom_races_status( state: State<'_, AppState>, id: String, ) -> std::result::Result, UiError> { let ctx = client_context(&state, &id)?; blocking(move || { let client = ctx.linked(); Ok(client .as_deref() .map(coa_core::custom_races::client_patch_status)) }) .await } #[tauri::command] async fn race_availability( state: State<'_, AppState>, id: String, ) -> std::result::Result { let root = path_of(&state, &id)?; blocking(move || coa_core::race_availability::status(&root)).await } #[tauri::command] async fn race_availability_save( state: State<'_, AppState>, id: String, catalog_sha256: String, realm: coa_core::realms::Mode, disabled_race_ids: Vec, ) -> std::result::Result { let root = path_of(&state, &id)?; let _guard = BusyGuard::acquire(&state, &id)?; blocking(move || { let (dir, _) = install_meta(&root)?; coa_core::race_availability::save(&root, &dir, &catalog_sha256, realm, &disabled_race_ids) }) .await } #[tauri::command] async fn custom_races_install( app: AppHandle, state: State<'_, AppState>, id: String, ) -> std::result::Result<(), UiError> { let ctx = client_context(&state, &id)?; let _guard = BusyGuard::acquire(&state, &id)?; let cancel = begin_client_job(&state)?; let sid = id.clone(); let result = blocking(move || { let client = ctx.require()?; coa_core::custom_races::install_client_patches(&client, &cancel, &|step, percent| { let _ = app.emit( "custom-races-progress", serde_json::json!({ "id": sid, "step": step, "percent": percent, }), ); })?; let enabled = ctx.root.as_ref().is_none_or(|root| { coa_core::modules::list(root) .iter() .any(|module| module.id == "custom-races" && module.enabled) }); coa_core::custom_races::set_client_patch_enabled(&client, enabled) }) .await; end_client_job(&state); result } #[tauri::command] async fn custom_race_characters( state: State<'_, AppState>, id: String, ) -> std::result::Result, UiError> { let root = path_of(&state, &id)?; blocking(move || coa_core::custom_races::custom_race_characters(&root)).await } /// Delete the companion bots of custom races through the running world's console. Returns how many. #[tauri::command] async fn purge_custom_race_bots( state: State<'_, AppState>, id: String, ) -> std::result::Result { let root = path_of(&state, &id)?; let _guard = BusyGuard::acquire(&state, &id)?; blocking(move || { let o = coa_core::process::observe(&root, &layout::read_ports(&root)); if o.world.state != coa_core::process::ServiceState::Running { return Err(Error::Invalid("Start the server to delete bots.".into())); } Ra::connect(&root)?.purge_custom_race_bots() }) .await } #[tauri::command] async fn addons_list( state: State<'_, AppState>, id: String, ) -> std::result::Result, UiError> { let ctx = client_context(&state, &id)?; blocking(move || coa_core::addons::list(&ctx.require()?)).await } /// Install or update a catalog addon in the linked game client (pinned commit, every file checked). #[tauri::command] async fn addons_install( state: State<'_, AppState>, id: String, addon: String, ) -> std::result::Result, UiError> { let ctx = client_context(&state, &id)?; let _guard = BusyGuard::acquire(&state, &id)?; let cancel = begin_client_job(&state)?; let result = blocking(move || coa_core::addons::install(&ctx.require()?, &addon, &cancel)).await; end_client_job(&state); result } #[tauri::command] async fn addons_remove( state: State<'_, AppState>, id: String, addon: String, ) -> std::result::Result, UiError> { let ctx = client_context(&state, &id)?; let _guard = BusyGuard::acquire(&state, &id)?; blocking(move || coa_core::addons::remove(&ctx.require()?, &addon)).await } #[tauri::command] async fn custom_races_uninstall( state: State<'_, AppState>, id: String, ) -> std::result::Result<(), UiError> { let ctx = client_context(&state, &id)?; let _guard = BusyGuard::acquire(&state, &id)?; blocking(move || coa_core::custom_races::uninstall_client_patches(&ctx.require()?)).await } #[tauri::command] async fn custom_races_toggle_client( state: State<'_, AppState>, id: String, enabled: bool, ) -> std::result::Result<(), UiError> { let root = path_of(&state, &id)?; let _guard = BusyGuard::acquire(&state, &id)?; blocking(move || { let client = linked_client(&root)? .ok_or_else(|| Error::Invalid("No game client is linked to this server.".into()))?; coa_core::custom_races::set_client_patch_enabled(&client, enabled) }) .await } #[tauri::command] async fn module_settings( state: State<'_, AppState>, id: String, module: String, ) -> std::result::Result, UiError> { let root = path_of(&state, &id)?; blocking(move || coa_core::modules::settings(&root, &module)).await } #[tauri::command] async fn module_save_settings( state: State<'_, AppState>, id: String, module: String, changes: BTreeMap, ) -> std::result::Result, UiError> { let root = path_of(&state, &id)?; let _guard = BusyGuard::acquire(&state, &id)?; blocking(move || { let (dir, _) = install_meta(&root)?; coa_core::modules::save_settings(&root, &dir, &module, &changes) }) .await } #[tauri::command] async fn all_settings( state: State<'_, AppState>, id: String, ) -> std::result::Result, UiError> { let root = path_of(&state, &id)?; blocking(move || coa_core::allsettings::list(&root)).await } #[tauri::command] async fn all_settings_save( state: State<'_, AppState>, id: String, changes: BTreeMap, ) -> std::result::Result, UiError> { let root = path_of(&state, &id)?; let _guard = BusyGuard::acquire(&state, &id)?; blocking(move || { let (dir, _) = install_meta(&root)?; coa_core::allsettings::save(&root, &dir, &changes) }) .await } #[tauri::command] async fn list_accounts( state: State<'_, AppState>, id: String, ) -> std::result::Result, UiError> { let root = path_of(&state, &id)?; blocking(move || coa_core::accounts::list(&root)).await } #[tauri::command] async fn account_set_password( state: State<'_, AppState>, id: String, name: String, password: String, ) -> std::result::Result<(), UiError> { let root = path_of(&state, &id)?; blocking(move || { Ra::connect(&root)?.set_account_password(&name, &password)?; tracing::info!(%name, "account password changed"); Ok(()) }) .await } #[tauri::command] async fn account_set_access( state: State<'_, AppState>, id: String, name: String, level: u8, ) -> std::result::Result<(), UiError> { let root = path_of(&state, &id)?; blocking(move || { Ra::connect(&root)?.set_account_access(&name, level)?; tracing::info!(%name, level, "account access level changed"); Ok(()) }) .await } #[tauri::command] async fn account_rename( state: State<'_, AppState>, id: String, name: String, new_name: String, password: String, ) -> std::result::Result<(), UiError> { let root = path_of(&state, &id)?; blocking(move || { let mut ra = Ra::connect(&root)?; coa_core::accounts::rename(&root, &mut ra, &name, &new_name, &password) }) .await } #[tauri::command] async fn account_delete( state: State<'_, AppState>, id: String, name: String, ) -> std::result::Result<(), UiError> { let root = path_of(&state, &id)?; blocking(move || { let mut ra = Ra::connect(&root)?; coa_core::accounts::delete(&root, &mut ra, &name) }) .await } fn install_meta(root: &std::path::Path) -> Result<(PathBuf, InstallMeta)> { let dir = meta_dir(root)?; let (_, meta) = MetaDir::open(&dir)?; Ok((dir, meta)) } #[tauri::command] async fn check_update( state: State<'_, AppState>, id: String, source: Option, background: Option, ) -> std::result::Result { let root = path_of(&state, &id)?; // The check that repeats every few minutes must not start and stop the database of a stopped server. let access = if background.unwrap_or(false) { update::DatabaseAccess::OnlyIfRunning } else { update::DatabaseAccess::Start }; blocking(move || { let (_, meta) = install_meta(&root)?; let selection = coa_core::update_route::select( &meta, update_source(source)?, coa_core::signing::EMBEDDED_PUBLIC_KEY, )?; let mut preview = update::preview_with( &root, &meta, &selection.source, coa_core::signing::EMBEDDED_PUBLIC_KEY, &Default::default(), access, )?; preview.latest_version = selection.latest_version; Ok(preview) }) .await } #[tauri::command] fn pending_update( state: State<'_, AppState>, id: String, ) -> std::result::Result, UiError> { let root = path_of(&state, &id)?; Ok(update::pending_checked(&meta_dir(&root)?)?) } #[tauri::command] async fn apply_update( app: AppHandle, state: State<'_, AppState>, id: String, source: Option, resolutions: BTreeMap, ) -> std::result::Result { let root = path_of(&state, &id)?; let _guard = BusyGuard::acquire(&state, &id)?; blocking(move || { let (dir, meta) = install_meta(&root)?; let src = coa_core::update_route::select( &meta, update_source(source)?, coa_core::signing::EMBEDDED_PUBLIC_KEY, )? .source; let (manifest, _) = coa_core::pkgsource::fetch_manifest(&src, coa_core::signing::EMBEDDED_PUBLIC_KEY)?; update::validate_candidate(&meta, &manifest)?; // Files cannot be replaced while the server runs: stop it first (gracefully), like the Stop button. let observed = coa_core::process::observe(&root, &layout::read_ports(&root)); if observed.world.state != coa_core::process::ServiceState::Stopped || observed.auth.state != coa_core::process::ServiceState::Stopped || coa_core::multiworld::is_running(&root) { let out = driver::run(&root, Verb::StopAll)?; if !out.ok { return Err(Error::Invalid( "The server could not be stopped, so the update was not started.".into(), )); } } let env = update::RepackEnv { root: &root, meta_dir: &dir, }; update::apply( &update::Params { root: &root, meta_dir: &dir, source: src, trusted_key: coa_core::signing::EMBEDDED_PUBLIC_KEY, cancel: Cancel::default(), resolutions, env: &env, fail_after_ops: None, }, &|step, percent| { let _ = app.emit( "update-progress", serde_json::json!({ "step": step, "percent": percent }), ); }, ) }) .await } #[tauri::command] async fn rollback_update( state: State<'_, AppState>, id: String, txn: String, ) -> std::result::Result { let root = path_of(&state, &id)?; let _guard = BusyGuard::acquire(&state, &id)?; blocking(move || { let dir = meta_dir(&root)?; let env = update::RepackEnv { root: &root, meta_dir: &dir, }; update::rollback(&root, &dir, &txn, &env) }) .await } #[tauri::command] async fn retry_update_validation( state: State<'_, AppState>, id: String, txn: String, ) -> std::result::Result { let root = path_of(&state, &id)?; let _guard = BusyGuard::acquire(&state, &id)?; blocking(move || { let dir = meta_dir(&root)?; let pending = update::load(&dir, &txn)?; let source = coa_core::pkgsource::Source::Url(format!( "https://github.com/Corfirean/coa-server-build/releases/download/server-{}/", pending.to_version )); let env = update::RepackEnv { root: &root, meta_dir: &dir, }; update::retry_validation( &root, &dir, &txn, &source, coa_core::signing::EMBEDDED_PUBLIC_KEY, &env, ) }) .await } #[tauri::command] async fn get_population( state: State<'_, AppState>, id: String, realm: Option, ) -> std::result::Result, UiError> { let root = path_of(&state, &id)?; Ok(tauri::async_runtime::spawn_blocking(move || { let o = coa_core::process::observe(&root, &layout::read_ports(&root)); if o.mysql.state != coa_core::process::ServiceState::Running { return None; } if let Some(mode) = realm { coa_core::population::query_for_realm(&root, mode).ok() } else { coa_core::population::query(&root).ok() } }) .await .unwrap_or(None)) } #[tauri::command] async fn companions_login_all( state: State<'_, AppState>, id: String, realm: Option, ) -> std::result::Result { let root = path_of(&state, &id)?; let _guard = BusyGuard::acquire(&state, &id)?; blocking(move || { let mut ra = Ra::connect_target(&root, realm)?; ra.login_all() }) .await } #[tauri::command] async fn companions_spawn_fleet( state: State<'_, AppState>, id: String, race: u8, level: u8, realm: Option, ) -> std::result::Result { let root = path_of(&state, &id)?; let _guard = BusyGuard::acquire(&state, &id)?; blocking(move || { let mut ra = Ra::connect_target(&root, realm)?; ra.spawn_fleet(race, level) }) .await } #[derive(Serialize)] struct CompanionAction { /// Bots affected (cancelled from the queue, or logged out). count: u32, } #[tauri::command] async fn companions_stop_spawning( state: State<'_, AppState>, id: String, realm: Option, ) -> std::result::Result { let root = path_of(&state, &id)?; blocking(move || { let mode = realm.unwrap_or_else(|| { coa_core::realms::view(&root).map(|v| v.active).unwrap_or_default() }); let meta = meta_dir(&root)?; let cancelled_pending = coa_core::companions::cancel_pending_job(&meta, mode.name()) .ok() .flatten(); match Ra::connect_target(&root, Some(mode)).and_then(|mut ra| ra.cancel_spawning()) { Ok(ra_cancelled) => Ok(CompanionAction { count: ra_cancelled + cancelled_pending.map(|j| j.remaining_count()).unwrap_or(0), }), Err(e) => { if let Some(job) = cancelled_pending { Ok(CompanionAction { count: job.remaining_count(), }) } else { Err(e) } } } }) .await } #[tauri::command] async fn companions_take_offline( state: State<'_, AppState>, id: String, realm: Option, ) -> std::result::Result { let root = path_of(&state, &id)?; let _guard = BusyGuard::acquire(&state, &id)?; blocking(move || { let mut ra = Ra::connect_target(&root, realm)?; let _ = ra.cancel_spawning(); Ok(CompanionAction { count: ra.despawn_all()?, }) }) .await } #[tauri::command] async fn companions_despawn_some( state: State<'_, AppState>, id: String, count: u32, realm: Option, ) -> std::result::Result { let root = path_of(&state, &id)?; let _guard = BusyGuard::acquire(&state, &id)?; blocking(move || { if !(1..=5000).contains(&count) { return Err(Error::Invalid("Choose a number between 1 and 5000.".into())); } let mode = realm.unwrap_or_else(|| { coa_core::realms::view(&root).map(|v| v.active).unwrap_or_default() }); let target = coa_core::multiworld::resolve_bot_operation_target(&root, mode)?; let prefix = coa_core::population::bot_account_prefix(&root).to_uppercase(); let db = coa_core::db::Db::from_repack(&root, coa_core::db::Account::App)?; let rows = db.query(&format!( "SELECT c.guid FROM {}.characters c JOIN acore_auth.account a ON a.id=c.account WHERE c.online=1 AND UPPER(a.username) LIKE '{prefix}%' ORDER BY RAND() LIMIT {count};", target.chars_db ))?; let guids: Vec = rows.lines().filter_map(|l| l.trim().parse().ok()).collect(); let mut ra = Ra::connect_target(&root, Some(mode))?; let mut done = 0; for g in guids { if ra.despawn_bot(g).unwrap_or(false) { done += 1; } } Ok(CompanionAction { count: done }) }) .await } #[tauri::command] async fn companions_delete_all( app: AppHandle, state: State<'_, AppState>, id: String, realm: Option, ) -> std::result::Result { let root = path_of(&state, &id)?; let _guard = BusyGuard::acquire(&state, &id)?; blocking(move || { let mode = realm.unwrap_or_else(|| { coa_core::realms::view(&root).map(|v| v.active).unwrap_or_default() }); let target = coa_core::multiworld::resolve_bot_operation_target(&root, mode)?; let meta = meta_dir(&root)?; backup::create( &root, &meta, Kind::Quick, Trigger::BeforeDangerousChange, Some(format!("before deleting all {} companions", target.realm.label())), &|step| { let _ = app.emit("backup-progress", step); }, )?; let before = coa_core::population::query_for_realm(&root, mode) .map(|p| p.bots_total) .unwrap_or(0); let _ = coa_core::companions::cancel_pending_job(&meta, mode.name()); let mut ra = Ra::connect_target(&root, Some(mode))?; let _ = ra.cancel_spawning(); ra.purge_all()?; Ok(CompanionAction { count: before }) }) .await } #[tauri::command] async fn get_performance( state: State<'_, AppState>, id: String, ) -> std::result::Result, UiError> { let root = path_of(&state, &id)?; Ok(tauri::async_runtime::spawn_blocking(move || { let o = coa_core::process::observe(&root, &layout::read_ports(&root)); if o.world.state != coa_core::process::ServiceState::Running { return None; } Ra::connect(&root) .and_then(|mut r| r.performance()) .ok() .flatten() }) .await .unwrap_or(None)) } #[derive(Serialize)] struct CompanionSizes { hardware: coa_core::population::Hardware, sizes: Vec, } #[tauri::command] fn companion_sizes() -> CompanionSizes { let hardware = coa_core::population::hardware(); let sizes = coa_core::population::sizes(&hardware); CompanionSizes { hardware, sizes } } #[derive(Serialize)] struct CompanionsResult { spawned: Option, /// Created offline with their equipment (server was stopped and the batch was large). created: Option, /// Companions that existed before this request (for a progress bar while the server creates the new ones). baseline: Option, } /// Turn on automatic bot login for `count` bots and, if the server is running, ask it to create them. #[tauri::command] async fn add_companions( state: State<'_, AppState>, id: String, count: u32, realm: Option, level: Option, class_id: Option, spec_id: Option, archetype: Option, ) -> std::result::Result { let root = path_of(&state, &id)?; let _guard = BusyGuard::acquire(&state, &id)?; blocking(move || { if !(1..=2000).contains(&count) { return Err(Error::Invalid( "Choose between 1 and 2000 companions.".into(), )); } let mode = realm.unwrap_or_else(|| { coa_core::realms::view(&root).map(|v| v.active).unwrap_or_default() }); coa_core::companions::validate_spawn_request( mode, count, level, class_id, spec_id, archetype.as_deref(), )?; let target = coa_core::multiworld::resolve_bot_operation_target(&root, mode)?; if mode == coa_core::realms::Mode::Wildcard { if let Some(ref arch_id) = archetype { if !arch_id.trim().is_empty() { let db = coa_core::db::Db::from_repack(&root, coa_core::db::Account::Admin)?; let archetypes = coa_core::companions::list_wildcard_archetypes(&db, target.chars_db)?; if !archetypes.iter().any(|a| a.id.eq_ignore_ascii_case(arch_id.trim())) { return Err(Error::Invalid(format!( "Unknown Wildcard build UUID '{}' in {}.coa_build_creator.", arch_id.trim(), target.chars_db ))); } } } } let meta = meta_dir(&root)?; let mut changes = BTreeMap::new(); changes.insert("CoaBots.AutoLoginOnStartup".to_string(), Value::Bool(true)); let existing_cfg = config::load(&target.world_root, Scope::Bots)?; let existing_max = existing_cfg .settings .iter() .find(|s| s.meta.key == "CoaBots.AutoLogin.MaxCount") .and_then(|s| s.value.as_u64()) .unwrap_or(0) as u32; let already = coa_core::population::query_for_realm(&root, mode) .map(|p| p.bots_total) .unwrap_or(0); changes.insert( "CoaBots.AutoLogin.MaxCount".to_string(), Value::from(existing_max.max(already + count).min(5000)), ); config::save(&target.world_root, &meta, Scope::Bots, &changes)?; let mut baseline = None; let spawned = if target.running { if let Ok(admin_db) = coa_core::db::Db::from_repack(&root, coa_core::db::Account::Admin) { let _ = coa_core::companions::ensure_templates_for_schema(&admin_db, target.chars_db); } baseline = coa_core::population::query_for_realm(&root, mode) .ok() .map(|p| p.bots_total); let mut ra = Ra::connect_target(&root, Some(mode))?; if let Some(lvl) = level { Some(ra.spawn_custom(count, lvl, class_id, spec_id, archetype.as_deref())?) } else { Some(ra.spawn_bots(count)?) } } else { let _ = coa_core::companions::migrate_legacy_pending_job(&meta, &id); let mut job = coa_core::companions::CompanionsPendingJob::new( &id, mode.name(), count, level, class_id, spec_id, archetype.clone(), ); if let Ok(admin_db) = coa_core::db::Db::from_repack(&root, coa_core::db::Account::Admin) { if let Ok(snap) = coa_core::companions::query_bot_db_snapshot(&root, &admin_db, target.chars_db, None) { job.baseline_bot_count = Some(snap.bot_count); job.baseline_max_guid = Some(snap.max_guid); } } coa_core::companions::save_pending_job(&meta, mode.name(), &job)?; None }; tracing::info!(count, spawned = spawned.is_some(), "companions requested"); Ok(CompanionsResult { spawned, created: None, baseline, }) }) .await } #[tauri::command] async fn get_wildcard_archetypes( state: State<'_, AppState>, id: String, ) -> std::result::Result, UiError> { let root = path_of(&state, &id)?; blocking(move || { let db = coa_core::db::Db::from_repack(&root, coa_core::db::Account::Admin)?; let target = coa_core::multiworld::resolve_bot_operation_target(&root, coa_core::realms::Mode::Wildcard) .unwrap_or_else(|_| coa_core::multiworld::BotOperationTarget { world_root: root.clone(), chars_db: "acore_characters_wildcard", ra_port: 3444, running: false, realm: coa_core::realms::Mode::Wildcard, }); Ok(coa_core::companions::list_wildcard_archetypes(&db, target.chars_db)?) }) .await } const REMOTE_CLIENT_ID: &str = "@remote-client"; fn remote_dir() -> PathBuf { data_dir().join("remote-client") } #[tauri::command] fn remote_connection() -> std::result::Result { Ok(coa_core::remote_client::load(&remote_dir())?) } #[tauri::command] fn remote_connect( state: State<'_, AppState>, host: String, ) -> std::result::Result { let job = state.client_cancel.lock().unwrap(); if job.is_some() { return Err(Error::Invalid("Wait for the client operation to finish.".into()).into()); } let dir = remote_dir(); let mut profile = coa_core::remote_client::load(&dir)?; let host = host.trim(); if host.is_empty() { return Err(Error::Invalid("Enter the host's IP address or hostname.".into()).into()); } if profile.host != host { // A host typed by hand is not the listed server whose account was remembered. profile.realm = None; } profile.host = host.into(); coa_core::remote_client::save(&dir, &profile)?; Ok(profile) } struct ClientContext { dir: PathBuf, path: Option, source: Option, host: String, root: Option, } fn client_context(state: &AppState, id: &str) -> Result { if id == REMOTE_CLIENT_ID { let dir = remote_dir(); let profile = coa_core::remote_client::load(&dir)?; return Ok(ClientContext { dir, path: profile.client_path.map(PathBuf::from), source: None, host: profile.host, root: None, }); } let root = path_of(state, id)?; let (dir, meta) = install_meta(&root)?; let source = coa_core::client::addon_source(&root); Ok(ClientContext { dir, path: meta.client_path.map(PathBuf::from), source, host: "127.0.0.1".into(), root: Some(root), }) } impl ClientContext { fn linked(&self) -> Option { self.path .clone() .filter(|p| coa_core::client::detect(p, None).is_some()) } fn require(&self) -> Result { self.linked() .ok_or_else(|| Error::Invalid("Set up a game client first.".into())) } fn link(&self, path: &str) -> Result<()> { if let Some(root) = &self.root { let (_, mut meta) = install_meta(root)?; meta.client_path = Some(path.into()); coa_core::fsx::atomic_write_json(&self.dir.join("install.json"), &meta) } else { let mut profile = coa_core::remote_client::load(&self.dir)?; profile.client_path = Some(path.into()); coa_core::remote_client::save(&self.dir, &profile) } } } fn client_of(root: &std::path::Path) -> Result<(PathBuf, InstallMeta, Option)> { let (dir, meta) = install_meta(root)?; let client = meta.client_path.clone().map(PathBuf::from).ok_or_else(|| { Error::Invalid("No game client is set up for this server yet.".into()) })?; Ok((dir, meta, Some(client))) } #[tauri::command] fn client_graphics( state: State<'_, AppState>, id: String, ) -> std::result::Result { Ok(coa_core::client_graphics::status( &client_context(&state, &id)?.require()?, )?) } #[tauri::command] fn client_set_graphics( state: State<'_, AppState>, id: String, name: String, disabled: bool, ) -> std::result::Result { let job = state.client_cancel.lock().unwrap(); if job.is_some() { return Err(Error::Invalid("Wait for the client operation to finish.".into()).into()); } Ok(coa_core::client_graphics::set( &client_context(&state, &id)?.require()?, &name, disabled, )?) } #[tauri::command] fn client_info( state: State<'_, AppState>, id: String, ) -> std::result::Result, UiError> { let ctx = client_context(&state, &id)?; Ok(ctx .path .and_then(|p| coa_core::client::detect(&p, ctx.source.as_deref()))) } #[tauri::command] fn set_client( state: State<'_, AppState>, id: String, path: String, ) -> std::result::Result { let job = state.client_cancel.lock().unwrap(); if job.is_some() { return Err(Error::Invalid("Wait for the client operation to finish.".into()).into()); } let ctx = client_context(&state, &id)?; let info = coa_core::client::detect(std::path::Path::new(&path), ctx.source.as_deref()) .ok_or_else(|| Error::Invalid("This folder does not look like a game client (it needs Data and the game executable).".into()))?; ctx.link(&info.path)?; Ok( coa_core::client::detect(std::path::Path::new(&info.path), ctx.source.as_deref()) .unwrap_or(info), ) } #[tauri::command] fn client_realmlist( state: State<'_, AppState>, id: String, host: String, ) -> std::result::Result, UiError> { let root = path_of(&state, &id)?; let (dir, _, client) = client_of(&root)?; Ok(coa_core::client::set_realmlist( &client.unwrap(), &dir, &host, )?) } #[tauri::command] fn client_install_addon( state: State<'_, AppState>, id: String, ) -> std::result::Result<(), UiError> { let root = path_of(&state, &id)?; let (dir, _, client) = client_of(&root)?; let source = coa_core::client::addon_source(&root).ok_or_else(|| { Error::Invalid("This server package does not include the companion addon.".into()) })?; Ok(coa_core::client::install_addon( &client.unwrap(), &dir, &source, )?) } #[derive(Serialize)] struct ClientStatus { /// A usable client folder is linked to this server. linked: bool, /// The Manager keeps this folder up to date (it downloaded it or was asked to adopt it). managed: bool, installed_version: Option, latest_version: Option, latest_bytes: Option, /// A managed client is older than the published one (or its download never finished). update_available: bool, } fn linked_client(root: &std::path::Path) -> Result> { let (_, meta) = install_meta(root)?; Ok(meta .client_path .map(PathBuf::from) .filter(|p| coa_core::client::detect(p, None).is_some())) } /// Cheap: one small manifest request and the local state file; no game file is read. #[tauri::command] async fn client_status( state: State<'_, AppState>, id: String, ) -> std::result::Result { let ctx = client_context(&state, &id)?; blocking(move || { let client = ctx.linked(); let latest = coa_core::clientdl::fetch_latest().ok(); let local = client.as_deref().map(coa_core::clientdl::local); let managed = local.as_ref().map(|l| l.managed).unwrap_or(false); let installed = local.and_then(|l| l.version); let update_available = managed && latest .as_ref() .map(|l| installed.as_deref() != Some(l.version.as_str())) .unwrap_or(false); Ok(ClientStatus { linked: client.is_some(), managed, installed_version: installed, latest_bytes: latest.as_ref().map(|l| l.total_bytes()), latest_version: latest.map(|l| l.version), update_available, }) }) .await } #[derive(Serialize)] struct ClientDownloadCheck { needed_bytes: u64, free_bytes: u64, version: String, /// Where the client would go. dest: String, } const CLIENT_FOLDER: &str = "CoA Client"; #[tauri::command] async fn client_download_check( parent: String, ) -> std::result::Result { blocking(move || { let latest = coa_core::clientdl::fetch_latest()?; let dest = PathBuf::from(&parent).join(CLIENT_FOLDER); Ok(ClientDownloadCheck { needed_bytes: latest.total_bytes(), free_bytes: coa_core::fsx::free_space(std::path::Path::new(&parent))?, version: latest.version, dest: dest.to_string_lossy().into_owned(), }) }) .await } /// Compare the linked client with the published one. Hashes files only where the recorded state cannot vouch for them. #[tauri::command] async fn client_plan( app: AppHandle, state: State<'_, AppState>, id: String, ) -> std::result::Result { let ctx = client_context(&state, &id)?; let cancel = begin_client_job(&state)?; let result = blocking(move || { let client = ctx.require()?; let manifest = coa_core::clientdl::fetch_latest()?; let current = coa_core::clientdl::load_state(&client).unwrap_or_default(); coa_core::clientdl::plan(&client, &manifest, ¤t, &cancel, &|s| { let _ = app.emit("client-progress", s); }) }) .await; end_client_job(&state); result } /// Bring the linked client to the published version. `keep_modified` leaves files the player changed alone. #[tauri::command] async fn client_sync( app: AppHandle, state: State<'_, AppState>, id: String, keep_modified: bool, ) -> std::result::Result<(), UiError> { let ctx = client_context(&state, &id)?; let cancel = begin_client_job(&state)?; let result = blocking(move || { let client = ctx.require()?; run_client_sync(&app, &client, keep_modified, &cancel)?; if ctx.root.is_none() && !ctx.host.is_empty() { coa_core::client::set_realmlist(&client, &ctx.dir, &ctx.host)?; } Ok(()) }) .await; end_client_job(&state); result } fn run_client_sync( app: &AppHandle, client: &std::path::Path, keep_modified: bool, cancel: &Cancel, ) -> Result<()> { let emit = |s: coa_core::clientdl::Step| { let _ = app.emit("client-progress", s); }; let manifest = coa_core::clientdl::fetch_latest()?; let current = coa_core::clientdl::load_state(client).unwrap_or_default(); let plan = coa_core::clientdl::plan(client, &manifest, ¤t, cancel, &emit)?; coa_core::download::check_url(coa_core::clientdl::OBJECTS_URL)?; let transport = coa_core::download::HttpTransport::new()?; coa_core::clientdl::apply( &coa_core::clientdl::Apply { client, manifest: &manifest, plan: &plan, keep_modified, transport: &transport, objects_url: coa_core::clientdl::OBJECTS_URL, cancel, }, &emit, )?; tracing::info!(version = %manifest.version, downloaded = plan.items.len(), "client brought up to date"); Ok(()) } /// Download the client into `/CoA Client`, then link it to a host or player profile. #[tauri::command] async fn client_download( app: AppHandle, state: State<'_, AppState>, id: String, parent: String, ) -> std::result::Result { let ctx = client_context(&state, &id)?; let cancel = begin_client_job(&state)?; let result = blocking(move || { let parent = PathBuf::from(&parent); if !parent.is_dir() { return Err(Error::Invalid( "Choose an existing folder to put the game client in.".into(), )); } let dest = parent.join(CLIENT_FOLDER); let resuming = coa_core::clientdl::load_state(&dest).is_some(); let non_empty = std::fs::read_dir(&dest) .map(|mut r| r.next().is_some()) .unwrap_or(false); if non_empty && !resuming { return Err(Error::Invalid(format!( "{} already exists and is not an unfinished download. Choose another folder.", dest.display() ))); } std::fs::create_dir_all(&dest)?; run_client_sync(&app, &dest, false, &cancel)?; let info = coa_core::client::detect(&dest, ctx.source.as_deref()) .ok_or_else(|| Error::Invalid("The downloaded client looks incomplete.".into()))?; ctx.link(&info.path)?; if !ctx.host.is_empty() { coa_core::client::set_realmlist(&dest, &ctx.dir, &ctx.host)?; } if let Some(src) = &ctx.source { coa_core::client::install_addon(&dest, &ctx.dir, src)?; } Ok(coa_core::client::detect(&dest, ctx.source.as_deref()).unwrap_or(info)) }) .await; end_client_job(&state); result } #[tauri::command] fn client_cancel(state: State<'_, AppState>) { if let Ok(c) = state.client_cancel.lock() { if let Some(c) = c.as_ref() { c.cancel(); } } } fn begin_client_job(state: &AppState) -> std::result::Result { let mut slot = state .client_cancel .lock() .map_err(|_| Error::Invalid("state poisoned".into()))?; if slot.is_some() { return Err(Error::Invalid( "The game client is already being checked or downloaded.".into(), ) .into()); } let cancel = Cancel::default(); *slot = Some(cancel.clone()); Ok(cancel) } fn end_client_job(state: &AppState) { if let Ok(mut c) = state.client_cancel.lock() { *c = None; } } /// Launch the game client independently of the local server. #[tauri::command] async fn play( state: State<'_, AppState>, id: String, ) -> std::result::Result { if id == REMOTE_CLIENT_ID { let ctx = client_context(&state, &id)?; let client = ctx.require()?; // The account the Manager made (or linked) on that listed server goes into the login box at every Play, // also when another server's account was used in between. let login = coa_core::remote_client::load(&remote_dir()) .ok() .and_then(|profile| profile.realm) .and_then(|realm| { let pc = control_cmds::player(&state).ok()?; pc.credentials(&control_cmds::realm_id(&realm).ok()?).ok()? }); return blocking(move || { if ctx.host.is_empty() { return Err(Error::Invalid( "Enter the host's IP address or hostname first.".into(), )); } if coa_core::client::is_running(&client) { return Err(Error::Invalid("The game is already running.".into())); } coa_core::client::begin_realmlist_override(&client, &ctx.dir, &ctx.host)?; if let Some(creds) = &login { let _ = coa_core::glue_config::prefill_login(&client, &creds.username, &creds.password); } if window_preferences::clear_cache_on_play(&data_dir()) { let _ = coa_core::client::clear_game_cache(&client); } coa_core::client::launch(&client)?; let client_c = client.clone(); let meta_c = ctx.dir.clone(); std::thread::Builder::new() .name("client-realmlist-watcher".into()) .spawn(move || { std::thread::sleep(std::time::Duration::from_millis(3000)); while coa_core::client::is_running(&client_c) { std::thread::sleep(std::time::Duration::from_millis(1000)); } let _ = coa_core::client::revert_realmlist_override(&meta_c); }) .ok(); Ok(DriverOutcome { ok: true, exit_code: None, code: None, human: None, output: String::new(), }) }) .await; } let root = path_of(&state, &id)?; let (dir, _, client) = client_of(&root)?; let client = client.unwrap(); if coa_core::client::is_running(&client) { return Err(Error::Invalid( "Close the game client before pressing Play so its selected realm can be updated." .into(), ) .into()); } blocking(move || { let mode = coa_core::realms::state(&root)?.active; let realm = coa_core::realm_names::for_mode(&root, mode); if !coa_core::client::sync_realm_named(&client, &dir, &realm)? { return Err(Error::Invalid( "Close the game client before pressing Play so its selected realm can be updated." .into(), )); } let existing = coa_core::glue_config::read_glue_config(&client).unwrap_or_default(); if existing.is_empty() { let _ = coa_core::glue_config::prefill_login(&client, "local", "local"); } if window_preferences::clear_cache_on_play(&data_dir()) { let _ = coa_core::client::clear_game_cache(&client); } coa_core::client::launch(&client)?; Ok(DriverOutcome { ok: true, exit_code: None, code: None, human: None, output: String::new(), }) }) .await } #[derive(Serialize)] struct FriendsStatus { settings: coa_core::friends::Settings, lan_ip: Option, lan_addresses: Vec, exposure: Vec, /// The configuration lets other computers reach the login and world servers. servers_open: bool, firewall: Option, tailscale: coa_core::net::Tailscale, server_running: bool, auth_port: u16, world_port: u16, secondary_world_port: Option, reborn_world_port: Option, } /// Open one of a few known help pages in the default browser. Anything else is refused, so a page can never ask the /// Manager to launch an arbitrary address. #[tauri::command] fn open_link(url: String) -> std::result::Result<(), UiError> { const ALLOWED: &[&str] = &[ "https://tailscale.com/", "https://login.tailscale.com/", "https://portforward.com/", "https://github.com/Corfirean/", ]; // A prefilled "new issue" page of one of the places a report can go (the Manager, Companions, SQUID Playerbots): the // address must be exactly that page, and its query may carry `&` between the (percent-encoded) title and text. let issue = coa_core::report::is_new_issue_url(&url); let chars_ok = url .chars() .all(|c| c.is_ascii_alphanumeric() || "/:._-?=#%".contains(c) || (issue && c == '&')); // the GitHub page of a module that is in the bundled catalog (some are not ours) let catalog = coa_core::modules::catalog().iter().any(|e| e.repo == url); if !(issue || catalog || ALLOWED.iter().any(|p| url.starts_with(p))) || !chars_ok || url.len() > 12_000 { return Err(Error::Invalid("That link is not allowed.".into()).into()); } tauri_plugin_opener::open_url(&url, None::<&str>).map_err(|e| Error::Invalid(e.to_string()))?; Ok(()) } #[derive(Serialize)] struct ReportContext { manager_version: String, windows: String, /// "new" for a server the Manager installed, "imported" for one that was added. install_kind: String, server_version: Option, /// Where the form should start: the bot system that is switched on, else the Manager. suggested_target: String, /// The release of whichever bot system is on, for a report that goes to its repository. bots_version: Option, } /// The places a report can go, each with its GitHub repository. #[tauri::command] fn report_targets() -> Vec { coa_core::report::targets() } /// The distribution on Linux ("Linux (Arch Linux)"), from `/etc/os-release`; empty if it cannot be read. #[cfg(not(windows))] fn windows_version() -> String { std::fs::read_to_string("/etc/os-release") .ok() .and_then(|t| { t.lines().find_map(|l| { l.strip_prefix("PRETTY_NAME=") .map(|v| v.trim_matches('"').to_string()) }) }) .map(|name| format!("Linux ({name})")) .unwrap_or_default() } /// "Windows 11 (build 26200)" from `ver`; empty if it cannot be read. #[cfg(windows)] fn windows_version() -> String { let mut cmd = std::process::Command::new("cmd.exe"); cmd.args(["/C", "ver"]); #[cfg(windows)] { use std::os::windows::process::CommandExt; cmd.creation_flags(0x0800_0000); } let out = cmd .output() .map(|o| String::from_utf8_lossy(&o.stdout).into_owned()) .unwrap_or_default(); let build: Option = out .split("Version") .nth(1) .and_then(|v| v.trim().trim_end_matches(']').split('.').nth(2)) .and_then(|b| b.trim().parse().ok()); match build { Some(b) if b >= 22000 => format!("Windows 11 (build {b})"), Some(b) => format!("Windows 10 (build {b})"), None => String::new(), } } /// What the problem report fills in on its own. Nothing here identifies the person or the machine. #[tauri::command] async fn report_context( state: State<'_, AppState>, id: String, ) -> std::result::Result { let root = path_of(&state, &id)?; blocking(move || { let (_, meta) = install_meta(&root)?; let bots = coa_core::report::bots(&root); let companions = [ meta.bots.version.clone(), meta.bots .commit .as_ref() .map(|c| c.chars().take(8).collect()), ] .into_iter() .flatten() .collect::>() .join(" В· "); Ok(ReportContext { manager_version: coa_core::MANAGER_VERSION.to_string(), windows: windows_version(), install_kind: if meta.kind == coa_core::registry::InstallKind::New { "new".into() } else { "imported".into() }, server_version: meta.core.version.clone(), suggested_target: bots.suggested.to_string(), bots_version: if bots.suggested == "squid" { bots.squid_version } else if bots.suggested == "companions" && !companions.is_empty() { Some(companions) } else { None }, }) }) .await } #[tauri::command] async fn friends_status( state: State<'_, AppState>, id: String, ) -> std::result::Result { let root = path_of(&state, &id)?; blocking(move || { let meta = meta_dir(&root)?; let ports = layout::read_ports(&root); let automatic = coa_core::net::lan_ip().filter(|ip| coa_core::net::is_lan_address(*ip)); Ok(FriendsStatus { settings: coa_core::friends::load(&meta), lan_ip: automatic.map(|a| a.to_string()), lan_addresses: coa_core::net::lan_addresses(automatic).unwrap_or_default(), exposure: if coa_core::docker::is_docker(&root) { coa_core::docker::exposure(&root, &ports) } else { coa_core::net::exposure(&ports) }, servers_open: coa_core::friends::bind_is_open(&root), // The Windows firewall exists only on Windows; on Linux Docker publishes the ports itself. firewall: (platform::flavor() == Flavor::Repack).then(coa_core::firewall::status), tailscale: coa_core::net::tailscale(), server_running: coa_core::process::observe(&root, &ports).world.state == coa_core::process::ServiceState::Running, auth_port: ports.auth, world_port: ports.world, secondary_world_port: coa_core::realms::state(&root)? .secondary_world_port .filter(|_| coa_core::realms::state(&root).is_ok_and(|s| s.simultaneous)), reborn_world_port: coa_core::realms::state(&root)? .reborn_world_port .filter(|_| coa_core::realms::state(&root).is_ok_and(|s| s.with_reborn)), }) }) .await } #[derive(Serialize)] struct InternetCheck { public_ip: Option, router_ip: Option, reachability: coa_core::net::Reachability, router_found: bool, } /// Talks to an outside address service and to the router. Only runs when the user presses the button. #[tauri::command] async fn friends_check_internet() -> std::result::Result { blocking(move || { let public = coa_core::net::public_ip().ok(); let gw = coa_core::upnp::discover(); let router = gw .as_ref() .and_then(|g| coa_core::upnp::external_ip(g).ok()); Ok(InternetCheck { public_ip: public.map(|a| a.to_string()), router_ip: router.map(|a| a.to_string()), reachability: coa_core::net::classify(router, public), router_found: gw.is_some(), }) }) .await } #[derive(Serialize)] struct FriendsResult { host: String, restart_required: bool, note: Option, } /// Switch how friends connect. `host` is only needed for the internet mode (the public address from the check). #[tauri::command] async fn friends_enable( state: State<'_, AppState>, id: String, mode: coa_core::friends::Mode, host: Option, lan_address_override: Option, use_upnp: bool, ) -> std::result::Result { use coa_core::friends::{self, Mode}; let root = path_of(&state, &id)?; let _guard = BusyGuard::acquire(&state, &id)?; blocking(move || { let meta = meta_dir(&root)?; let ports = layout::read_ports(&root); let mut note = None; let realms = coa_core::realms::state(&root)?; let extra = realms.extra_world_ports(); let host = match mode { Mode::Local => "127.0.0.1".to_string(), Mode::Lan => coa_core::net::resolve_lan_host(lan_address_override.as_deref(), coa_core::net::lan_ip())?, Mode::Direct => host.filter(|h| !h.is_empty()).ok_or_else(|| Error::Invalid("Check your connection first to learn your public address.".into()))?, Mode::Private => coa_core::net::tailscale().ip.ok_or_else(|| Error::Invalid("Tailscale is not connected. Install it, sign in, then try again.".into()))?, }; let open = mode != Mode::Local; let changed = friends::set_open(&root, &meta, open)?; if open && platform::flavor() == Flavor::Repack { coa_core::firewall::ensure_rules_with_extra(&ports, &extra)?; } if mode == Mode::Direct && use_upnp { match coa_core::upnp::discover() { Some(gw) => { let lan = coa_core::net::lan_ip().ok_or_else(|| Error::Invalid("No local address.".into()))?; coa_core::upnp::add_mapping(&gw, ports.auth, lan, "Auth")?; coa_core::upnp::add_mapping(&gw, ports.world, lan, "World")?; for port in &extra { coa_core::upnp::add_mapping(&gw, *port, lan, "Extra world")?; } note = Some("Your router was asked to forward the game ports.".to_string()); } None => note = Some("Your router does not support automatic setup; forward the two game ports by hand or use the private network.".to_string()), } } let mut settings = friends::load(&meta); settings.select_mode(mode, host.clone(), lan_address_override); friends::save(&meta, &settings)?; let running = coa_core::process::observe(&root, &ports).world.state == coa_core::process::ServiceState::Running; if running { friends::apply_realm_address(&root, &settings)?; } Ok(FriendsResult { host, restart_required: changed && running, note }) }) .await } #[tauri::command] async fn friends_package( state: State<'_, AppState>, id: String, ) -> std::result::Result { let root = path_of(&state, &id)?; blocking(move || { let meta = meta_dir(&root)?; let host = coa_core::friends::load(&meta) .host .ok_or_else(|| Error::Invalid("Choose how friends connect first.".into()))?; let desktop = if platform::flavor() == Flavor::Docker { coa_core::diag::desktop_or_temp() } else { std::env::var_os("USERPROFILE") .map(PathBuf::from) .unwrap_or_else(std::env::temp_dir) .join("Desktop") }; let out = if desktop.is_dir() { desktop } else { std::env::temp_dir() } .join("CoA-Friend-Setup.zip"); coa_core::friends::make_friend_package(&root, &host, true, &out)?; Ok(out.to_string_lossy().into_owned()) }) .await } #[tauri::command] async fn run_diagnostics( state: State<'_, AppState>, id: String, ) -> std::result::Result { let root = path_of(&state, &id)?; blocking(move || { let (_, meta) = install_meta(&root)?; Ok(coa_core::diag::run(&root, &meta)) }) .await } #[tauri::command] async fn verify_files( state: State<'_, AppState>, id: String, ) -> std::result::Result, UiError> { let root = path_of(&state, &id)?; blocking(move || { let (_, meta) = install_meta(&root)?; Ok(coa_core::diag::verify_managed(&root, &meta)) }) .await } /// Writes a redacted zip for bug reports to the Desktop and returns its path. #[tauri::command] async fn export_diagnostics( state: State<'_, AppState>, id: String, ) -> std::result::Result { let root = path_of(&state, &id)?; blocking(move || { let (dir, meta) = install_meta(&root)?; let report = coa_core::diag::run(&root, &meta); let out = coa_core::diag::desktop_or_temp() .join(format!("CoA-Diagnostics-{}.zip", coa_core::diag::stamp())); coa_core::diag::export_package( &root, &dir, &data_dir().join("logs").join("manager.log"), &meta, &report, &out, )?; // Show the file in its folder so nobody has to look for it; failing to open the folder is not a failure. let _ = tauri_plugin_opener::reveal_item_in_dir(&out); Ok(out.to_string_lossy().into_owned()) }) .await } #[tauri::command] async fn list_crashes( state: State<'_, AppState>, id: String, limit: Option, ) -> std::result::Result, UiError> { let root = path_of(&state, &id)?; blocking(move || coa_core::crashes::list(&root, limit.unwrap_or(10))).await } #[tauri::command] async fn console_tail( state: State<'_, AppState>, id: String, source: coa_core::console::Source, filter: Option, lines: Option, ) -> std::result::Result, UiError> { let root = path_of(&state, &id)?; blocking(move || { // A Docker server's database writes to its container's output, not to a file. if coa_core::docker::is_docker(&root) && matches!(source, coa_core::console::Source::Database) { return coa_core::docker::logs::database_log( &root, filter.as_deref(), lines.unwrap_or(300).min(2000), ); } let path = coa_core::console::log_path( &root, &data_dir().join("logs").join("manager.log"), source, ); coa_core::console::tail(&path, filter.as_deref(), lines.unwrap_or(300).min(2000)) }) .await } #[tauri::command] fn console_risk(command: String) -> coa_core::console::Risk { coa_core::console::risk(&command) } /// Send one command to the world server console. Risky commands need `confirmed`. #[tauri::command] async fn console_command( state: State<'_, AppState>, id: String, command: String, confirmed: bool, ) -> std::result::Result { let root = path_of(&state, &id)?; blocking(move || { let c = coa_core::console::check_command(&command)?.to_string(); if coa_core::console::risk(&c) == coa_core::console::Risk::Dangerous && !confirmed { return Err(Error::Invalid( "This command can shut things down or change many records. Confirm it first." .into(), )); } tracing::info!(command = %c, "console command"); Ra::connect(&root)?.run(&c) }) .await } #[tauri::command] fn manager_installing(enabled: bool) { QUIT_REQUESTED.store(enabled, std::sync::atomic::Ordering::SeqCst); } #[tauri::command] fn close_manager(app: AppHandle) -> std::result::Result<(), UiError> { if window_preferences::close_to_tray(&data_dir()).unwrap_or(false) { QUIT_REQUESTED.store(false, std::sync::atomic::Ordering::SeqCst); if let Some(window) = app.get_webview_window("main") { window.hide().map_err(|e| Error::Invalid(e.to_string()))?; } } else { QUIT_REQUESTED.store(true, std::sync::atomic::Ordering::SeqCst); app.exit(0); } Ok(()) } #[tauri::command] fn close_to_tray() -> std::result::Result { Ok(window_preferences::close_to_tray(&data_dir())?) } #[tauri::command] fn set_close_to_tray(enabled: bool) -> std::result::Result<(), UiError> { Ok(window_preferences::save(&data_dir(), enabled)?) } #[tauri::command] fn clear_game_cache_on_play() -> bool { window_preferences::clear_cache_on_play(&data_dir()) } #[tauri::command] fn set_clear_game_cache_on_play(enabled: bool) -> std::result::Result<(), UiError> { Ok(window_preferences::save_clear_cache_on_play(&data_dir(), enabled)?) } fn show_main_window(app: &AppHandle) { let handle = app.clone(); if let Err(error) = app.run_on_main_thread(move || { if let Some(window) = handle.get_webview_window("main") { let result = window .unminimize() .and_then(|_| window.show()) .and_then(|_| window.set_focus()); if let Err(error) = result { tracing::error!(%error, "Could not restore the Manager window"); } } else { tracing::error!("The Manager main window is missing"); } }) { tracing::error!(%error, "Could not schedule Manager window restoration"); } } static QUIT_REQUESTED: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false); pub fn run() { let dir = data_dir(); let _ = coa_core::logging::init(&dir.join("logs").join("manager.log")); tauri::Builder::default() .plugin(tauri_plugin_single_instance::init(|app, _, _| { show_main_window(app) })) .plugin(tauri_plugin_dialog::init()) .plugin(tauri_plugin_updater::Builder::new().build()) .plugin(tauri_plugin_process::init()) .invoke_handler(tauri::generate_handler![ server_logging_preset, release_history, default_install_dir, game_data_folder, set_game_data_folder, install_environment, scan_server, add_server, list_servers, forget_server, server_status, start_server, stop_server, force_stop_server, get_settings, save_settings, list_presets, preview_preset, list_config_snapshots, restore_config_snapshot, list_backups, dashboard_status, dashboard_install, dashboard_start, dashboard_open, dashboard_stop, backup_location, set_backup_location, create_backup, verify_backup, delete_backup, restore_backup_configs, restore_backup_database, install_preflight, install_requirements, report_context, list_accounts, realmlist_profiles, realmlist_save, realmlist_delete, realmlist_activate, modules_list, realm_profiles, realm_select, realm_simultaneous, realm_with_reborn, realm_names, realm_rename, mysql_custom, mysql_custom_save, restart_schedule, restart_schedule_save, clear_game_cache_on_play, set_clear_game_cache_on_play, custom_race_characters, purge_custom_race_bots, addons_list, addons_install, addons_remove, check_database, repair_server, module_set_enabled, module_settings, module_save_settings, all_settings, all_settings_save, account_set_password, account_set_access, account_rename, account_delete, install_new, cancel_install, create_account, check_update, pending_update, apply_update, rollback_update, retry_update_validation, get_population, get_performance, companions_stop_spawning, companions_take_offline, companions_delete_all, companions_despawn_some, companions_login_all, companions_spawn_fleet, open_link, report_targets, companion_sizes, add_companions, get_wildcard_archetypes, remote_connection, remote_connect, client_info, client_graphics, client_set_graphics, set_client, client_realmlist, client_install_addon, client_status, client_download_check, client_plan, client_sync, client_download, client_cancel, play, friends_status, friends_check_internet, friends_enable, friends_package, run_diagnostics, verify_files, export_diagnostics, list_crashes, console_tail, console_risk, console_command, custom_races_status, race_availability, race_availability_save, custom_races_install, custom_races_uninstall, custom_races_toggle_client, portable_state, portable_preflight, portable_play, portable_local_characters, portable_make, portable_resolve, portable_history, portable_add_realm, portable_remove_realm, portable_diagnostics, portable_launch, registry_status, portable_preflight_remote, manager_installing, close_manager, close_to_tray, set_close_to_tray, browse_enabled, browse_set_enabled, browse_list, browse_detail, module_catalog, registry_set_url, registry_publish, registry_unpublish, registry_retry, control_cmds::control_status, control_cmds::control_set_preferred_username, control_cmds::registry_set_access, control_cmds::join_realm, control_cmds::join_link, control_cmds::join_account, control_cmds::join_credentials, control_cmds::join_forget, control_cmds::join_characters, control_cmds::join_claim ]) .on_window_event(|window, event| { if let tauri::WindowEvent::CloseRequested { api, .. } = event { if window.label() != "main" { return; } if window_preferences::close_to_tray(&data_dir()).unwrap_or(false) { api.prevent_close(); if let Err(error) = window.hide() { tracing::warn!(%error, "Could not hide the Manager window"); } } else { QUIT_REQUESTED.store(true, std::sync::atomic::Ordering::SeqCst); } } }) .setup(|app| { let dir = data_dir(); // Crash safety: recover any unfinished client realmlist overrides from previous abnormal termination let _ = coa_core::client::revert_realmlist_override(&dir); let portable = start_portable(&dir); let (control, host_control) = control_cmds::start(&dir, portable.clone()); app.manage(AppState { registry: Registry::at(dir.join("installs.json")), busy: Mutex::new(HashSet::new()), install_cancel: Mutex::new(None), client_cancel: Mutex::new(None), portable, realm_registry: start_realm_registry(&dir), control, host_control, }); #[cfg(desktop)] { use tauri::menu::{Menu, MenuItem}; use tauri::tray::{MouseButton, MouseButtonState, TrayIconBuilder, TrayIconEvent}; let show = MenuItem::with_id(app, "show", "Open CoA Server Manager", true, None::<&str>)?; let quit = MenuItem::with_id(app, "quit", "Exit", true, None::<&str>)?; let menu = Menu::with_items(app, &[&show, &quit])?; let mut builder = TrayIconBuilder::new() .tooltip("CoA Server Manager") .menu(&menu) .show_menu_on_left_click(false) .on_menu_event(|app, event| match event.id.as_ref() { "show" => { show_main_window(app); } "quit" => { QUIT_REQUESTED.store(true, std::sync::atomic::Ordering::SeqCst); app.exit(0); } _ => {} }) .on_tray_icon_event(|tray, event| { if let TrayIconEvent::Click { button: MouseButton::Left, button_state: MouseButtonState::Up, .. } = event { let app = tray.app_handle(); show_main_window(app); } }); if let Some(icon) = app.default_window_icon() { builder = builder.icon(icon.clone()); } builder.build(app)?; } Ok(()) }) .build(tauri::generate_context!()) .expect("error while building CoA Server Manager") .run(|app, event| match event { tauri::RunEvent::ExitRequested { api, .. } => { if !QUIT_REQUESTED.load(std::sync::atomic::Ordering::SeqCst) { api.prevent_exit(); } } tauri::RunEvent::Exit => { // the Host loop stops with the application: what it is doing is finished first, the stores keep every session if let Some(rt) = app.state::().portable.clone() { rt.shutdown(); } if let Some(rt) = app.state::().realm_registry.clone() { rt.shutdown(); } if let Some(rt) = app.state::().host_control.clone() { rt.shutdown(); } } _ => {} }); } // ---- Public listing (Registry) ----------------------------------------------------------------------------------------------- fn realm_registry( state: &State<'_, AppState>, ) -> std::result::Result, UiError> { state .realm_registry .clone() .ok_or_else(|| Error::Invalid("the publishing service did not start".into()).into()) } #[tauri::command] async fn portable_preflight_remote( state: State<'_, AppState>, character: String, capabilities: serde_json::Value, ) -> std::result::Result { portable_call(&state, move |s| { s.preflight_advert(&character, &capabilities) }) .await } fn browse_client() -> std::result::Result { browse_preferences::require_enabled(&data_dir())?; let settings = coa_core::realm_registry::settings::load(&data_dir().join("registry"))?; let url = std::env::var("COA_REGISTRY_URL") .ok() .filter(|u| !u.is_empty()) .unwrap_or_else(|| settings.effective_url().to_string()); Ok(coa_core::realm_registry::BrowseClient::new(&url)?) } #[tauri::command] fn browse_enabled() -> std::result::Result { Ok(browse_preferences::enabled(&data_dir())?) } #[tauri::command] fn browse_set_enabled(enabled: bool) -> std::result::Result<(), UiError> { Ok(browse_preferences::save(&data_dir(), enabled)?) } fn browse_error(e: coa_core::realm_registry::ClientError) -> UiError { Error::Invalid(e.to_string()).into() } /// One page of the public realm list (a plain read of the Registry; nothing about the player is sent). #[tauri::command] async fn browse_list( params: coa_core::realm_registry::BrowseParams, ) -> std::result::Result { tauri::async_runtime::spawn_blocking(move || { let query = params.to_query()?; browse_client()?.list(&query).map_err(browse_error) }) .await .map_err(|e| Error::Invalid(e.to_string()))? } #[tauri::command] async fn browse_detail( realm_id: String, ) -> std::result::Result { tauri::async_runtime::spawn_blocking(move || { let id = coa_registry_proto::RealmId::parse(&realm_id) .map_err(|e| Error::Invalid(e.to_string()))?; browse_client()?.detail(&id).map_err(browse_error) }) .await .map_err(|e| Error::Invalid(e.to_string()))? } #[derive(serde::Serialize)] struct ModuleInfo { id: String, name: String, description: std::collections::BTreeMap, status: String, icon: String, } /// The Manager's own module catalog: names and descriptions of the modules a realm's advertisement lists by id. #[tauri::command] fn module_catalog() -> Vec { coa_core::modules::catalog() .into_iter() .map(|e| ModuleInfo { id: e.id, name: e.name, description: e.description, status: e.status, icon: e.icon, }) .collect() } #[tauri::command] fn registry_status(state: State<'_, AppState>) -> coa_core::realm_registry::RegistryStatus { state .realm_registry .as_ref() .map(|r| r.status()) .unwrap_or_default() } #[tauri::command] async fn registry_set_url( state: State<'_, AppState>, url: Option, ) -> std::result::Result<(), UiError> { let rt = realm_registry(&state)?; tauri::async_runtime::spawn_blocking(move || rt.set_url(url)) .await .map_err(|e| Error::Invalid(e.to_string()))? .map_err(UiError::from) } #[tauri::command] async fn registry_publish( state: State<'_, AppState>, local_id: String, display_name: String, description: String, language: String, region: Option, ) -> std::result::Result<(), UiError> { let rt = realm_registry(&state)?; tauri::async_runtime::spawn_blocking(move || { rt.publish( &local_id, &display_name, &description, &language, region.as_deref(), ) }) .await .map_err(|e| Error::Invalid(e.to_string()))? .map_err(UiError::from) } #[tauri::command] async fn registry_unpublish( state: State<'_, AppState>, local_id: String, ) -> std::result::Result<(), UiError> { let rt = realm_registry(&state)?; tauri::async_runtime::spawn_blocking(move || rt.unpublish(&local_id)) .await .map_err(|e| Error::Invalid(e.to_string()))? .map_err(UiError::from) } #[tauri::command] fn registry_retry(state: State<'_, AppState>, local_id: String) { if let Some(r) = &state.realm_registry { r.retry(&local_id); } } fn start_realm_registry( dir: &std::path::Path, ) -> Option> { use coa_core::realm_registry::{FileKeyStore, LocalRealmsSource, RegistryRuntime}; let installs = Registry::at(dir.join("installs.json")); let registry_dir = dir.join("registry"); let source = LocalRealmsSource::with_provisioning( dir.join("portable").join("realms"), move || installs.list().unwrap_or_default(), move |local_id| { // a realm creates accounts for joining players unless its owner said it only links the ones that exist coa_core::realm_registry::settings::load(®istry_dir) .ok() .and_then(|s| s.realms.get(local_id).map(|c| !c.existing_only)) .unwrap_or(true) }, ); let keys = FileKeyStore::new(dir.join("registry").join("keys")); match RegistryRuntime::start(&dir.join("registry"), Arc::new(keys), Arc::new(source)) { Ok(rt) => Some(Arc::new(rt)), Err(e) => { tracing::error!(error = %e, "the publishing service did not start"); None } } } fn start_portable(dir: &std::path::Path) -> Option> { let registry = Registry::at(dir.join("installs.json")); let control = InstallControl { registry: Registry::at(dir.join("installs.json")), }; let installs: portable_service::runtime::Installs = Box::new(move || registry.list().unwrap_or_default()); match PortableRuntime::start(&dir.join("portable"), installs, Some(Box::new(control))) { Ok(rt) => Some(Arc::new(rt)), Err(e) => { tracing::error!(error = %e, "the portable play service did not start"); None } } } #[cfg(all(test, not(windows)))] mod tests { use super::unix_data_home; use std::ffi::OsString; use std::path::PathBuf; fn os(s: &str) -> Option { Some(s.into()) } #[test] fn data_home_prefers_an_absolute_xdg_folder() { assert_eq!( unix_data_home(os("/data/xdg"), os("/home/u")), PathBuf::from("/data/xdg") ); } #[test] fn data_home_ignores_a_relative_xdg_folder_and_falls_back_to_home() { assert_eq!( unix_data_home(os("relative/dir"), os("/home/u")), PathBuf::from("/home/u/.local/share") ); assert_eq!( unix_data_home(None, os("/home/u")), PathBuf::from("/home/u/.local/share") ); } #[test] fn data_home_without_any_variable_uses_the_temp_folder() { assert_eq!(unix_data_home(None, None), std::env::temp_dir()); } }