mirror of
https://github.com/Corfirean/coa-server-manager.git
synced 2026-11-18 19:25:56 +00:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
ee59708fbf | ||
|
|
3ed9c5dacd | ||
|
|
9099168927 | ||
|
|
a27e0eb6ab | ||
|
|
c46edd2feb | ||
|
|
f934bef303 | ||
|
|
c882a21334 | ||
|
|
a625b065cf | ||
|
|
5c3a9def0c | ||
|
|
25098b5a63 | ||
|
|
45a699d2ca | ||
|
|
be68eb4341 | ||
|
|
58c1e1aee0 | ||
|
|
ad69fb0401 | ||
|
|
3f98ba3add | ||
|
|
7a3fefaafd |
No files matched your search
Generated
+3
-3
@@ -491,7 +491,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "coa-core"
|
||||
version = "0.6.7"
|
||||
version = "0.6.8"
|
||||
dependencies = [
|
||||
"base64 0.22.1",
|
||||
"chrono",
|
||||
@@ -520,7 +520,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "coa-release"
|
||||
version = "0.6.7"
|
||||
version = "0.6.8"
|
||||
dependencies = [
|
||||
"chrono",
|
||||
"coa-core",
|
||||
@@ -529,7 +529,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "coa-server-manager"
|
||||
version = "0.6.7"
|
||||
version = "0.6.8"
|
||||
dependencies = [
|
||||
"coa-core",
|
||||
"serde",
|
||||
|
||||
+1
-1
@@ -3,7 +3,7 @@ resolver = "2"
|
||||
members = ["crates/coa-core", "crates/coa-release", "src-tauri"]
|
||||
|
||||
[workspace.package]
|
||||
version = "0.6.7"
|
||||
version = "0.6.8"
|
||||
edition = "2021"
|
||||
license = "AGPL-3.0-only"
|
||||
|
||||
|
||||
@@ -0,0 +1,29 @@
|
||||
# TODO
|
||||
|
||||
## UI / UX
|
||||
- [x] **Предупреждение о несохранённых изменениях при переходе между вкладками (Unsaved Changes Guard / Modal)**:
|
||||
- Если у пользователя есть несохранённые изменения в настройках (`ModulesPage`, `SettingsPage` — сервер, боты и др.) и он переходит на другую вкладку (в боковом меню `Shell.tsx` или кнопками навигации), показывать pop-up диалог подтверждения.
|
||||
- Опции в диалоге:
|
||||
- **Сохранить (Save)** — сохранить внесённые изменения и перейти на выбранную страницу.
|
||||
- **Сбросить (Discard)** — отменить несохранённые изменения и перейти на выбранную страницу.
|
||||
- **Отмена (Cancel)** — остаться на текущей странице с сохранением введённых данных.
|
||||
- *Контекст:* Предотвратит случайную потерю настроек, когда пользователь меняет параметры модуля/сервера и сразу уходит на вкладку Overview для запуска сервера (см. [Issue #45](https://github.com/Corfirean/coa-server-manager/issues/45)).
|
||||
|
||||
## Сервер и стабильность
|
||||
- [x] **Автоподнятие сервера при падении (Auto-restart on crash) со счётчиком и расшифровкой крашей**:
|
||||
- **Настройка:** Чекбокс «Автоматически перезапускать сервер при падении» в настройках сервера / менеджера.
|
||||
- **Поведение автоподнятия:**
|
||||
- Перезапускать процесс сервера только если падение произошло внезапно (процесс завершился с ненулевым exit code, крашем или без команды от менеджера).
|
||||
- Если пользователь нажал кнопку «Стоп» (Stop Server), сервер останавливается полностью, автоподнятие не срабатывает.
|
||||
- Защита от бесконечного цикла крашей (Crash Loop Protection): если за короткий интервал (например, 2-3 минуты) сервер падает более 3-5 раз, автоподнятие временно прекращается, а в UI выводится критическое оповещение.
|
||||
- **Счётчик падений в интерфейсе:**
|
||||
- Рядом со статусом сервера (или в шапке/панели состояния) показывать бейдж со счётчиком крашей с момента старта (например: `Крашей: 2`).
|
||||
- При клике на счётчик открывать окно / модалку со списком последних падений с точным временем.
|
||||
- **Расшифровка причин краша (Crash Explanation Engine):**
|
||||
- *Как парсить и определять причину:*
|
||||
1. Читать свежий текстовый файл из `Core/Crashes/<hash>_worldserver.exe_[date].txt`.
|
||||
2. Смотреть `Exception code` (например, `C0000005` — нарушение доступа к памяти/access violation, `C0000420` — сработавший assert ядра, `C00000FD` — переполнение стека, `E06D7363` — исключение C++ / std::bad_alloc).
|
||||
3. При `C0000420` парсить блок `ASSERTION FAILED` (`Location`, `Function`, `Condition`).
|
||||
4. Анализировать последние строки `Core/Logs/Server.log` и `Errors.log` на критические маркеры (потеря соединения с MySQL, нехватка RAM/OOM, ошибка бинда портов).
|
||||
5. Проверять по встроенному словарю известных сигнатур (паттерны частых крашей с понятным описанием, например: «Сбой удаления объекта из сетки карты», «Ошибка запроса к базе данных», «Нехватка оперативной памяти»).
|
||||
- *Fallback:* Если сигнатура не опознана в словаре известных проблем, показывать краткую техническую выжимку (код исключения + сработавший ассерт или вершина Call Stack) и кнопку разворота полного текста крашлога / копирования.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: added
|
||||
audience: admins
|
||||
title: Linux: install from the install screen, play with Wine or Proton (experimental)
|
||||
---
|
||||
Experimental. The install screen offers Docker installs on Linux, realm profiles and the Play button work on a Docker server, and updates are not offered for it.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: fixed
|
||||
audience: admins
|
||||
title: A failing database update is no longer reported as "database not running"
|
||||
---
|
||||
An SQL error whose message contained the number 2003, such as an out-of-range value, was shown as "The database is not running". The real error is now shown.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: added
|
||||
audience: admins
|
||||
title: Unsaved settings are protected and crashed servers can restart automatically
|
||||
---
|
||||
The Manager asks before leaving unsaved settings. Optional automatic restart pauses after repeated crashes, and crash history explains common failures.
|
||||
@@ -17,6 +17,9 @@ pub const ADDON_NAME: &str = "CoABotUI";
|
||||
const EXECUTABLES: [&str; 3] = ["Ascension.exe", "Wow.exe", "WoW.exe"];
|
||||
|
||||
pub fn is_running(client: &Path) -> bool {
|
||||
if crate::platform::flavor() == crate::platform::Flavor::Docker {
|
||||
return crate::wine::is_running(client, &EXECUTABLES);
|
||||
}
|
||||
EXECUTABLES.iter().any(|exe| {
|
||||
let path = client.join(exe);
|
||||
let path = dunce::canonicalize(&path).unwrap_or(path);
|
||||
@@ -307,6 +310,9 @@ pub fn install_addon(client: &Path, meta: &Path, source: &Path) -> Result<()> {
|
||||
/// Start the game client. The caller is responsible for making sure the server is ready first.
|
||||
pub fn launch(client: &Path) -> Result<u32> {
|
||||
let exe = find_exe(client).ok_or_else(|| Error::Invalid("The game client was not found.".into()))?;
|
||||
if crate::platform::flavor() == crate::platform::Flavor::Docker {
|
||||
return crate::wine::launch(client, exe);
|
||||
}
|
||||
let child = Command::new(client.join(exe)).current_dir(client).spawn()?;
|
||||
Ok(child.id())
|
||||
}
|
||||
|
||||
@@ -0,0 +1,249 @@
|
||||
//! Crash log discovery and human-friendly explanation for worldserver crashes.
|
||||
|
||||
use std::fs;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::time::SystemTime;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use crate::error::Result;
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
|
||||
pub struct CrashItem {
|
||||
pub id: String,
|
||||
pub timestamp_ms: u64,
|
||||
pub date_str: String,
|
||||
pub title: String,
|
||||
pub explanation: String,
|
||||
pub category: String,
|
||||
pub exception_code: Option<String>,
|
||||
pub location: Option<String>,
|
||||
pub function: Option<String>,
|
||||
pub condition: Option<String>,
|
||||
pub preview: String,
|
||||
pub full_log: String,
|
||||
}
|
||||
|
||||
/// Lists recent crash reports from `Core/Crashes`, sorted newest first.
|
||||
pub fn list(root: &Path, limit: usize) -> Result<Vec<CrashItem>> {
|
||||
let dir = root.join("Core/Crashes");
|
||||
let mut files: Vec<(PathBuf, SystemTime)> = Vec::new();
|
||||
if let Ok(entries) = fs::read_dir(&dir) {
|
||||
for entry in entries.flatten() {
|
||||
let path = entry.path();
|
||||
if path.is_file() && path.extension().and_then(|e| e.to_str()) == Some("txt") {
|
||||
let mtime = entry.metadata().and_then(|m| m.modified()).unwrap_or(SystemTime::UNIX_EPOCH);
|
||||
files.push((path, mtime));
|
||||
}
|
||||
}
|
||||
}
|
||||
files.sort_by_key(|(_, t)| std::cmp::Reverse(*t));
|
||||
files.truncate(limit.max(1));
|
||||
|
||||
let mut items = Vec::new();
|
||||
for (path, mtime) in files {
|
||||
if let Ok(content) = fs::read_to_string(&path) {
|
||||
let item = parse_crash_content(&path, mtime, &content);
|
||||
items.push(item);
|
||||
}
|
||||
}
|
||||
Ok(items)
|
||||
}
|
||||
|
||||
/// Parses crash report content and generates human-friendly titles and explanations.
|
||||
pub fn parse_crash_content(path: &Path, mtime: SystemTime, content: &str) -> CrashItem {
|
||||
let filename = path.file_name().unwrap_or_default().to_string_lossy().into_owned();
|
||||
let timestamp_ms = mtime.duration_since(SystemTime::UNIX_EPOCH).map(|d| d.as_millis() as u64).unwrap_or(0);
|
||||
|
||||
let mut date_str = String::new();
|
||||
let mut exception_code = None;
|
||||
let mut location = None;
|
||||
let mut function = None;
|
||||
let mut condition = None;
|
||||
|
||||
let lines: Vec<&str> = content.lines().collect();
|
||||
|
||||
let mut in_assertion = false;
|
||||
for line in &lines {
|
||||
let trimmed = line.trim();
|
||||
if trimmed.starts_with("Date ") && date_str.is_empty() {
|
||||
date_str = trimmed.to_string();
|
||||
} else if trimmed.starts_with("Exception code:") {
|
||||
let parts: Vec<&str> = trimmed.split_whitespace().collect();
|
||||
if parts.len() >= 3 {
|
||||
exception_code = Some(parts[2].to_string());
|
||||
}
|
||||
} else if trimmed.contains(">> ASSERTION FAILED") {
|
||||
in_assertion = true;
|
||||
} else if in_assertion {
|
||||
if trimmed.starts_with("# Location:") {
|
||||
let loc = trimmed.trim_start_matches("# Location:").trim();
|
||||
let clean = loc.rsplit(['\\', '/']).take(2).collect::<Vec<_>>();
|
||||
location = Some(if clean.len() == 2 { format!("{}/{}", clean[1], clean[0]) } else { loc.to_string() });
|
||||
} else if trimmed.starts_with("# Function:") {
|
||||
function = Some(trimmed.trim_start_matches("# Function:").trim().to_string());
|
||||
} else if trimmed.starts_with("# Condition:") {
|
||||
condition = Some(trimmed.trim_start_matches("# Condition:").trim().to_string());
|
||||
} else if trimmed.starts_with("#---") && condition.is_some() {
|
||||
in_assertion = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if date_str.is_empty() {
|
||||
if let Some(pos) = filename.find("_[") {
|
||||
if let Some(end) = filename[pos..].find(']') {
|
||||
date_str = filename[pos + 2..pos + end].replace('_', " ");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let (category, title, explanation) = explain(exception_code.as_deref(), function.as_deref(), condition.as_deref(), content);
|
||||
|
||||
let preview_lines: Vec<&str> = lines.iter().take(25).copied().collect();
|
||||
let preview = preview_lines.join("\n");
|
||||
|
||||
CrashItem {
|
||||
id: filename,
|
||||
timestamp_ms,
|
||||
date_str,
|
||||
title,
|
||||
explanation,
|
||||
category,
|
||||
exception_code,
|
||||
location,
|
||||
function,
|
||||
condition,
|
||||
preview,
|
||||
full_log: content.to_string(),
|
||||
}
|
||||
}
|
||||
|
||||
fn explain(code: Option<&str>, func: Option<&str>, cond: Option<&str>, full: &str) -> (String, String, String) {
|
||||
let lower_full = full.to_lowercase();
|
||||
let lower_func = func.map(|f| f.to_lowercase()).unwrap_or_default();
|
||||
let lower_cond = cond.map(|c| c.to_lowercase()).unwrap_or_default();
|
||||
|
||||
if let Some(c) = code {
|
||||
if c.eq_ignore_ascii_case("C0000420") {
|
||||
if lower_func.contains("removefromgrid") || lower_cond.contains("isingrid") {
|
||||
return (
|
||||
"assertion".into(),
|
||||
"Сбой удаления сущности из сетки карты (Grid / Despawn)".into(),
|
||||
"Сервер попытался выгрузить объект (игрока, NPC или бота), который уже не находился в сетке карты. Обычно происходит при резком разрыве соединения, телепортации или одновременном деспавне нескольких сущностей.".into(),
|
||||
);
|
||||
}
|
||||
if lower_func.contains("map::") || lower_func.contains("grid::") {
|
||||
return (
|
||||
"assertion".into(),
|
||||
"Ошибка обновления сетки игрового мира (Map Grid)".into(),
|
||||
"Сбой при загрузке или обновлении клеток локации (Grid/Cell). Может быть вызван перемещением сущностей через границы чанков.".into(),
|
||||
);
|
||||
}
|
||||
if lower_func.contains("playerbot") || lower_func.contains("aiplayerbot") {
|
||||
return (
|
||||
"assertion".into(),
|
||||
"Ошибка в модуле ботов (Playerbots)".into(),
|
||||
"Внутренний сбой в логике ИИ ботов (экипировка, заклинание или поиск пути).".into(),
|
||||
);
|
||||
}
|
||||
let cond_label = cond.unwrap_or("Assert condition failed");
|
||||
return (
|
||||
"assertion".into(),
|
||||
format!("Сработала внутренняя проверка ядра ({cond_label})"),
|
||||
format!("Сервер обнаружил нарушение целостности данных в функции {}. Выполнение было аварийно остановлено.", func.unwrap_or("неизвестно")),
|
||||
);
|
||||
} else if c.eq_ignore_ascii_case("C0000005") {
|
||||
return (
|
||||
"access_violation".into(),
|
||||
"Нарушение доступа к памяти (Access Violation)".into(),
|
||||
"Попытка чтения или записи по некорректному адресу памяти (разыменование null-указателя или освобождённого объекта).".into(),
|
||||
);
|
||||
} else if c.eq_ignore_ascii_case("C00000FD") {
|
||||
return (
|
||||
"stack_overflow".into(),
|
||||
"Переполнение стека (Stack Overflow)".into(),
|
||||
"Исчерпание стека вызовов, вызванное бесконечной рекурсией или слишком глубоким стеком вызовов функций.".into(),
|
||||
);
|
||||
} else if c.eq_ignore_ascii_case("E06D7363") {
|
||||
if lower_full.contains("bad_alloc") {
|
||||
return (
|
||||
"out_of_memory".into(),
|
||||
"Нехватка оперативной памяти (Out of Memory)".into(),
|
||||
"Серверу не удалось выделить оперативную память (std::bad_alloc). Проверьте объем доступной RAM.".into(),
|
||||
);
|
||||
}
|
||||
return (
|
||||
"exception".into(),
|
||||
"Необработанное исключение C++ (C++ Exception)".into(),
|
||||
"Произошло критическое исключение C++, которое не было перехвачено ядром сервера.".into(),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
if lower_full.contains("mysql server has gone away") || lower_full.contains("connection lost") {
|
||||
return (
|
||||
"database".into(),
|
||||
"Потеряна связь с базой данных (MySQL)".into(),
|
||||
"Связь сервера с СУБД MySQL была прервана или служба базы данных упала.".into(),
|
||||
);
|
||||
}
|
||||
|
||||
if lower_full.contains("address already in use") || lower_full.contains("bind failed") {
|
||||
return (
|
||||
"network".into(),
|
||||
"Сетевой порт уже занят".into(),
|
||||
"Порт мира, авторизации или базы данных уже занят другим приложением.".into(),
|
||||
);
|
||||
}
|
||||
|
||||
(
|
||||
"generic".into(),
|
||||
"Непредвиденный сбой процесса сервера".into(),
|
||||
"Процесс worldserver аварийно завершился. Детали и стек вызовов доступны в полном тексте отчёта.".into(),
|
||||
)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn parses_assertion_report() {
|
||||
let report = r#"Revision: AzerothCore rev. df5bcdf26092 2026-10-02 22:08:42 +0500 (coa-bots branch) (Win64, RelWithDebInfo, Static)
|
||||
Date 3:10:2026. Time 20:20
|
||||
//=====================================================
|
||||
Exception code: C0000420 Ein Assertionsfehler ist aufgetreten.
|
||||
|
||||
Assertion message: #----------------------------------------------------------------------#
|
||||
|
||||
>> ASSERTION FAILED
|
||||
|
||||
# Location: D:\a\coa-server-build\src\server\game\Entities\Object\Object.h:376
|
||||
# Function: GridObject<class Player>::RemoveFromGrid
|
||||
# Condition: IsInGrid()
|
||||
|
||||
#----------------------------------------------------------------------#
|
||||
|
||||
Fault address: 00007FF7ECD3645E
|
||||
"#;
|
||||
let item = parse_crash_content(Path::new("dummy_worldserver.exe_[3-10_20-20-51].txt"), SystemTime::UNIX_EPOCH, report);
|
||||
println!("ITEM: {item:#?}");
|
||||
assert_eq!(item.exception_code.as_deref(), Some("C0000420"));
|
||||
assert_eq!(item.category, "assertion");
|
||||
assert_eq!(item.condition.as_deref(), Some("IsInGrid()"));
|
||||
assert_eq!(item.function.as_deref(), Some("GridObject<class Player>::RemoveFromGrid"));
|
||||
assert!(item.title.contains("Grid"));
|
||||
assert!(item.explanation.contains("сетке карты"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parses_access_violation() {
|
||||
let report = r#"Date 4:10:2026. Time 12:00
|
||||
Exception code: C0000005 ACCESS_VIOLATION
|
||||
Fault address: 00007FF7ECD3645E
|
||||
"#;
|
||||
let item = parse_crash_content(Path::new("crash.txt"), SystemTime::UNIX_EPOCH, report);
|
||||
assert_eq!(item.exception_code.as_deref(), Some("C0000005"));
|
||||
assert_eq!(item.category, "access_violation");
|
||||
assert!(item.title.contains("Access Violation"));
|
||||
}
|
||||
}
|
||||
@@ -176,10 +176,13 @@ impl Db {
|
||||
|
||||
fn fail(&self, stderr: &[u8]) -> Error {
|
||||
let text = String::from_utf8_lossy(stderr);
|
||||
let down = text.contains("2003") || text.contains("Can't connect") || text.contains("is not running") || text.contains("No such container");
|
||||
// Only the client's own connection errors mean "not running": the number 2003 or the words can also appear inside
|
||||
// the message of an ordinary SQL error (a duplicate entry, a row number) and must not hide it.
|
||||
let down = text.contains("ERROR 2003") || text.contains("ERROR 2002") || text.contains("Can't connect to MySQL server")
|
||||
|| text.contains("No such container") || text.contains("is not running");
|
||||
let code = if down { ErrorCode::DatabaseNotRunning } else { ErrorCode::Unknown };
|
||||
match code {
|
||||
ErrorCode::DatabaseNotRunning => Error::Invalid("The database is not running. Start the server first.".into()),
|
||||
ErrorCode::DatabaseNotRunning => Error::Invalid(format!("The database is not running. Start the server first. ({})", text.trim().lines().last().unwrap_or("").chars().take(300).collect::<String>())),
|
||||
_ => Error::Invalid(format!("database command failed: {}", text.trim().lines().last().unwrap_or(""))),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,69 @@
|
||||
//! The disposable database a release is validated against, on a Linux computer.
|
||||
//!
|
||||
//! A release is checked by applying its database changes to the database of the signed base package. The base carries the
|
||||
//! MySQL data directory of a Windows repack, and a MySQL 8.4 server in Docker opens it as it is (with the repack's table
|
||||
//! name setting). So the fixture is a Docker server folder whose database container uses that directory in place of a
|
||||
//! volume; everything else (start, SQL, schema capture, dumps) is the code of a Docker installation.
|
||||
|
||||
use std::fs;
|
||||
use std::path::Path;
|
||||
|
||||
use super::{Config, Docker, MARKER, MYSQL_IMAGE};
|
||||
use crate::driver::{self, Verb};
|
||||
use crate::error::{Error, Result};
|
||||
use crate::{fsx, install, package};
|
||||
|
||||
/// Turn an extracted base package (`mysql/data`, `Settings/`) into a Docker server folder and start its database.
|
||||
pub fn prepare(root: &Path) -> Result<()> {
|
||||
prepare_with(&super::SystemDocker, root)
|
||||
}
|
||||
|
||||
pub(crate) fn prepare_with(d: &dyn Docker, root: &Path) -> Result<()> {
|
||||
let boot = root.join(package::BOOTSTRAP_CREDENTIALS);
|
||||
if !boot.is_file() {
|
||||
return Err(Error::Invalid("The package has no database bootstrap information.".into()));
|
||||
}
|
||||
let secrets: serde_json::Value = fsx::read_json(&boot)?;
|
||||
let root_pw = secrets["rootPassword"].as_str().filter(|p| p.chars().all(|c| c.is_ascii_hexdigit()) && !p.is_empty())
|
||||
.ok_or_else(|| Error::Invalid("The database bootstrap information is not usable.".into()))?.to_string();
|
||||
fs::copy(&boot, root.join("Settings/database.json"))?;
|
||||
let data = fs::canonicalize(root.join("mysql/data"))
|
||||
.map_err(|_| Error::Invalid("The package has no database data directory.".into()))?;
|
||||
let cfg = Config {
|
||||
project: format!("schema-{}", install::random_hex(8)),
|
||||
bind_address: "127.0.0.1".into(),
|
||||
mysql_image: MYSQL_IMAGE.into(),
|
||||
data_dir: None,
|
||||
mysql_data: Some(data.to_string_lossy().into_owned()),
|
||||
};
|
||||
fsx::atomic_write_json(&root.join(MARKER), &cfg)?;
|
||||
|
||||
let started = driver::run(root, Verb::StartMysql)?;
|
||||
if !started.ok {
|
||||
return Err(Error::Invalid(started.human.map(|h| h.message.to_string()).unwrap_or_else(|| "The database could not be started.".into())));
|
||||
}
|
||||
// The repack's administrator account only exists for connections from the server itself (the socket); the Manager
|
||||
// connects over TCP. The fixture is thrown away, so the account is simply added.
|
||||
let sql = format!("CREATE USER IF NOT EXISTS 'root'@'127.0.0.1' IDENTIFIED BY '{root_pw}'; GRANT ALL ON *.* TO 'root'@'127.0.0.1' WITH GRANT OPTION;");
|
||||
let mut call = super::Call::new(&["exec", "-i", "-e", "MYSQL_PWD", &cfg.names().db, "mysql", "--user=root"], std::time::Duration::from_secs(60));
|
||||
call.env = vec![("MYSQL_PWD".into(), root_pw)];
|
||||
call.stdin = Some(sql.as_bytes());
|
||||
let o = d.run(&call)?;
|
||||
if !o.ok() {
|
||||
return Err(Error::Invalid(format!("The fixture database could not be opened to the Manager: {}", o.text())));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn a_package_without_bootstrap_information_is_refused_before_anything_starts() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let err = prepare(dir.path()).unwrap_err();
|
||||
assert!(err.to_string().contains("bootstrap"), "{err}");
|
||||
assert!(!dir.path().join(MARKER).exists());
|
||||
}
|
||||
}
|
||||
@@ -146,7 +146,7 @@ fn write_settings(root: &Path, data_dir: &Path) -> Result<Settings> {
|
||||
let (auth, world, ra) = (pick_port(DEFAULT_PORTS.0)?, pick_port(DEFAULT_PORTS.1)?, pick_port(DEFAULT_PORTS.2)?);
|
||||
let (root_password, app_password) = (random_hex(48), random_hex(48));
|
||||
fs::create_dir_all(root.join("Settings"))?;
|
||||
let docker = Config { project, bind_address: "127.0.0.1".into(), mysql_image: super::MYSQL_IMAGE.into(), data_dir: Some(data_dir.to_string_lossy().into_owned()) };
|
||||
let docker = Config { project, bind_address: "127.0.0.1".into(), mysql_image: super::MYSQL_IMAGE.into(), data_dir: Some(data_dir.to_string_lossy().into_owned()), mysql_data: None };
|
||||
fsx::atomic_write_json(&root.join(MARKER), &docker)?;
|
||||
// Same file and keys as a repack, so the console, the ports and the settings screens work unchanged. The database is
|
||||
// not published on the host; its port is only there to fill the key.
|
||||
|
||||
@@ -210,7 +210,7 @@ fn start(d: &dyn Docker, root: &Path, cfg: &Config, with_game: bool, log: &mut L
|
||||
if !state.get(&n.db).is_some_and(Container::running) {
|
||||
remove(d, &n.db);
|
||||
let mut call = Call::new(&[], Duration::from_secs(120));
|
||||
call.args = db_args(cfg, &n);
|
||||
call.args = db_args(cfg, &n, owner_of(root).as_deref());
|
||||
call.env = vec![("MYSQL_ROOT_PASSWORD".into(), secrets.root.clone())];
|
||||
let o = d.run(&call).or_else(|e| fail(ErrorCode::DockerUnavailable, e.to_string()))?;
|
||||
if !o.ok() {
|
||||
@@ -223,6 +223,10 @@ fn start(d: &dyn Docker, root: &Path, cfg: &Config, with_game: bool, log: &mut L
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
// Realm profiles (CoA / Wildcard): the database is running and healthy here (started and waited for above), which the
|
||||
// realm list update below needs. Finish an interrupted switch, then make the realm list say what is selected. The repack's
|
||||
// launcher did this when it started; here nothing else would.
|
||||
let realm = prepare_realm(root, log)?;
|
||||
ensure_image(d, log)?;
|
||||
super::ensure_main_configs(root).map_err(|e| Failure { code: ErrorCode::ServerFilesIncomplete, output: e.to_string() })?;
|
||||
std::fs::create_dir_all(root.join("Core/Logs")).map_err(|e| Failure { code: ErrorCode::ServerFilesIncomplete, output: e.to_string() })?;
|
||||
@@ -234,7 +238,7 @@ fn start(d: &dyn Docker, root: &Path, cfg: &Config, with_game: bool, log: &mut L
|
||||
remove(d, &n.world);
|
||||
let mut call = Call::new(&[], Duration::from_secs(60));
|
||||
call.args = game_args(cfg, &n, GameKind::World, &host, &cfg.data_path(&host), ports.world, ports.ra, owner.as_deref());
|
||||
call.env = database_env(&secrets, true);
|
||||
call.env = database_env(&secrets, true, realm);
|
||||
run_container(d, &call, &n.world, log)?;
|
||||
}
|
||||
wait_listening(d, cfg, &n.world, ports.world, WORLD_WAIT, log)?;
|
||||
@@ -243,7 +247,7 @@ fn start(d: &dyn Docker, root: &Path, cfg: &Config, with_game: bool, log: &mut L
|
||||
remove(d, &n.auth);
|
||||
let mut call = Call::new(&[], Duration::from_secs(60));
|
||||
call.args = game_args(cfg, &n, GameKind::Auth, &host, &cfg.data_path(&host), ports.auth, 0, owner.as_deref());
|
||||
call.env = database_env(&secrets, false);
|
||||
call.env = database_env(&secrets, false, realm);
|
||||
run_container(d, &call, &n.auth, log)?;
|
||||
}
|
||||
wait_listening(d, cfg, &n.auth, ports.auth, AUTH_WAIT, log)?;
|
||||
@@ -333,12 +337,22 @@ fn connect_ip(cfg: &Config) -> IpAddr {
|
||||
|
||||
// ------------------------------------------------------------------------------------------------- argument lists
|
||||
|
||||
fn db_args(cfg: &Config, n: &Names) -> Vec<String> {
|
||||
fn db_args(cfg: &Config, n: &Names, owner: Option<&str>) -> Vec<String> {
|
||||
let mut a: Vec<String> = ["run", "--detach", "--name"].iter().map(|s| s.to_string()).collect();
|
||||
a.push(n.db.clone());
|
||||
a.extend(["--network".into(), n.network.clone(), "--network-alias".into(), "db".into()]);
|
||||
a.extend(["--label".into(), format!("coa.project={}", cfg.project)]);
|
||||
a.extend(["--volume".into(), format!("{}:/var/lib/mysql", n.volume)]);
|
||||
match &cfg.mysql_data {
|
||||
Some(dir) => {
|
||||
// A data directory from a Windows repack: it is written by the person who owns the folder, and its table names
|
||||
// were folded to lower case (the repack's setting), which the server must be told because a Linux one does not.
|
||||
a.extend(["--volume".into(), format!("{dir}:/var/lib/mysql")]);
|
||||
if let Some(o) = owner {
|
||||
a.extend(["--user".into(), o.into()]);
|
||||
}
|
||||
}
|
||||
None => a.extend(["--volume".into(), format!("{}:/var/lib/mysql", n.volume)]),
|
||||
}
|
||||
// The password comes from the environment of the docker client, not from this command line.
|
||||
a.extend(["--env".into(), "MYSQL_ROOT_PASSWORD".into()]);
|
||||
// "mysqladmin ping" succeeds as soon as the server answers, with or without a login. It must go over TCP, like
|
||||
@@ -349,6 +363,9 @@ fn db_args(cfg: &Config, n: &Names) -> Vec<String> {
|
||||
a.extend(["--health-interval".into(), "5s".into(), "--health-timeout".into(), "5s".into(), "--health-retries".into(), "40".into()]);
|
||||
a.extend(["--stop-timeout".into(), "60".into()]);
|
||||
a.push(cfg.mysql_image.clone());
|
||||
if cfg.mysql_data.is_some() {
|
||||
a.push("--lower-case-table-names=1".into());
|
||||
}
|
||||
a
|
||||
}
|
||||
|
||||
@@ -359,16 +376,32 @@ enum GameKind {
|
||||
}
|
||||
|
||||
/// Connection strings: host;port;user;password;database. They hold the password, so they travel by environment.
|
||||
fn database_env(s: &Secrets, world: bool) -> Vec<(String, String)> {
|
||||
fn database_env(s: &Secrets, world: bool, realm: crate::realms::Mode) -> Vec<(String, String)> {
|
||||
let info = |db: &str| format!("db;3306;acore;{};{db}", s.app);
|
||||
let mut env = vec![("AC_LOGIN_DATABASE_INFO".to_string(), info("acore_auth"))];
|
||||
if world {
|
||||
env.push(("AC_WORLD_DATABASE_INFO".into(), info("acore_world")));
|
||||
env.push(("AC_CHARACTER_DATABASE_INFO".into(), info("acore_characters")));
|
||||
// The databases of the selected realm (the Wildcard realm has its own world and characters databases).
|
||||
let schema = |kind: &str| realm.schema(kind).unwrap_or("acore_world");
|
||||
env.push(("AC_WORLD_DATABASE_INFO".into(), info(schema("world"))));
|
||||
env.push(("AC_CHARACTER_DATABASE_INFO".into(), info(schema("characters"))));
|
||||
}
|
||||
env
|
||||
}
|
||||
|
||||
/// Realm profiles are only in play once a profile has been chosen on this server (`Settings/realm-profile.json`).
|
||||
fn prepare_realm(root: &Path, log: &mut Log) -> Step<crate::realms::Mode> {
|
||||
let fail_with = |e: crate::error::Error| Failure { code: ErrorCode::StartupFailed, output: e.to_string() };
|
||||
crate::realms::before_start(root).map_err(fail_with)?;
|
||||
let active = crate::realms::state(root).map_err(fail_with)?.active;
|
||||
if root.join("Settings/realm-profile.json").exists() {
|
||||
crate::realms::setup_realmlist(root).map_err(fail_with)?;
|
||||
let db = crate::db::Db::from_repack(root, crate::db::Account::Admin).map_err(fail_with)?;
|
||||
db.query("UPDATE acore_auth.realmlist SET name='Conquest of Azeroth' WHERE id=1; UPDATE acore_auth.realmlist SET name='Wildcard' WHERE id=2;").map_err(fail_with)?;
|
||||
log.say(format!("realm {}", active.name()));
|
||||
}
|
||||
Ok(active)
|
||||
}
|
||||
|
||||
fn game_args(cfg: &Config, n: &Names, kind: GameKind, host: &Path, data: &Path, port: u16, ra_port: u16, owner: Option<&str>) -> Vec<String> {
|
||||
let (name, alias, binary, conf, inner_port) = match kind {
|
||||
GameKind::World => (&n.world, "world", "./worldserver", "configs/worldserver.conf", WORLD_PORT),
|
||||
@@ -698,6 +731,44 @@ mod tests {
|
||||
assert!(runs[1].args.windows(2).any(|w| w == ["--env", "AC_WORLD_DATABASE_INFO"]), "name only, the value is in the environment");
|
||||
}
|
||||
|
||||
// Unix only: the folder is a Linux path (a Windows path has a colon, which a Docker folder may not).
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn a_release_fixture_runs_its_database_on_the_package_data_directory_not_on_a_volume() {
|
||||
let (_d, root) = server("t1");
|
||||
fs::write(root.join("Settings/docker.json"), r#"{"project":"t1","mysqlData":"/work/fixture/mysql/data"}"#).unwrap();
|
||||
let sim = Sim::new();
|
||||
assert!(run_with(&sim, &root, Verb::StartMysql).unwrap().ok);
|
||||
let db = &sim.calls_of("run")[0].args;
|
||||
assert!(db.windows(2).any(|w| w == ["--volume", "/work/fixture/mysql/data:/var/lib/mysql"]), "{db:?}");
|
||||
assert!(!db.iter().any(|a| a.starts_with("coa-t1-db:")), "no named volume: {db:?}");
|
||||
assert!(db.iter().any(|a| a == "--user"), "the folder is written by its owner");
|
||||
assert_eq!(db.last().map(String::as_str), Some("--lower-case-table-names=1"), "a server option, so after the image name");
|
||||
// An installation never gets any of it.
|
||||
let (_d2, root2) = server("t2");
|
||||
let sim2 = Sim::new();
|
||||
assert!(run_with(&sim2, &root2, Verb::StartMysql).unwrap().ok);
|
||||
let plain = &sim2.calls_of("run")[0].args;
|
||||
assert!(plain.windows(2).any(|w| w == ["--volume", "coa-t2-db:/var/lib/mysql"]), "{plain:?}");
|
||||
assert!(!plain.iter().any(|a| a == "--lower-case-table-names=1" || a == "--user"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_containers_use_the_databases_of_the_selected_realm() {
|
||||
let s = Secrets { root: "r".into(), app: "apppw".into() };
|
||||
let get = |env: &[(String, String)], k: &str| env.iter().find(|(n, _)| n == k).map(|(_, v)| v.clone());
|
||||
let coa = database_env(&s, true, crate::realms::Mode::Coa);
|
||||
assert_eq!(get(&coa, "AC_WORLD_DATABASE_INFO").unwrap(), "db;3306;acore;apppw;acore_world");
|
||||
assert_eq!(get(&coa, "AC_CHARACTER_DATABASE_INFO").unwrap(), "db;3306;acore;apppw;acore_characters");
|
||||
let wild = database_env(&s, true, crate::realms::Mode::Wildcard);
|
||||
assert_eq!(get(&wild, "AC_WORLD_DATABASE_INFO").unwrap(), "db;3306;acore;apppw;acore_world_wildcard");
|
||||
assert_eq!(get(&wild, "AC_CHARACTER_DATABASE_INFO").unwrap(), "db;3306;acore;apppw;acore_characters_wildcard");
|
||||
// Accounts are shared by both realms; the auth server never sees the others.
|
||||
assert_eq!(get(&wild, "AC_LOGIN_DATABASE_INFO").unwrap(), "db;3306;acore;apppw;acore_auth");
|
||||
let auth = database_env(&s, false, crate::realms::Mode::Wildcard);
|
||||
assert_eq!(auth.len(), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_database_is_only_healthy_once_it_takes_tcp_connections() {
|
||||
let (_d, root) = server("t1");
|
||||
|
||||
@@ -15,6 +15,7 @@
|
||||
//! ```
|
||||
|
||||
mod cli;
|
||||
pub mod fixture;
|
||||
pub mod install;
|
||||
mod lifecycle;
|
||||
|
||||
@@ -63,6 +64,10 @@ pub struct Config {
|
||||
/// mounted read-only, so one copy can serve several servers.
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub data_dir: Option<String>,
|
||||
/// A MySQL data directory the database container uses in place of its volume. Only for the disposable fixture that
|
||||
/// validates a release (the data directory of the signed base package); an installation never sets it.
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub mysql_data: Option<String>,
|
||||
}
|
||||
|
||||
pub(crate) struct Names {
|
||||
@@ -96,10 +101,10 @@ impl Config {
|
||||
if self.bind_address.parse::<IpAddr>().is_err() {
|
||||
return Err(Error::Invalid(format!("{} is not an IP address.", self.bind_address)));
|
||||
}
|
||||
if let Some(d) = &self.data_dir {
|
||||
// The folder goes into a `--volume host:container:ro` option, where a colon would be read as a separator.
|
||||
for d in [&self.data_dir, &self.mysql_data].into_iter().flatten() {
|
||||
// The folder goes into a `--volume host:container` option, where a colon would be read as a separator.
|
||||
if !Path::new(d).is_absolute() || d.contains(':') {
|
||||
return Err(Error::Invalid("The game data folder must be a full path without a colon.".into()));
|
||||
return Err(Error::Invalid("A Docker folder must be a full path without a colon.".into()));
|
||||
}
|
||||
}
|
||||
let image_ok = !self.mysql_image.is_empty() && self.mysql_image.chars().all(|c| c.is_ascii_alphanumeric() || "._/:@-".contains(c));
|
||||
|
||||
@@ -7,6 +7,7 @@ pub mod remote_client;
|
||||
pub mod clientdl;
|
||||
pub mod config;
|
||||
pub mod console;
|
||||
pub mod crashes;
|
||||
pub mod dashboard;
|
||||
pub mod db;
|
||||
pub mod diag;
|
||||
@@ -31,6 +32,7 @@ pub mod repair;
|
||||
pub mod schema_check;
|
||||
pub mod net;
|
||||
pub mod package;
|
||||
pub mod platform;
|
||||
pub mod ra;
|
||||
pub mod allsettings;
|
||||
pub mod modules;
|
||||
@@ -41,6 +43,7 @@ pub mod release;
|
||||
pub mod report;
|
||||
pub mod release_schema;
|
||||
pub mod update;
|
||||
pub mod wine;
|
||||
pub mod upnp;
|
||||
pub mod signing;
|
||||
pub mod srp6;
|
||||
|
||||
@@ -0,0 +1,41 @@
|
||||
//! Which kind of server a new installation is on this computer. This is the one place where the host decides: a Windows
|
||||
//! computer installs a repack, anything else installs a Docker server. The screens and the commands ask here and then
|
||||
//! call the code of that kind, so no platform check is scattered through shared code.
|
||||
|
||||
use serde::Serialize;
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
|
||||
#[serde(rename_all = "kebab-case")]
|
||||
pub enum Flavor {
|
||||
/// The CoA Repack: Windows executables supervised by the repack's launcher.
|
||||
Repack,
|
||||
/// MySQL, the auth server and the world server in Docker containers.
|
||||
Docker,
|
||||
}
|
||||
|
||||
pub fn flavor() -> Flavor {
|
||||
if cfg!(windows) {
|
||||
Flavor::Repack
|
||||
} else {
|
||||
Flavor::Docker
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn the_host_decides_once() {
|
||||
#[cfg(windows)]
|
||||
assert_eq!(flavor(), Flavor::Repack);
|
||||
#[cfg(not(windows))]
|
||||
assert_eq!(flavor(), Flavor::Docker);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_screens_read_the_flavor_as_a_plain_word() {
|
||||
assert_eq!(serde_json::to_string(&Flavor::Repack).unwrap(), "\"repack\"");
|
||||
assert_eq!(serde_json::to_string(&Flavor::Docker).unwrap(), "\"docker\"");
|
||||
}
|
||||
}
|
||||
@@ -65,10 +65,16 @@ pub fn state(root: &Path) -> Result<RealmState> {
|
||||
fsx::read_json(&root.join(STATE))
|
||||
}
|
||||
|
||||
/// The world server executable of this folder: `worldserver.exe` in a repack, `worldserver` in a Docker server.
|
||||
fn world_binary(root: &Path) -> std::path::PathBuf {
|
||||
let exe = root.join("Core/worldserver.exe");
|
||||
if exe.exists() { exe } else { root.join("Core/worldserver") }
|
||||
}
|
||||
|
||||
pub fn view(root: &Path) -> Result<View> {
|
||||
let s = state(root)?;
|
||||
// Inspect the binary itself; templates or an old log cannot prove installed support.
|
||||
let supported = fs::read(root.join("Core/worldserver.exe"))?
|
||||
let supported = fs::read(world_binary(root))?
|
||||
.windows(b"Wildcard synergy settings".len()).any(|w| w == b"Wildcard synergy settings");
|
||||
Ok(View { active: s.active, wildcard_created: s.wildcard_created, supported, recovery_pending: root.join(JOURNAL).exists(), simultaneous: s.simultaneous, secondary_world_port: s.secondary_world_port, secondary_running: crate::multiworld::is_running(root) })
|
||||
}
|
||||
@@ -269,6 +275,8 @@ pub fn select(root: &Path, mode: Mode) -> Result<View> {
|
||||
|
||||
/// Adapt the bundled launcher's canonical schema and realm choices without changing its supervision logic.
|
||||
pub fn prepare_launcher(root: &Path) -> Result<()> {
|
||||
// A Docker server has no launcher to adapt: the Docker backend reads the active realm itself.
|
||||
if crate::docker::is_docker(root) { return Ok(()); }
|
||||
let path = root.join("Scripts/manage.py");
|
||||
let source = fs::read_to_string(&path)?;
|
||||
let patched = patch_launcher(&source)?;
|
||||
@@ -353,6 +361,31 @@ pub fn setup_realmlist(root: &Path) -> Result<()> {
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn a_docker_server_is_checked_for_wildcard_support_in_its_own_binary() {
|
||||
let d = tempfile::tempdir().unwrap();
|
||||
fs::create_dir_all(d.path().join("Core")).unwrap();
|
||||
fs::create_dir_all(d.path().join("Settings")).unwrap();
|
||||
fs::write(d.path().join("Settings/docker.json"), br#"{"project":"t1"}"#).unwrap();
|
||||
fs::write(d.path().join("Core/worldserver"), b"ELF...Wildcard synergy settings...").unwrap();
|
||||
assert!(view(d.path()).unwrap().supported, "worldserver without .exe is read too");
|
||||
fs::write(d.path().join("Core/worldserver"), b"ELF...an older build").unwrap();
|
||||
assert!(!view(d.path()).unwrap().supported);
|
||||
// The repack's executable still wins when both exist, so a repack is read as before.
|
||||
fs::write(d.path().join("Core/worldserver.exe"), b"MZ...Wildcard synergy settings").unwrap();
|
||||
assert!(view(d.path()).unwrap().supported);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_docker_server_has_no_launcher_to_adapt() {
|
||||
let d = tempfile::tempdir().unwrap();
|
||||
fs::create_dir_all(d.path().join("Settings")).unwrap();
|
||||
// No Scripts/manage.py anywhere: on a repack this fails, on a Docker server there is nothing to do.
|
||||
assert!(prepare_launcher(d.path()).is_err());
|
||||
fs::write(d.path().join("Settings/docker.json"), br#"{"project":"t1"}"#).unwrap();
|
||||
prepare_launcher(d.path()).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fresh_wildcard_disables_bots_and_preserves_scaling() {
|
||||
let mut f = Files::new();
|
||||
|
||||
@@ -38,7 +38,12 @@ pub fn extract_base(source: &Path, fixture: &Path, trusted_key: &str) -> Result<
|
||||
["mysql/", "settings/", "runtime/", "scripts/", "core/", "bugreport/"].iter().any(|prefix| path.starts_with(prefix))
|
||||
}, &|_, _| {})?;
|
||||
fsx::atomic_write(&fixture.join(MARKER), b"disposable release-schema fixture")?;
|
||||
install::bootstrap_database(fixture)
|
||||
// A Linux computer has no Windows database program: the fixture is a Docker server over the package's data directory.
|
||||
if cfg!(windows) {
|
||||
install::bootstrap_database(fixture)
|
||||
} else {
|
||||
crate::docker::fixture::prepare(fixture)
|
||||
}
|
||||
}
|
||||
|
||||
pub fn capture_release(fixture: &Path, tree: &Path, sql: &[SqlFile]) -> Result<()> {
|
||||
|
||||
@@ -283,12 +283,22 @@ pub enum DatabaseAccess {
|
||||
OnlyIfRunning,
|
||||
}
|
||||
|
||||
/// The update packages are those of the Windows repack (executables, a bundled MySQL, a launcher): applying one to a Docker
|
||||
/// server would put Windows files in a Linux server folder. Updating a Docker server is separate work.
|
||||
fn refuse_for_docker(root: &Path) -> Result<()> {
|
||||
if crate::docker::is_docker(root) {
|
||||
return Err(Error::Invalid("Updates are not available for Docker servers yet.".into()));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Describe the update; a managed launcher may need a one-time authenticated payload check.
|
||||
pub fn preview(root: &Path, meta: &InstallMeta, source: &Source, trusted_key: &str, resolutions: &BTreeMap<String, Resolution>) -> Result<Preview> {
|
||||
preview_with(root, meta, source, trusted_key, resolutions, DatabaseAccess::Start)
|
||||
}
|
||||
|
||||
pub fn preview_with(root: &Path, meta: &InstallMeta, source: &Source, trusted_key: &str, resolutions: &BTreeMap<String, Resolution>, access: DatabaseAccess) -> Result<Preview> {
|
||||
refuse_for_docker(root)?;
|
||||
let meta_dir = crate::registry::metadata_dir_for(root)?;
|
||||
let _lock = operation_lock(&meta_dir)?;
|
||||
ensure_recovered(&meta_dir)?;
|
||||
@@ -396,6 +406,7 @@ fn step(report: &dyn Fn(&str, u8), name: &str, pct: u8) {
|
||||
/// Run the whole update. On failure before the new build is validated the files are rolled back automatically;
|
||||
/// a build that is applied but unhealthy is left in `NeedsDecision` so the owner chooses.
|
||||
pub fn apply(p: &Params, report: &dyn Fn(&str, u8)) -> Result<Outcome> {
|
||||
refuse_for_docker(p.root)?;
|
||||
let (root, meta_dir) = (p.root, p.meta_dir);
|
||||
let _lock = operation_lock(meta_dir)?;
|
||||
ensure_recovered(meta_dir)?;
|
||||
@@ -700,6 +711,7 @@ fn restore_files(root: &Path, before: &Path, txn: &mut Txn) -> Result<()> {
|
||||
|
||||
/// Restore the database recovery point first, then restore binaries and configuration.
|
||||
pub fn rollback(root: &Path, meta_dir: &Path, id: &str, env: &dyn Env) -> Result<Txn> {
|
||||
refuse_for_docker(root)?;
|
||||
let _lock = operation_lock(meta_dir)?;
|
||||
let mut txn = load(meta_dir, id)?;
|
||||
if matches!(txn.state, State::Committed | State::RolledBack) {
|
||||
@@ -1142,6 +1154,27 @@ mod tests {
|
||||
assert_eq!(read(&w, "Core/worldserver.exe"), b"world-v1");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_docker_server_is_never_given_the_repack_files() {
|
||||
// Found by trying the installer: the update check of a Docker server read the Windows channel and offered its files.
|
||||
let w = world(&[], false);
|
||||
write(&w.root, "Settings/docker.json", br#"{"project":"t1"}"#);
|
||||
let before = read(&w, "Core/worldserver.exe");
|
||||
let meta = InstallMeta::new(InstallKind::New, &w.root);
|
||||
|
||||
let err = preview(&w.root, &meta, &Source::Dir(w.pkg.clone()), &w.key, &BTreeMap::new()).unwrap_err();
|
||||
assert!(err.to_string().contains("Docker"), "{err}");
|
||||
let err = run(&w, &Fake::ok(), BTreeMap::new(), None).unwrap_err();
|
||||
assert!(err.to_string().contains("Docker"), "{err}");
|
||||
assert!(rollback(&w.root, &w.meta, "any", &Fake::ok()).is_err());
|
||||
assert_eq!(read(&w, "Core/worldserver.exe"), before, "nothing was touched");
|
||||
assert!(!w.root.join("Core/newfile.dll").exists());
|
||||
|
||||
// The same package is applied to the same folder once it is not a Docker server.
|
||||
fs::remove_file(w.root.join("Settings/docker.json")).unwrap();
|
||||
assert_eq!(run(&w, &Fake::ok(), BTreeMap::new(), None).unwrap().txn.state, State::Committed);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn happy_path_replaces_creates_merges_and_records_ownership() {
|
||||
let w = world(&[], false);
|
||||
|
||||
@@ -0,0 +1,393 @@
|
||||
//! Starting the game client on Linux. The client is a Windows program, so it runs under umu-launcher with a Proton build
|
||||
//! (what the project's own guide uses), or under plain Wine when umu is not installed. This is the Linux counterpart of
|
||||
//! starting `Ascension.exe` directly; `client::launch` hands over to it on a Linux host and Windows never comes here.
|
||||
//!
|
||||
//! The settings are found on their own and can all be overridden, from strongest to weakest: the environment
|
||||
//! (`COA_PROTONPATH`, `COA_WINEPREFIX`), then `client-launch.json` in the Manager's folder, then what is installed.
|
||||
|
||||
use std::fs::{self, OpenOptions};
|
||||
use std::io::Write;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::process::{Command, Stdio};
|
||||
|
||||
use serde::Deserialize;
|
||||
|
||||
use crate::error::{Error, Result};
|
||||
|
||||
/// Prefix used when nothing else is said: the folder umu-launcher itself suggests for a game.
|
||||
const DEFAULT_PREFIX: &str = "Games/umu/coa-client";
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub enum Runner {
|
||||
/// umu-launcher runs the game with a Proton build. `proton` is `None` when umu should pick and download one itself.
|
||||
Umu { program: PathBuf, proton: Option<PathBuf> },
|
||||
Wine { program: PathBuf },
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub struct Launcher {
|
||||
pub runner: Runner,
|
||||
pub prefix: PathBuf,
|
||||
}
|
||||
|
||||
/// What to run, in a form that can be checked without running anything.
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub struct Plan {
|
||||
pub program: PathBuf,
|
||||
pub args: Vec<String>,
|
||||
pub env: Vec<(String, String)>,
|
||||
pub cwd: PathBuf,
|
||||
}
|
||||
|
||||
/// `client-launch.json`: every key is optional.
|
||||
#[derive(Debug, Default, Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct Overrides {
|
||||
pub proton_path: Option<String>,
|
||||
pub prefix: Option<String>,
|
||||
/// "umu" or "wine": use this one even if the other is installed.
|
||||
pub runner: Option<String>,
|
||||
}
|
||||
|
||||
/// Everything detection looks at, so it can be tested without a real computer.
|
||||
pub struct Host<'a> {
|
||||
pub var: &'a dyn Fn(&str) -> Option<String>,
|
||||
pub which: &'a dyn Fn(&str) -> Option<PathBuf>,
|
||||
/// Names of the entries of a folder (empty when it does not exist).
|
||||
pub list: &'a dyn Fn(&Path) -> Vec<String>,
|
||||
pub is_file: &'a dyn Fn(&Path) -> bool,
|
||||
}
|
||||
|
||||
fn proton_folders(home: &Path) -> Vec<PathBuf> {
|
||||
vec![
|
||||
home.join(".local/share/Steam/compatibilitytools.d"),
|
||||
home.join(".steam/root/compatibilitytools.d"),
|
||||
home.join(".steam/steam/compatibilitytools.d"),
|
||||
home.join(".var/app/com.valvesoftware.Steam/.local/share/Steam/compatibilitytools.d"),
|
||||
PathBuf::from("/usr/share/steam/compatibilitytools.d"),
|
||||
]
|
||||
}
|
||||
|
||||
/// Numbers of a name in order, so that GE-Proton10-9 sorts before GE-Proton10-34.
|
||||
fn version_key(name: &str) -> Vec<u64> {
|
||||
let mut out = Vec::new();
|
||||
let mut cur = String::new();
|
||||
for c in name.chars().chain(std::iter::once(' ')) {
|
||||
if c.is_ascii_digit() {
|
||||
cur.push(c);
|
||||
} else if !cur.is_empty() {
|
||||
out.push(cur.parse().unwrap_or(0));
|
||||
cur.clear();
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// The newest GE-Proton build installed for Steam, if any. A folder only counts when it holds the `proton` script.
|
||||
fn newest_proton(host: &Host, home: &Path) -> Option<PathBuf> {
|
||||
proton_folders(home)
|
||||
.into_iter()
|
||||
.flat_map(|dir| (host.list)(&dir).into_iter().filter(|n| n.starts_with("GE-Proton")).map(move |n| (n.clone(), dir.join(n))))
|
||||
.filter(|(_, path)| (host.is_file)(&path.join("proton")))
|
||||
.max_by_key(|(name, _)| version_key(name))
|
||||
.map(|(_, path)| path)
|
||||
}
|
||||
|
||||
pub fn detect_with(host: &Host, overrides: &Overrides) -> Result<Launcher> {
|
||||
let home = (host.var)("HOME").map(PathBuf::from).ok_or_else(|| Error::Invalid("The home folder of this user is not known.".into()))?;
|
||||
let prefix = (host.var)("COA_WINEPREFIX").or_else(|| overrides.prefix.clone()).map(PathBuf::from).unwrap_or_else(|| home.join(DEFAULT_PREFIX));
|
||||
let proton = (host.var)("COA_PROTONPATH").or_else(|| overrides.proton_path.clone()).map(PathBuf::from).or_else(|| newest_proton(host, &home));
|
||||
let (umu, wine) = ((host.which)("umu-run"), (host.which)("wine"));
|
||||
let runner = match (overrides.runner.as_deref(), umu, wine) {
|
||||
(Some("wine"), _, Some(program)) => Runner::Wine { program },
|
||||
(Some("umu"), Some(program), _) | (None, Some(program), _) => Runner::Umu { program, proton },
|
||||
(_, None, Some(program)) => Runner::Wine { program },
|
||||
_ => {
|
||||
return Err(Error::Invalid(
|
||||
"To play on Linux the game client needs umu-launcher (with a Proton build such as GE-Proton) or Wine. Install one of them and press Play again.".into(),
|
||||
))
|
||||
}
|
||||
};
|
||||
Ok(Launcher { runner, prefix })
|
||||
}
|
||||
|
||||
/// The command line that starts `exe` from the client folder.
|
||||
pub fn plan(launcher: &Launcher, client: &Path, exe: &str) -> Plan {
|
||||
let mut env = vec![("WINEPREFIX".to_string(), launcher.prefix.to_string_lossy().into_owned())];
|
||||
// DivxTac.dll is a mixed-mode .NET assembly: loaded through wine-mono it deadlocks the client on the world loading screen
|
||||
// (100%). Disabling it has the same effect as removing the file.
|
||||
env.push(("WINEDLLOVERRIDES".into(), "divxtac=d".into()));
|
||||
let program = match &launcher.runner {
|
||||
Runner::Umu { program, proton } => {
|
||||
env.push(("GAMEID".into(), "0".into()));
|
||||
if let Some(p) = proton {
|
||||
env.push(("PROTONPATH".into(), p.to_string_lossy().into_owned()));
|
||||
}
|
||||
program.clone()
|
||||
}
|
||||
Runner::Wine { program } => program.clone(),
|
||||
};
|
||||
// The client reads Data/ relative to the working directory.
|
||||
Plan { program, args: vec![exe.to_string()], env, cwd: client.to_path_buf() }
|
||||
}
|
||||
|
||||
fn system_var(k: &str) -> Option<String> {
|
||||
std::env::var(k).ok().filter(|v| !v.trim().is_empty())
|
||||
}
|
||||
|
||||
fn find_on_path(program: &str) -> Option<PathBuf> {
|
||||
std::env::split_paths(&std::env::var_os("PATH")?).map(|d| d.join(program)).find(|p| p.is_file())
|
||||
}
|
||||
|
||||
fn list_names(dir: &Path) -> Vec<String> {
|
||||
fs::read_dir(dir).map(|rd| rd.filter_map(|e| e.ok()).filter_map(|e| e.file_name().into_string().ok()).collect()).unwrap_or_default()
|
||||
}
|
||||
|
||||
fn data_home() -> Option<PathBuf> {
|
||||
system_var("XDG_DATA_HOME").map(PathBuf::from).filter(|p| p.is_absolute()).or_else(|| system_var("HOME").map(|h| PathBuf::from(h).join(".local/share")))
|
||||
}
|
||||
|
||||
fn overrides_file() -> Option<PathBuf> {
|
||||
data_home().map(|d| d.join("CoAServerManager/client-launch.json"))
|
||||
}
|
||||
|
||||
pub fn detect() -> Result<Launcher> {
|
||||
let overrides: Overrides = overrides_file().and_then(|p| crate::fsx::read_json(&p).ok()).unwrap_or_default();
|
||||
detect_with(&Host { var: &system_var, which: &find_on_path, list: &list_names, is_file: &|p| p.is_file() }, &overrides)
|
||||
}
|
||||
|
||||
/// Where what the client prints goes: the Manager's own log folder.
|
||||
pub fn log_path() -> Option<PathBuf> {
|
||||
data_home().map(|d| d.join("CoAServerManager/logs/client.log"))
|
||||
}
|
||||
|
||||
/// Start the client and return at once; it keeps running when the Manager closes. Returns the process id.
|
||||
pub fn launch(client: &Path, exe: &str) -> Result<u32> {
|
||||
let launcher = detect()?;
|
||||
let plan = plan(&launcher, client, exe);
|
||||
let log = match log_path() {
|
||||
Some(p) => {
|
||||
if let Some(dir) = p.parent() {
|
||||
fs::create_dir_all(dir)?;
|
||||
}
|
||||
let mut f = OpenOptions::new().create(true).append(true).open(&p)?;
|
||||
writeln!(f, "=== {} {:?} in {}", plan.program.display(), plan.args, plan.cwd.display())?;
|
||||
for (k, v) in &plan.env {
|
||||
writeln!(f, " {k}={v}")?;
|
||||
}
|
||||
Some(f)
|
||||
}
|
||||
None => None,
|
||||
};
|
||||
let mut cmd = Command::new(&plan.program);
|
||||
cmd.args(&plan.args).current_dir(&plan.cwd).envs(plan.env.iter().map(|(k, v)| (k, v))).stdin(Stdio::null());
|
||||
match log {
|
||||
Some(f) => {
|
||||
cmd.stderr(f.try_clone()?).stdout(f);
|
||||
}
|
||||
None => {
|
||||
cmd.stdout(Stdio::null()).stderr(Stdio::null());
|
||||
}
|
||||
}
|
||||
#[cfg(unix)]
|
||||
{
|
||||
use std::os::unix::process::CommandExt;
|
||||
cmd.process_group(0); // its own group: closing the Manager does not take the game with it
|
||||
}
|
||||
let mut child = cmd.spawn().map_err(|e| Error::Invalid(format!("The game client could not be started ({}): {e}", plan.program.display())))?;
|
||||
let pid = child.id();
|
||||
std::thread::spawn(move || {
|
||||
let _ = child.wait(); // reap it when the game closes
|
||||
});
|
||||
Ok(pid)
|
||||
}
|
||||
|
||||
/// Is a process running this client? Under Wine its command line carries the Windows form of the path
|
||||
/// (`Z:\home\you\client\Ascension.exe`), which is the only trace of it that names the folder.
|
||||
pub fn command_line_runs(cmdline: &str, client: &Path, exe: &str) -> bool {
|
||||
let wanted = format!("{}/{}", client.to_string_lossy().trim_end_matches('/'), exe).to_lowercase();
|
||||
cmdline.replace('\0', " ").replace('\\', "/").to_lowercase().contains(&wanted)
|
||||
}
|
||||
|
||||
/// The folder as it was given and as the system resolves it. On an immutable distribution (SteamOS, Bazzite) `/home` is a
|
||||
/// link to `/var/home`: Wine writes the path it was given, the resolved one differs, and either may be what the command
|
||||
/// line of the running client holds.
|
||||
fn spellings(client: &Path) -> Vec<PathBuf> {
|
||||
let mut all = vec![client.to_path_buf()];
|
||||
if let Ok(real) = fs::canonicalize(client) {
|
||||
if real != client {
|
||||
all.push(real);
|
||||
}
|
||||
}
|
||||
all
|
||||
}
|
||||
|
||||
pub fn is_running(client: &Path, exes: &[&str]) -> bool {
|
||||
let folders = spellings(client);
|
||||
let Ok(rd) = fs::read_dir("/proc") else { return false };
|
||||
rd.filter_map(|e| e.ok())
|
||||
.filter(|e| e.file_name().to_string_lossy().bytes().all(|b| b.is_ascii_digit()))
|
||||
.filter_map(|e| fs::read(e.path().join("cmdline")).ok())
|
||||
.any(|raw| {
|
||||
let line = String::from_utf8_lossy(&raw);
|
||||
folders.iter().any(|folder| exes.iter().any(|exe| command_line_runs(&line, folder, exe)))
|
||||
})
|
||||
}
|
||||
|
||||
// Linux only: the folders are written as Linux path strings.
|
||||
#[cfg(all(test, unix))]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use std::collections::{BTreeMap, BTreeSet};
|
||||
|
||||
#[test]
|
||||
fn a_client_folder_behind_a_link_is_looked_for_under_both_names() {
|
||||
// SteamOS and Bazzite: /home is a link to /var/home.
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
fs::create_dir_all(dir.path().join("var/home/u/client")).unwrap();
|
||||
std::os::unix::fs::symlink("var/home", dir.path().join("home")).unwrap();
|
||||
let given = dir.path().join("home/u/client");
|
||||
let both = spellings(&given);
|
||||
assert_eq!(both.len(), 2);
|
||||
assert_eq!(both[0], given);
|
||||
assert!(both[1].starts_with(dir.path().canonicalize().unwrap().join("var/home")));
|
||||
// Wine kept the name it was given, so the line holds the first one and not the resolved one.
|
||||
let line = format!("Z:\\{}\\Ascension.exe", given.to_string_lossy().replace('/', "\\"));
|
||||
assert!(!command_line_runs(&line, &both[1], "Ascension.exe"));
|
||||
assert!(both.iter().any(|f| command_line_runs(&line, f, "Ascension.exe")));
|
||||
}
|
||||
|
||||
/// A computer described in a few lines: variables, programs on the path, folders with their entries, and `proton` scripts.
|
||||
struct Fake {
|
||||
vars: BTreeMap<&'static str, &'static str>,
|
||||
programs: BTreeSet<&'static str>,
|
||||
folders: BTreeMap<&'static str, Vec<&'static str>>,
|
||||
}
|
||||
|
||||
impl Fake {
|
||||
fn new() -> Fake {
|
||||
Fake { vars: BTreeMap::from([("HOME", "/home/ana")]), programs: BTreeSet::new(), folders: BTreeMap::new() }
|
||||
}
|
||||
|
||||
fn detect(&self, overrides: &Overrides) -> Result<Launcher> {
|
||||
let var = |k: &str| self.vars.get(k).map(|v| v.to_string());
|
||||
let which = |p: &str| self.programs.contains(p).then(|| PathBuf::from(format!("/usr/bin/{p}")));
|
||||
let list = |d: &Path| self.folders.get(d.to_str().unwrap()).map(|v| v.iter().map(|s| s.to_string()).collect()).unwrap_or_default();
|
||||
// every listed build has its `proton` script
|
||||
let is_file = |p: &Path| p.file_name().is_some_and(|n| n == "proton");
|
||||
detect_with(&Host { var: &var, which: &which, list: &list, is_file: &is_file }, overrides)
|
||||
}
|
||||
}
|
||||
|
||||
const STEAM: &str = "/home/ana/.local/share/Steam/compatibilitytools.d";
|
||||
|
||||
#[test]
|
||||
fn umu_with_the_newest_ge_proton_is_the_default() {
|
||||
let mut c = Fake::new();
|
||||
c.programs.extend(["umu-run", "wine"]);
|
||||
c.folders.insert(STEAM, vec!["GE-Proton9-27", "GE-Proton10-9", "GE-Proton10-34", "Proton-Experimental", "notes.txt"]);
|
||||
let l = c.detect(&Overrides::default()).unwrap();
|
||||
assert_eq!(l.prefix, PathBuf::from("/home/ana/Games/umu/coa-client"));
|
||||
match l.runner {
|
||||
Runner::Umu { proton, program } => {
|
||||
assert_eq!(program, PathBuf::from("/usr/bin/umu-run"));
|
||||
assert_eq!(proton, Some(PathBuf::from(format!("{STEAM}/GE-Proton10-34"))), "10-34 is newer than 10-9");
|
||||
}
|
||||
other => panic!("{other:?}"),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn without_a_proton_build_umu_is_left_to_choose_one() {
|
||||
let mut c = Fake::new();
|
||||
c.programs.insert("umu-run");
|
||||
let Runner::Umu { proton, .. } = c.detect(&Overrides::default()).unwrap().runner else { panic!() };
|
||||
assert_eq!(proton, None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn plain_wine_is_used_when_umu_is_not_installed() {
|
||||
let mut c = Fake::new();
|
||||
c.programs.insert("wine");
|
||||
assert!(matches!(c.detect(&Overrides::default()).unwrap().runner, Runner::Wine { .. }));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn without_umu_or_wine_the_person_is_told_what_to_install() {
|
||||
let err = Fake::new().detect(&Overrides::default()).unwrap_err().to_string();
|
||||
assert!(err.contains("umu-launcher") && err.contains("Wine"), "{err}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn settings_override_what_is_installed_and_the_environment_overrides_the_file() {
|
||||
let mut c = Fake::new();
|
||||
c.programs.extend(["umu-run", "wine"]);
|
||||
c.folders.insert(STEAM, vec!["GE-Proton10-34"]);
|
||||
let file = Overrides { proton_path: Some("/opt/proton-a".into()), prefix: Some("/data/prefix-a".into()), runner: None };
|
||||
let l = c.detect(&file).unwrap();
|
||||
assert_eq!(l.prefix, PathBuf::from("/data/prefix-a"));
|
||||
assert!(matches!(&l.runner, Runner::Umu { proton: Some(p), .. } if p == Path::new("/opt/proton-a")));
|
||||
c.vars.insert("COA_PROTONPATH", "/opt/proton-b");
|
||||
c.vars.insert("COA_WINEPREFIX", "/data/prefix-b");
|
||||
let l = c.detect(&file).unwrap();
|
||||
assert_eq!(l.prefix, PathBuf::from("/data/prefix-b"));
|
||||
assert!(matches!(&l.runner, Runner::Umu { proton: Some(p), .. } if p == Path::new("/opt/proton-b")));
|
||||
// Forcing Wine works when it is installed, and falls back to umu when it is not.
|
||||
let wine = Overrides { runner: Some("wine".into()), ..Default::default() };
|
||||
assert!(matches!(c.detect(&wine).unwrap().runner, Runner::Wine { .. }));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_command_is_the_one_of_the_projects_own_launcher_script() {
|
||||
let l = Launcher { runner: Runner::Umu { program: "/usr/bin/umu-run".into(), proton: Some("/p/GE-Proton11-6".into()) }, prefix: "/home/ana/Games/umu/coa-client".into() };
|
||||
let p = plan(&l, Path::new("/home/ana/CoaServer/client/ascension-live"), "Ascension.exe");
|
||||
assert_eq!(p.program, PathBuf::from("/usr/bin/umu-run"));
|
||||
assert_eq!(p.args, ["Ascension.exe"]);
|
||||
assert_eq!(p.cwd, PathBuf::from("/home/ana/CoaServer/client/ascension-live"), "the client reads Data/ from its working directory");
|
||||
let env: BTreeMap<_, _> = p.env.iter().cloned().collect();
|
||||
assert_eq!(env["GAMEID"], "0");
|
||||
assert_eq!(env["PROTONPATH"], "/p/GE-Proton11-6");
|
||||
assert_eq!(env["WINEPREFIX"], "/home/ana/Games/umu/coa-client");
|
||||
assert_eq!(env["WINEDLLOVERRIDES"], "divxtac=d", "DivxTac.dll deadlocks the world loading screen under wine-mono");
|
||||
// Wine has no GAMEID / PROTONPATH.
|
||||
let w = plan(&Launcher { runner: Runner::Wine { program: "/usr/bin/wine".into() }, prefix: "/pre".into() }, Path::new("/c"), "Wow.exe");
|
||||
assert!(w.env.iter().all(|(k, _)| k != "GAMEID" && k != "PROTONPATH") && w.args == ["Wow.exe"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_wine_command_line_names_the_client_folder_in_windows_form() {
|
||||
let client = Path::new("/home/ana/CoaServer/client/ascension-live");
|
||||
assert!(command_line_runs("Z:\\home\\ana\\CoaServer\\client\\ascension-live\\Ascension.exe\0", client, "Ascension.exe"));
|
||||
assert!(command_line_runs("C:\\windows\\system32\\start.exe /exec Z:\\HOME\\ANA\\coaserver\\client\\ascension-live\\ascension.exe", client, "Ascension.exe"), "case does not matter");
|
||||
assert!(!command_line_runs("Z:\\home\\ana\\CoaServer\\client\\ascension-lab\\Ascension.exe", client, "Ascension.exe"), "another client folder");
|
||||
assert!(!command_line_runs("umu-run Ascension.exe", client, "Ascension.exe"), "the launcher alone does not name the folder");
|
||||
assert!(!command_line_runs("Z:\\home\\ana\\CoaServer\\client\\ascension-live\\Ascension.exe.ORIGINAL", Path::new("/other"), "Ascension.exe"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn newer_versions_sort_after_older_ones() {
|
||||
assert!(version_key("GE-Proton10-9") < version_key("GE-Proton10-34"));
|
||||
assert!(version_key("GE-Proton9-27") < version_key("GE-Proton10-1"));
|
||||
assert!(version_key("GE-Proton11-6-x86_64") < version_key("GE-Proton11-7-x86_64"));
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn a_real_launch_runs_the_program_in_the_client_folder_with_the_right_environment() {
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
let d = tempfile::tempdir().unwrap();
|
||||
let client = d.path().join("client");
|
||||
fs::create_dir_all(&client).unwrap();
|
||||
let out = d.path().join("seen.txt");
|
||||
let script = d.path().join("umu-run");
|
||||
fs::write(&script, format!("#!/bin/sh\n{{ echo \"cwd=$(pwd)\"; echo \"arg=$1\"; echo \"prefix=$WINEPREFIX\"; echo \"gameid=$GAMEID\"; echo \"dll=$WINEDLLOVERRIDES\"; }} > '{}'\n", out.display())).unwrap();
|
||||
fs::set_permissions(&script, fs::Permissions::from_mode(0o755)).unwrap();
|
||||
let launcher = Launcher { runner: Runner::Umu { program: script, proton: None }, prefix: d.path().join("prefix") };
|
||||
let p = plan(&launcher, &client, "Ascension.exe");
|
||||
let mut child = Command::new(&p.program).args(&p.args).current_dir(&p.cwd).envs(p.env.iter().map(|(k, v)| (k, v))).spawn().unwrap();
|
||||
assert!(child.wait().unwrap().success());
|
||||
let seen = fs::read_to_string(&out).unwrap();
|
||||
assert!(seen.contains(&format!("cwd={}", fs::canonicalize(&client).unwrap().display())), "{seen}");
|
||||
assert!(seen.contains("arg=Ascension.exe") && seen.contains("gameid=0") && seen.contains("dll=divxtac=d") && seen.contains("prefix="), "{seen}");
|
||||
}
|
||||
}
|
||||
+32
-2
@@ -392,8 +392,38 @@ hand over to `coa_core::docker`; nothing else needed to change for start, stop,
|
||||
so replaying the SQL files from the base scripts fails, in any order. `coa-release export-baseline --server DIR --out DIR`
|
||||
produces the dumps from a prepared server (repack or Docker). The game data stays where the person has it
|
||||
(`dataDir` in `docker.json`, mounted read-only). A failure removes the containers, the volume and the staging folder.
|
||||
* **Not done yet**: wiring the installer into the screens, downloading the game data, updates, port conflict detection,
|
||||
the firewall and exposure checks, the Wildcard realm profiles, and the client under Wine/Proton.
|
||||
* **Validating a release on Linux** (`docker/fixture.rs`, used by `coa-release extract-schema-base` and `schema-contract` where
|
||||
there is no Windows database program): the signed base package carries the MySQL data directory of a Windows repack, and a
|
||||
MySQL 8.4 container opens it as it is (`--lower-case-table-names=1`, the repack's setting). The fixture is a Docker server
|
||||
folder (`docker.json` with `mysqlData`: the database container uses that directory in place of a volume; an installation
|
||||
never sets it), plus a `root` account for TCP, which the repack only has for its socket. The release SQL is then applied and the
|
||||
schema contract captured by the same code as on Windows, and `export-baseline` dumps the result: that is how a Linux build
|
||||
produces `Database/baseline` without anyone's live database. The migration checksums recorded in the base are those of
|
||||
files checked out on Windows (CRLF line endings, `core.autocrlf`): the SQL of the core, the modules and SQUID must be
|
||||
checked out the same way for the checksums to match, or every applied migration looks edited.
|
||||
* **In the screens** the host is asked once per command (`coa_core::platform::flavor()`: repack on Windows, Docker
|
||||
elsewhere) and the Docker half lives in `src-tauri/src/docker_install.rs`; the repack arm of each install command is the
|
||||
code that was there. `install_environment` tells the install screen the kind of server, the suggested folder
|
||||
(`~/CoaServer`) and why Docker cannot be used, if it cannot. On Docker the screen also asks for the game data folder and
|
||||
the package, and there is no default package address until a signed Linux package is published. Packages are checked with
|
||||
the embedded key; only a debug build (`tauri dev`) accepts another one, named in `COA_DEV_TRUSTED_KEY`, to try the
|
||||
installer on a package signed with a throwaway key.
|
||||
* **Updates are refused for a Docker server, never half done.** `update::preview`, `apply` and `rollback` refuse it: the
|
||||
update packages are the repack's (executables, a bundled MySQL, a launcher) and applying one would put Windows files in a
|
||||
Linux folder. Found by installing a server with the screen: the update check had read the Windows channel and offered one.
|
||||
* **Realm profiles (CoA / Wildcard) work on a Docker server.** What the repack's patched launcher did at each start is done
|
||||
by the Docker backend: finish an interrupted switch (`realms::before_start`), name the realms in the realm list, and give
|
||||
the containers the databases of the selected realm (`acore_world_wildcard` ...). The switch itself (configuration swap,
|
||||
database copy, journal) is the shared code; `prepare_launcher` has nothing to patch, and Wildcard support is read from
|
||||
`Core/worldserver` as it is from `Core/worldserver.exe`.
|
||||
* **The game client starts under Wine on a Linux host** (`wine.rs`; `client::launch` and `client::is_running` hand over):
|
||||
umu-launcher with a Proton build when `umu-run` is installed (the newest GE-Proton found for Steam, or umu's own choice),
|
||||
else plain Wine; `WINEPREFIX` defaults to `~/Games/umu/coa-client`; `WINEDLLOVERRIDES=divxtac=d` is always set, because
|
||||
DivxTac.dll deadlocks the world loading screen under wine-mono. `COA_PROTONPATH`, `COA_WINEPREFIX` or
|
||||
`client-launch.json` in the Manager's folder (`proton_path`, `prefix`, `runner`) override the detection. Whether the client
|
||||
runs is read from `/proc` (under Wine the command line holds the Windows form of the path). Output goes to `client.log`.
|
||||
* **Not done yet**: downloading the game data, updates, port conflict detection, the firewall and exposure checks, the
|
||||
Wildcard realm profiles, and the client under Wine/Proton.
|
||||
|
||||
### D14. Keeping Windows and Linux apart
|
||||
|
||||
|
||||
Generated
+2
-2
@@ -1,12 +1,12 @@
|
||||
{
|
||||
"name": "coa-server-manager",
|
||||
"version": "0.6.7",
|
||||
"version": "0.6.8",
|
||||
"lockfileVersion": 3,
|
||||
"requires": true,
|
||||
"packages": {
|
||||
"": {
|
||||
"name": "coa-server-manager",
|
||||
"version": "0.6.7",
|
||||
"version": "0.6.8",
|
||||
"dependencies": {
|
||||
"@tauri-apps/api": "^2.12.0",
|
||||
"@tauri-apps/plugin-dialog": "^2.8.0",
|
||||
|
||||
+1
-1
@@ -1,7 +1,7 @@
|
||||
{
|
||||
"name": "coa-server-manager",
|
||||
"private": true,
|
||||
"version": "0.6.7",
|
||||
"version": "0.6.8",
|
||||
"license": "AGPL-3.0-only",
|
||||
"type": "module",
|
||||
"scripts": {
|
||||
|
||||
@@ -0,0 +1,125 @@
|
||||
//! The Linux (Docker) side of the install commands. `lib.rs` asks `coa_core::platform::flavor()` once per command and
|
||||
//! calls this module for a Docker install; the code for a repack install stays where it was and is not changed by what
|
||||
//! happens here.
|
||||
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
use coa_core::docker::{self, install as core_install, SystemDocker};
|
||||
use coa_core::download::Cancel;
|
||||
use coa_core::install::{Preflight, Source};
|
||||
use coa_core::registry::Registry;
|
||||
use coa_core::{Error, Result};
|
||||
use serde::Serialize;
|
||||
use tauri::{AppHandle, Emitter, State};
|
||||
|
||||
use super::{blocking, data_dir, summary, AppState, InstallRequirements, ServerSummary, UiError};
|
||||
|
||||
/// What the install screen needs to know about this computer before it asks anything.
|
||||
#[derive(Serialize)]
|
||||
pub struct Environment {
|
||||
pub flavor: coa_core::platform::Flavor,
|
||||
pub default_dir: String,
|
||||
/// Why Docker cannot be used (not installed, not running, no permission), in Docker's own words; none when it works.
|
||||
pub docker_problem: Option<String>,
|
||||
}
|
||||
|
||||
pub fn default_dir() -> String {
|
||||
default_dir_in(std::env::var("HOME").ok().as_deref())
|
||||
}
|
||||
|
||||
fn default_dir_in(home: Option<&str>) -> String {
|
||||
match home.map(|h| h.trim_end_matches('/')).filter(|h| !h.is_empty()) {
|
||||
Some(h) => format!("{h}/CoaServer"),
|
||||
None => "/srv/coa".into(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn docker_problem() -> Option<String> {
|
||||
docker::check_docker(&SystemDocker).err().map(|e| e.to_string())
|
||||
}
|
||||
|
||||
pub fn environment() -> Environment {
|
||||
Environment { flavor: coa_core::platform::flavor(), default_dir: default_dir(), docker_problem: docker_problem() }
|
||||
}
|
||||
|
||||
pub fn preflight(dest: &str, data: Option<String>, needed: Option<u64>, registry: &Registry) -> Preflight {
|
||||
// The size comes from the signed package list when the screen already has it; it is checked again at install time.
|
||||
core_install::preflight(Path::new(dest), Path::new(data.as_deref().unwrap_or("")), needed.unwrap_or(1024 * 1024 * 1024), registry)
|
||||
}
|
||||
|
||||
/// The Linux package has no default address yet: it is published only after the maintainer has signed it.
|
||||
pub fn package_source(custom: Option<String>) -> Result<Source> {
|
||||
let pick = custom.filter(|s| !s.trim().is_empty()).or_else(|| std::env::var("COA_PACKAGE_SOURCE").ok().filter(|s| !s.trim().is_empty()));
|
||||
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 => Err(Error::Invalid("Choose the Linux server package (a folder or an address): none is published yet.".into())),
|
||||
}
|
||||
}
|
||||
|
||||
/// The key a Linux package must be signed with. A debug build (`tauri dev`) may name another one in `COA_DEV_TRUSTED_KEY`,
|
||||
/// to try the installer on a package signed with a throwaway key; a release build always uses the embedded key.
|
||||
pub fn trusted_key() -> String {
|
||||
#[cfg(debug_assertions)]
|
||||
if let Ok(k) = std::env::var("COA_DEV_TRUSTED_KEY") {
|
||||
if !k.trim().is_empty() {
|
||||
return k.trim().to_string();
|
||||
}
|
||||
}
|
||||
coa_core::signing::EMBEDDED_PUBLIC_KEY.to_string()
|
||||
}
|
||||
|
||||
pub async fn requirements(package: Option<String>) -> std::result::Result<InstallRequirements, UiError> {
|
||||
blocking(move || {
|
||||
let (m, _) = coa_core::pkgsource::fetch_manifest(&package_source(package)?, &trusted_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
|
||||
}
|
||||
|
||||
pub async fn install(app: AppHandle, state: State<'_, AppState>, dest: String, package: Option<String>, data: Option<String>) -> std::result::Result<ServerSummary, UiError> {
|
||||
let source = package_source(package)?;
|
||||
let data_dir_path = PathBuf::from(data.filter(|d| !d.trim().is_empty()).ok_or_else(|| Error::Invalid("Choose the folder that holds the game data.".into()))?);
|
||||
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 key = trusted_key();
|
||||
let result = tauri::async_runtime::spawn_blocking(move || {
|
||||
core_install::install(
|
||||
&core_install::Params { source, dest: dest_path, data_dir: data_dir_path, trusted_key: &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)))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn the_default_folder_is_in_the_home_folder() {
|
||||
assert_eq!(default_dir_in(Some("/home/ana")), "/home/ana/CoaServer");
|
||||
assert_eq!(default_dir_in(Some("/home/ana/")), "/home/ana/CoaServer");
|
||||
assert_eq!(default_dir_in(None), "/srv/coa");
|
||||
assert_eq!(default_dir_in(Some("")), "/srv/coa");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_linux_package_must_be_named_there_is_no_default() {
|
||||
std::env::remove_var("COA_PACKAGE_SOURCE");
|
||||
assert!(package_source(None).is_err());
|
||||
assert!(package_source(Some(" ".into())).is_err());
|
||||
assert!(matches!(package_source(Some("/tmp/pkg".into())).unwrap(), Source::Dir(_)));
|
||||
assert!(matches!(package_source(Some("https://example.org/pkg".into())).unwrap(), Source::Url(_)));
|
||||
}
|
||||
}
|
||||
+32
-2
@@ -5,11 +5,14 @@ use std::collections::HashSet;
|
||||
use std::path::PathBuf;
|
||||
use std::sync::Mutex;
|
||||
|
||||
mod docker_install;
|
||||
|
||||
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::install::{self, Preflight, Source};
|
||||
use coa_core::platform::{self, Flavor};
|
||||
use coa_core::ra::Ra;
|
||||
use coa_core::update::{self, Resolution};
|
||||
use coa_core::error::UiError;
|
||||
@@ -105,9 +108,19 @@ fn summary(id: String, path: PathBuf) -> ServerSummary {
|
||||
|
||||
#[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<ScanReport, UiError> {
|
||||
tauri::async_runtime::spawn_blocking(move || layout::scan(std::path::Path::new(&path)))
|
||||
@@ -450,7 +463,10 @@ async fn restore_backup_database(state: State<'_, AppState>, id: String, backup_
|
||||
}
|
||||
|
||||
#[tauri::command]
|
||||
fn install_preflight(state: State<'_, AppState>, dest: String, needed: Option<u64>) -> Preflight {
|
||||
fn install_preflight(state: State<'_, AppState>, dest: String, needed: Option<u64>, game_data: Option<String>) -> 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)
|
||||
@@ -468,6 +484,9 @@ struct InstallRequirements {
|
||||
/// How big the server is, read from the package's signed list before anything is downloaded.
|
||||
#[tauri::command]
|
||||
async fn install_requirements(package: Option<String>) -> std::result::Result<InstallRequirements, UiError> {
|
||||
if platform::flavor() == Flavor::Docker {
|
||||
return docker_install::requirements(package).await;
|
||||
}
|
||||
blocking(move || {
|
||||
let (m, _) = coa_core::pkgsource::fetch_manifest(&package_source(package), coa_core::signing::EMBEDDED_PUBLIC_KEY)?;
|
||||
let archive = m.archive.ok_or_else(|| Error::InvalidManifest("no archive".into()))?;
|
||||
@@ -477,7 +496,10 @@ async fn install_requirements(package: Option<String>) -> std::result::Result<In
|
||||
}
|
||||
|
||||
#[tauri::command]
|
||||
async fn install_new(app: AppHandle, state: State<'_, AppState>, dest: String, package: Option<String>) -> std::result::Result<ServerSummary, UiError> {
|
||||
async fn install_new(app: AppHandle, state: State<'_, AppState>, dest: String, package: Option<String>, game_data: Option<String>) -> std::result::Result<ServerSummary, UiError> {
|
||||
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 source = package_source(package);
|
||||
@@ -1543,6 +1565,12 @@ async fn export_diagnostics(state: State<'_, AppState>, id: String) -> std::resu
|
||||
.await
|
||||
}
|
||||
|
||||
#[tauri::command]
|
||||
async fn list_crashes(state: State<'_, AppState>, id: String, limit: Option<usize>) -> std::result::Result<Vec<coa_core::crashes::CrashItem>, 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(
|
||||
@@ -1590,6 +1618,7 @@ pub fn run() {
|
||||
.manage(AppState { registry: Registry::at(dir.join("installs.json")), busy: Mutex::new(HashSet::new()), install_cancel: Mutex::new(None), client_cancel: Mutex::new(None) })
|
||||
.invoke_handler(tauri::generate_handler![
|
||||
default_install_dir,
|
||||
install_environment,
|
||||
scan_server,
|
||||
add_server,
|
||||
list_servers,
|
||||
@@ -1677,6 +1706,7 @@ pub fn run() {
|
||||
run_diagnostics,
|
||||
verify_files,
|
||||
export_diagnostics,
|
||||
list_crashes,
|
||||
console_tail,
|
||||
console_risk,
|
||||
console_command
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
{
|
||||
"$schema": "https://schema.tauri.app/config/2",
|
||||
"productName": "CoA Server Manager",
|
||||
"version": "0.6.7",
|
||||
"version": "0.6.8",
|
||||
"identifier": "com.coa.servermanager",
|
||||
"build": {
|
||||
"beforeDevCommand": "npm run dev",
|
||||
|
||||
@@ -91,6 +91,8 @@ export {};
|
||||
if(cmd==="report_targets") return [{id:"manager",repo:"Corfirean/coa-server-manager",ours:true},{id:"companions",repo:"Corfirean/mod-coa-playerbots",ours:true},{id:"squid",repo:"Zyth45/mod-playerbots",ours:false}];
|
||||
if(cmd==="open_link"){(window as any).__lastLink=args.url;return null;}
|
||||
if(cmd==="export_diagnostics") return "C:\\Users\\you\\Desktop\\CoA-Diagnostics-20261001-140000.zip";
|
||||
if(cmd==="list_crashes") return [];
|
||||
if(cmd==="install_environment"){const docker=new URLSearchParams(location.search).get("flavor")==="docker";return docker?{flavor:"docker",default_dir:"/home/you/CoaServer",docker_problem:new URLSearchParams(location.search).has("nodocker")?"permission denied while trying to connect to the Docker daemon socket":null}:{flavor:"repack",default_dir:"C:\\Games\\CoA Server",docker_problem:null};}
|
||||
if(cmd==="install_preflight") return {ok:true,problems:[],free_bytes:210*2**30};
|
||||
if(cmd==="install_requirements") return {download_bytes:Math.round(5.9*2**30),unpacked_bytes:Math.round(11.4*2**30),version:"0.2.0"};
|
||||
if(cmd==="list_accounts"){const w=window as any;w.__acc=w.__acc??[{id:2,name:"ALICE",access:3,online:true,last_login:"2026-10-01 12:04:11",characters:4},{id:5,name:"BOB",access:0,online:false,last_login:null,characters:0},{id:6,name:"CAROL",access:2,online:false,last_login:"2026-09-30 21:40:02",characters:2}];return w.__acc;}
|
||||
|
||||
@@ -867,6 +867,21 @@ const de: Partial<Record<keyof typeof en, string>> = {
|
||||
"fr.lan.unavailable": "Ausgewählte Adresse nicht verfügbar",
|
||||
"fr.lan.unavailableText": "Die ausgewählte Adresse ist derzeit keinem erkannten lokalen Netzwerkadapter zugewiesen. Wählen Sie eine andere Adresse oder Automatisch, oder behalten Sie diese Adresse bewusst bei.",
|
||||
"fr.lan.invalid": "Ungültige IPv4-Adresse",
|
||||
"unsaved.title": "Nicht gespeicherte Änderungen",
|
||||
"unsaved.message": "Sie haben nicht gespeicherte Änderungen. Möchten Sie diese vor dem Verlassen der Seite speichern?",
|
||||
"unsaved.saveFailed": "Änderungen konnten nicht gespeichert werden. Bitte Eingaben überprüfen.",
|
||||
"crash.autoRestart": "Automatischer Neustart bei Absturz",
|
||||
"crash.autoRestartDesc": "Startet den Server automatisch neu, falls er unerwartet abstürzt.",
|
||||
"crash.badge": "Abstürze: {n}",
|
||||
"crash.historyTitle": "Absturzverlauf des Servers",
|
||||
"crash.noCrashes": "Keine Absturzberichte gefunden.",
|
||||
"crash.restartNotice": "Der Server ist abgestürzt und wurde automatisch neu gestartet (Absturz #{n}).",
|
||||
"crash.loopPaused": "Automatischer Neustart pausiert: Der Server ist mehrfach kurz hintereinander abgestürzt.",
|
||||
"crash.details": "Absturzdetails",
|
||||
"crash.viewRaw": "Vollständigen Bericht anzeigen",
|
||||
"crash.hideRaw": "Vollständigen Bericht verbergen",
|
||||
"crash.copyReport": "Bericht kopieren",
|
||||
"crash.copied": "Kopiert!",
|
||||
};
|
||||
|
||||
export default de;
|
||||
@@ -190,6 +190,14 @@ const en = {
|
||||
"install.localPkg": "Install from a local package folder instead of downloading",
|
||||
"install.localPkgHint": "(leave empty to download)",
|
||||
"install.button": "Install",
|
||||
"install.docker.title": "Docker is needed",
|
||||
"install.docker.text": "On Linux the server runs in Docker. Install Docker and start it, or allow your user to use it, then check again.",
|
||||
"install.docker.retry": "Check again",
|
||||
"install.data.label": "Game data folder",
|
||||
"install.data.hint": "The folder with the game's dbc, maps, vmaps and mmaps. It is used where it is and never changed.",
|
||||
"install.data.dialogTitle": "Choose the game data folder",
|
||||
"install.linuxPkg.label": "Server package",
|
||||
"install.linuxPkg.hint": "A folder or an address of the Linux server package",
|
||||
"install.progressTitle": "Preparing your server",
|
||||
"install.progressText": "This can take a few minutes. You can leave this window open.",
|
||||
"install.step.checking": "Checking your computer",
|
||||
@@ -890,6 +898,21 @@ const en = {
|
||||
"fr.lan.unavailable": "Selected address unavailable",
|
||||
"fr.lan.unavailableText": "The selected address is not currently assigned to a detected local interface. Choose another address or switch to Automatic, or keep this address intentionally.",
|
||||
"fr.lan.invalid": "Invalid IPv4 address",
|
||||
"unsaved.title": "Unsaved changes",
|
||||
"unsaved.message": "You have unsaved changes. Do you want to save them before leaving this page?",
|
||||
"unsaved.saveFailed": "Failed to save changes. Please check fields for errors.",
|
||||
"crash.autoRestart": "Auto-restart on crash",
|
||||
"crash.autoRestartDesc": "Automatically restart the world server if it crashes or stops unexpectedly.",
|
||||
"crash.badge": "Crashes: {n}",
|
||||
"crash.historyTitle": "Server Crash History",
|
||||
"crash.noCrashes": "No crash reports found.",
|
||||
"crash.restartNotice": "Server crashed and was automatically restarted (Crash #{n}).",
|
||||
"crash.loopPaused": "Auto-restart paused: the server crashed repeatedly in a short period.",
|
||||
"crash.details": "Crash Details",
|
||||
"crash.viewRaw": "View full crash report",
|
||||
"crash.hideRaw": "Hide full report",
|
||||
"crash.copyReport": "Copy crash report",
|
||||
"crash.copied": "Copied!",
|
||||
} as const;
|
||||
|
||||
export default en;
|
||||
@@ -867,6 +867,21 @@ const es: Partial<Record<keyof typeof en, string>> = {
|
||||
"fr.lan.unavailable": "Dirección seleccionada no disponible",
|
||||
"fr.lan.unavailableText": "La dirección seleccionada no está asignada actualmente a ninguna interfaz local detectada. Elige otra dirección o Automática, o conserva esta dirección si así lo deseas.",
|
||||
"fr.lan.invalid": "Dirección IPv4 no válida",
|
||||
"unsaved.title": "Cambios sin guardar",
|
||||
"unsaved.message": "¿Tienes cambios sin guardar. ¿Quieres guardarlos antes de salir de esta página?",
|
||||
"unsaved.saveFailed": "Error al guardar los cambios. Revisa los campos.",
|
||||
"crash.autoRestart": "Reinicio automático tras caída",
|
||||
"crash.autoRestartDesc": "Reinicia automáticamente el servidor si se detiene de forma inesperada.",
|
||||
"crash.badge": "Caídas: {n}",
|
||||
"crash.historyTitle": "Historial de caídas del servidor",
|
||||
"crash.noCrashes": "No se encontraron informes de caídas.",
|
||||
"crash.restartNotice": "El servidor se cayó y se reinició automáticamente (Caída #{n}).",
|
||||
"crash.loopPaused": "Reinicio automático pausado: el servidor se ha caído varias veces en poco tiempo.",
|
||||
"crash.details": "Detalles de la caída",
|
||||
"crash.viewRaw": "Ver informe completo",
|
||||
"crash.hideRaw": "Ocultar informe completo",
|
||||
"crash.copyReport": "Copiar informe",
|
||||
"crash.copied": "¡Copiado!",
|
||||
};
|
||||
|
||||
export default es;
|
||||
@@ -867,6 +867,21 @@ const fr: Partial<Record<keyof typeof en, string>> = {
|
||||
"fr.lan.unavailable": "Adresse sélectionnée indisponible",
|
||||
"fr.lan.unavailableText": "Cette adresse n’est actuellement attribuée à aucune interface locale détectée. Choisissez une autre adresse ou le mode Automatique, ou conservez volontairement cette adresse.",
|
||||
"fr.lan.invalid": "Adresse IPv4 non valide",
|
||||
"unsaved.title": "Modifications non enregistrées",
|
||||
"unsaved.message": "Vous avez des modifications non enregistrées. Voulez-vous les enregistrer avant de quitter cette page ?",
|
||||
"unsaved.saveFailed": "Échec de l’enregistrement. Veuillez vérifier les champs.",
|
||||
"crash.autoRestart": "Redémarrage automatique en cas de plantage",
|
||||
"crash.autoRestartDesc": "Redémarre automatiquement le serveur s’il plante ou s’arrête de manière inattendue.",
|
||||
"crash.badge": "Plantages : {n}",
|
||||
"crash.historyTitle": "Historique des plantages du serveur",
|
||||
"crash.noCrashes": "Aucun rapport de plantage trouvé.",
|
||||
"crash.restartNotice": "Le serveur a planté et a été redémarré automatiquement (Plantage #{n}).",
|
||||
"crash.loopPaused": "Redémarrage automatique suspendu : le serveur a planté plusieurs fois successivement.",
|
||||
"crash.details": "Détails du plantage",
|
||||
"crash.viewRaw": "Afficher le rapport complet",
|
||||
"crash.hideRaw": "Masquer le rapport complet",
|
||||
"crash.copyReport": "Copier le rapport",
|
||||
"crash.copied": "Copié !",
|
||||
};
|
||||
|
||||
export default fr;
|
||||
@@ -888,6 +888,21 @@ const ru: Partial<Record<keyof typeof en, string>> = {
|
||||
"fr.lan.unavailable": "Выбранный адрес недоступен",
|
||||
"fr.lan.unavailableText": "Выбранный адрес сейчас не назначен обнаруженному сетевому интерфейсу. Выберите другой адрес, переключитесь на автоматический выбор или намеренно сохраните этот адрес.",
|
||||
"fr.lan.invalid": "Некорректный IPv4-адрес",
|
||||
"unsaved.title": "Несохранённые изменения",
|
||||
"unsaved.message": "У вас есть несохранённые изменения. Сохранить их перед переходом на другую страницу?",
|
||||
"unsaved.saveFailed": "Не удалось сохранить настройки. Проверьте правильность значений.",
|
||||
"crash.autoRestart": "Автоподнятие при падении",
|
||||
"crash.autoRestartDesc": "Автоматически перезапускать сервер при внезапном падении или сбое.",
|
||||
"crash.badge": "Крашей: {n}",
|
||||
"crash.historyTitle": "История падений сервера",
|
||||
"crash.noCrashes": "Отчётов о падениях не найдено.",
|
||||
"crash.restartNotice": "Сервер упал и был автоматически перезапущен (Сбой #{n}).",
|
||||
"crash.loopPaused": "Автоподнятие приостановлено: сервер упал несколько раз подряд за короткое время.",
|
||||
"crash.details": "Подробности сбоя",
|
||||
"crash.viewRaw": "Показать полный отчёт",
|
||||
"crash.hideRaw": "Скрыть полный отчёт",
|
||||
"crash.copyReport": "Скопировать отчёт",
|
||||
"crash.copied": "Скопировано!",
|
||||
};
|
||||
|
||||
export default ru;
|
||||
@@ -869,6 +869,21 @@ const zh = {
|
||||
"fr.lan.unavailable": "所选地址不可用",
|
||||
"fr.lan.unavailableText": "所选地址目前未分配给检测到的本地网络接口。请选择其他地址、切换到自动,或有意保留此地址。",
|
||||
"fr.lan.invalid": "无效的 IPv4 地址",
|
||||
"unsaved.title": "未保存的修改",
|
||||
"unsaved.message": "您有未保存的修改。是否在离开前保存?",
|
||||
"unsaved.saveFailed": "保存失败,请检查填写内容。",
|
||||
"crash.autoRestart": "崩溃后自动重启",
|
||||
"crash.autoRestartDesc": "如果服务器意外崩溃或停止,自动重新拉起。",
|
||||
"crash.badge": "崩溃次数: {n}",
|
||||
"crash.historyTitle": "服务器崩溃记录",
|
||||
"crash.noCrashes": "未找到崩溃日志。",
|
||||
"crash.restartNotice": "服务器崩溃并已自动重新拉起(崩溃 #{n})。",
|
||||
"crash.loopPaused": "自动重启已暂停:服务器在短时间内连续崩溃。",
|
||||
"crash.details": "崩溃详情",
|
||||
"crash.viewRaw": "查看完整日志",
|
||||
"crash.hideRaw": "隐藏完整日志",
|
||||
"crash.copyReport": "复制崩溃报告",
|
||||
"crash.copied": "已复制!",
|
||||
} as const;
|
||||
|
||||
export default zh;
|
||||
+29
-2
@@ -265,6 +265,16 @@ export interface ReportTarget {
|
||||
ours: boolean;
|
||||
}
|
||||
|
||||
/** The kind of server this computer installs: a repack (Windows) or Docker containers (Linux). */
|
||||
export type Flavor = "repack" | "docker";
|
||||
|
||||
export interface InstallEnvironment {
|
||||
flavor: Flavor;
|
||||
default_dir: string;
|
||||
/** Why Docker cannot be used, in its own words; null when it works. */
|
||||
docker_problem: string | null;
|
||||
}
|
||||
|
||||
export interface InstallRequirements {
|
||||
download_bytes: number;
|
||||
unpacked_bytes: number;
|
||||
@@ -421,6 +431,21 @@ export interface ConsoleLine {
|
||||
level: "info" | "warn" | "error";
|
||||
}
|
||||
|
||||
export interface CrashItem {
|
||||
id: string;
|
||||
timestamp_ms: number;
|
||||
date_str: string;
|
||||
title: string;
|
||||
explanation: string;
|
||||
category: "assertion" | "access_violation" | "stack_overflow" | "out_of_memory" | "database" | "network" | "exception" | "generic";
|
||||
exception_code?: string | null;
|
||||
location?: string | null;
|
||||
function?: string | null;
|
||||
condition?: string | null;
|
||||
preview: string;
|
||||
full_log: string;
|
||||
}
|
||||
|
||||
export const api = {
|
||||
remoteConnection: () => invoke<RemoteConnection>("remote_connection"),
|
||||
remoteConnect: (host: string) => invoke<RemoteConnection>("remote_connect", { host }),
|
||||
@@ -454,7 +479,8 @@ export const api = {
|
||||
deleteBackup: (id: string, backupId: string) => invoke<void>("delete_backup", { id, backupId }),
|
||||
restoreConfigs: (id: string, backupId: string) => invoke<RecoveryPoint>("restore_backup_configs", { id, backupId }),
|
||||
restoreDatabase: (id: string, backupId: string, database: string) => invoke<DbRestore>("restore_backup_database", { id, backupId, database }),
|
||||
installPreflight: (dest: string, needed?: number) => invoke<Preflight>("install_preflight", { dest, needed: needed ?? null }),
|
||||
installEnvironment: () => invoke<InstallEnvironment>("install_environment"),
|
||||
installPreflight: (dest: string, needed?: number, gameData?: string) => invoke<Preflight>("install_preflight", { dest, needed: needed ?? null, gameData: gameData ?? null }),
|
||||
installRequirements: (pkg?: string) => invoke<InstallRequirements>("install_requirements", { package: pkg ?? null }),
|
||||
realmlistProfiles: (id: string) => invoke<{ profiles: RealmProfile[]; active: string | null }>("realmlist_profiles", { id }),
|
||||
realmlistSave: (id: string, profileId: string | null, name: string, data: string) => invoke<RealmProfile>("realmlist_save", { id, profileId, name, data }),
|
||||
@@ -473,7 +499,7 @@ export const api = {
|
||||
accountSetAccess: (id: string, name: string, level: number) => invoke<void>("account_set_access", { id, name, level }),
|
||||
accountRename: (id: string, name: string, newName: string, password: string) => invoke<void>("account_rename", { id, name, newName, password }),
|
||||
accountDelete: (id: string, name: string) => invoke<void>("account_delete", { id, name }),
|
||||
installNew: (dest: string, pkg?: string) => invoke<ServerSummary>("install_new", { dest, package: pkg ?? null }),
|
||||
installNew: (dest: string, pkg?: string, gameData?: string) => invoke<ServerSummary>("install_new", { dest, package: pkg ?? null, gameData: gameData ?? null }),
|
||||
cancelInstall: () => invoke<void>("cancel_install"),
|
||||
createAccount: (id: string, username: string, password: string, administrator: boolean) =>
|
||||
invoke<void>("create_account", { id, username, password, administrator }),
|
||||
@@ -512,6 +538,7 @@ export const api = {
|
||||
runDiagnostics: (id: string) => invoke<{ checks: DiagCheck[]; problems: number }>("run_diagnostics", { id }),
|
||||
verifyFiles: (id: string) => invoke<{ path: string; kind: "missing" | "changed" }[]>("verify_files", { id }),
|
||||
exportDiagnostics: (id: string) => invoke<string>("export_diagnostics", { id }),
|
||||
listCrashes: (id: string, limit?: number) => invoke<CrashItem[]>("list_crashes", { id, limit: limit ?? null }),
|
||||
consoleTail: (id: string, source: ConsoleSource, filter?: string, lines = 300) =>
|
||||
invoke<ConsoleLine[]>("console_tail", { id, source, filter: filter ?? null, lines }),
|
||||
consoleRisk: (command: string) => invoke<"normal" | "dangerous">("console_risk", { command }),
|
||||
|
||||
@@ -0,0 +1,32 @@
|
||||
import { useState } from "react";
|
||||
|
||||
const key = (id: string) => `coa-auto-restart-on-crash:${id}`;
|
||||
const fallback = () => false;
|
||||
|
||||
export function autoRestartOnCrash(id: string): boolean {
|
||||
try {
|
||||
const value = localStorage.getItem(key(id));
|
||||
return value === null ? fallback() : value === "1";
|
||||
} catch {
|
||||
return fallback();
|
||||
}
|
||||
}
|
||||
|
||||
export function setAutoRestartOnCrash(id: string, on: boolean) {
|
||||
try {
|
||||
localStorage.setItem(key(id), on ? "1" : "0");
|
||||
} catch {
|
||||
/* storage unavailable */
|
||||
}
|
||||
}
|
||||
|
||||
export function useAutoRestart(id: string): [boolean, (on: boolean) => void] {
|
||||
const [on, setOn] = useState(() => autoRestartOnCrash(id));
|
||||
return [
|
||||
on,
|
||||
(next) => {
|
||||
setAutoRestartOnCrash(id, next);
|
||||
setOn(next);
|
||||
},
|
||||
];
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
export interface UnsavedChangesGuard {
|
||||
isDirty: () => boolean;
|
||||
save: () => Promise<boolean>;
|
||||
discard: () => void;
|
||||
}
|
||||
@@ -0,0 +1,24 @@
|
||||
import { Card } from "@/components/ui/card";
|
||||
import { useT } from "@/i18n";
|
||||
import { useAutoRestart } from "@/lib/autoRestartPrefs";
|
||||
|
||||
export function AutoRestartSettings({ serverId }: { serverId: string }) {
|
||||
const t = useT();
|
||||
const [autoRestart, setAutoRestart] = useAutoRestart(serverId);
|
||||
|
||||
return (
|
||||
<Card className="mt-6 p-6">
|
||||
<h2 className="font-semibold">{t("crash.autoRestart")}</h2>
|
||||
<label className="mt-3 flex cursor-pointer items-center gap-3">
|
||||
<input
|
||||
type="checkbox"
|
||||
checked={autoRestart}
|
||||
onChange={(e) => setAutoRestart(e.target.checked)}
|
||||
className="h-4 w-4 accent-[#c9a24a]"
|
||||
/>
|
||||
<span className="text-sm font-medium">{t("crash.autoRestart")}</span>
|
||||
</label>
|
||||
<p className="mt-2 text-sm text-muted">{t("crash.autoRestartDesc")}</p>
|
||||
</Card>
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,198 @@
|
||||
import { useEffect, useState } from "react";
|
||||
import { AlertTriangle, Check, ChevronDown, ChevronUp, Copy, Loader2, X } from "lucide-react";
|
||||
import { api, type CrashItem } from "@/lib/api";
|
||||
import { Button } from "@/components/ui/button";
|
||||
import { Card } from "@/components/ui/card";
|
||||
import { useT } from "@/i18n";
|
||||
|
||||
export function CrashHistoryModal({
|
||||
serverId,
|
||||
onClose,
|
||||
}: {
|
||||
serverId: string;
|
||||
onClose: () => void;
|
||||
}) {
|
||||
const t = useT();
|
||||
const [loading, setLoading] = useState(true);
|
||||
const [crashes, setCrashes] = useState<CrashItem[]>([]);
|
||||
const [expandedId, setExpandedId] = useState<string | null>(null);
|
||||
const [copiedId, setCopiedId] = useState<string | null>(null);
|
||||
|
||||
useEffect(() => {
|
||||
let alive = true;
|
||||
void api
|
||||
.listCrashes(serverId, 30)
|
||||
.then((items) => {
|
||||
if (alive) {
|
||||
setCrashes(items);
|
||||
setLoading(false);
|
||||
}
|
||||
})
|
||||
.catch(() => {
|
||||
if (alive) setLoading(false);
|
||||
});
|
||||
return () => {
|
||||
alive = false;
|
||||
};
|
||||
}, [serverId]);
|
||||
|
||||
useEffect(() => {
|
||||
const onKey = (e: KeyboardEvent) => {
|
||||
if (e.key === "Escape") onClose();
|
||||
};
|
||||
window.addEventListener("keydown", onKey);
|
||||
return () => window.removeEventListener("keydown", onKey);
|
||||
}, [onClose]);
|
||||
|
||||
const copyReport = async (item: CrashItem) => {
|
||||
try {
|
||||
await navigator.clipboard.writeText(item.full_log);
|
||||
setCopiedId(item.id);
|
||||
setTimeout(() => setCopiedId(null), 2500);
|
||||
} catch {
|
||||
/* clipboard write failed */
|
||||
}
|
||||
};
|
||||
|
||||
const getCategoryColor = (category: CrashItem["category"]) => {
|
||||
switch (category) {
|
||||
case "assertion":
|
||||
return "bg-amber-500/15 text-amber-400 border-amber-500/30";
|
||||
case "access_violation":
|
||||
case "stack_overflow":
|
||||
case "out_of_memory":
|
||||
return "bg-bad/15 text-bad border-bad/30";
|
||||
case "network":
|
||||
case "database":
|
||||
return "bg-blue-500/15 text-blue-400 border-blue-500/30";
|
||||
default:
|
||||
return "bg-muted/15 text-muted border-line";
|
||||
}
|
||||
};
|
||||
|
||||
return (
|
||||
<div
|
||||
className="fixed inset-0 z-50 flex items-center justify-center bg-black/60 p-4 md:p-6"
|
||||
role="presentation"
|
||||
onClick={(e) => {
|
||||
if (e.target === e.currentTarget) onClose();
|
||||
}}
|
||||
>
|
||||
<Card
|
||||
className="flex max-h-[85vh] w-full max-w-2xl flex-col p-6 shadow-2xl"
|
||||
role="dialog"
|
||||
aria-modal="true"
|
||||
aria-label={t("crash.historyTitle")}
|
||||
>
|
||||
<div className="flex items-center justify-between border-b border-line pb-4">
|
||||
<div className="flex items-center gap-2.5">
|
||||
<AlertTriangle className="h-5 w-5 text-warn" aria-hidden />
|
||||
<h2 className="text-lg font-semibold">{t("crash.historyTitle")}</h2>
|
||||
</div>
|
||||
<button
|
||||
type="button"
|
||||
onClick={onClose}
|
||||
className="cursor-pointer text-muted transition-colors hover:text-ink"
|
||||
aria-label={t("btn.close")}
|
||||
>
|
||||
<X className="h-5 w-5" aria-hidden />
|
||||
</button>
|
||||
</div>
|
||||
|
||||
<div className="flex-1 overflow-y-auto py-4">
|
||||
{loading ? (
|
||||
<div className="flex items-center justify-center py-12 text-muted">
|
||||
<Loader2 className="h-6 w-6 animate-spin" aria-hidden />
|
||||
</div>
|
||||
) : crashes.length === 0 ? (
|
||||
<div className="py-12 text-center text-muted">
|
||||
<p>{t("crash.noCrashes")}</p>
|
||||
</div>
|
||||
) : (
|
||||
<div className="space-y-4">
|
||||
{crashes.map((item) => {
|
||||
const isExpanded = expandedId === item.id;
|
||||
const isCopied = copiedId === item.id;
|
||||
return (
|
||||
<div
|
||||
key={item.id}
|
||||
className="rounded-lg border border-line bg-card-2 p-4 text-sm transition-all"
|
||||
>
|
||||
<div className="flex flex-wrap items-start justify-between gap-2">
|
||||
<div>
|
||||
<span
|
||||
className={`inline-block rounded border px-2 py-0.5 text-xs font-medium uppercase tracking-wide ${getCategoryColor(
|
||||
item.category,
|
||||
)}`}
|
||||
>
|
||||
{item.exception_code ? `${item.category} (${item.exception_code})` : item.category}
|
||||
</span>
|
||||
<h3 className="mt-1.5 font-semibold text-ink">{item.title}</h3>
|
||||
</div>
|
||||
<span className="text-xs text-muted tabular-nums">{item.date_str}</span>
|
||||
</div>
|
||||
|
||||
<p className="mt-2 text-xs leading-relaxed text-muted">{item.explanation}</p>
|
||||
|
||||
<div className="mt-3 flex items-center justify-between border-t border-line/50 pt-2.5">
|
||||
<button
|
||||
type="button"
|
||||
onClick={() => setExpandedId(isExpanded ? null : item.id)}
|
||||
className="inline-flex cursor-pointer items-center gap-1.5 text-xs font-medium text-gold transition-colors hover:underline"
|
||||
>
|
||||
{isExpanded ? (
|
||||
<>
|
||||
<ChevronUp className="h-3.5 w-3.5" aria-hidden />
|
||||
{t("crash.hideRaw")}
|
||||
</>
|
||||
) : (
|
||||
<>
|
||||
<ChevronDown className="h-3.5 w-3.5" aria-hidden />
|
||||
{t("crash.viewRaw")}
|
||||
</>
|
||||
)}
|
||||
</button>
|
||||
|
||||
<Button
|
||||
variant="ghost"
|
||||
size="sm"
|
||||
onClick={() => void copyReport(item)}
|
||||
className="h-7 gap-1.5 px-2 text-xs text-muted hover:text-ink"
|
||||
>
|
||||
{isCopied ? (
|
||||
<>
|
||||
<Check className="h-3.5 w-3.5 text-ok" aria-hidden />
|
||||
<span className="text-ok">{t("crash.copied")}</span>
|
||||
</>
|
||||
) : (
|
||||
<>
|
||||
<Copy className="h-3.5 w-3.5" aria-hidden />
|
||||
<span>{t("crash.copyReport")}</span>
|
||||
</>
|
||||
)}
|
||||
</Button>
|
||||
</div>
|
||||
|
||||
{isExpanded && (
|
||||
<div className="mt-3">
|
||||
<pre className="selectable max-h-56 overflow-x-auto overflow-y-auto rounded border border-line bg-black/40 p-3 font-mono text-[11px] leading-relaxed text-muted">
|
||||
{item.full_log}
|
||||
</pre>
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
);
|
||||
})}
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
|
||||
<div className="flex justify-end border-t border-line pt-4">
|
||||
<Button variant="secondary" onClick={onClose}>
|
||||
{t("btn.close")}
|
||||
</Button>
|
||||
</div>
|
||||
</Card>
|
||||
</div>
|
||||
);
|
||||
}
|
||||
@@ -2,7 +2,7 @@ import { useEffect, useState } from "react";
|
||||
import { listen } from "@tauri-apps/api/event";
|
||||
import { open } from "@tauri-apps/plugin-dialog";
|
||||
import { Check, ChevronDown, ChevronRight, Loader2 } from "lucide-react";
|
||||
import { api, asUiError, type InstallRequirements, type InstallStep, type Preflight, type ServerSummary, type UiError } from "@/lib/api";
|
||||
import { api, asUiError, type InstallEnvironment, type InstallRequirements, type InstallStep, type Preflight, type ServerSummary, type UiError } from "@/lib/api";
|
||||
import { formatBytes } from "@/lib/utils";
|
||||
import { Button } from "@/components/ui/button";
|
||||
import { Card } from "@/components/ui/card";
|
||||
@@ -33,6 +33,19 @@ export function InstallServer(props: { canCancel: boolean; onCancel: () => void;
|
||||
const [pkg, setPkg] = useState("");
|
||||
const [installed, setInstalled] = useState<ServerSummary | null>(null);
|
||||
const [showDetails, setShowDetails] = useState(false);
|
||||
// What this computer installs. A repack (Windows) needs nothing more than a folder; Docker (Linux) also needs the game data
|
||||
// folder and a package, and Docker itself.
|
||||
const [env, setEnv] = useState<InstallEnvironment | null>(null);
|
||||
const [gameData, setGameData] = useState("");
|
||||
const docker = env?.flavor === "docker";
|
||||
|
||||
function loadEnvironment(first: boolean) {
|
||||
void api.installEnvironment().then((e) => {
|
||||
setEnv(e);
|
||||
if (first && e.flavor === "docker") setDest(e.default_dir);
|
||||
}).catch(() => setEnv(null));
|
||||
}
|
||||
useEffect(() => loadEnvironment(true), []);
|
||||
|
||||
// how big the server is, from the package's signed list (re-read when another package source is entered)
|
||||
useEffect(() => {
|
||||
@@ -43,9 +56,9 @@ export function InstallServer(props: { canCancel: boolean; onCancel: () => void;
|
||||
// room for the unpacked server plus the download that is removed afterwards
|
||||
const needed = req ? req.unpacked_bytes + req.download_bytes : undefined;
|
||||
useEffect(() => {
|
||||
const timer = setTimeout(() => void api.installPreflight(dest, needed).then(setPre).catch(() => setPre(null)), 250);
|
||||
const timer = setTimeout(() => void api.installPreflight(dest, needed, docker ? gameData.trim() : undefined).then(setPre).catch(() => setPre(null)), 250);
|
||||
return () => clearTimeout(timer);
|
||||
}, [dest, needed]);
|
||||
}, [dest, needed, docker, gameData]);
|
||||
|
||||
useEffect(() => {
|
||||
const un = listen<InstallStep>("install-progress", (e) => setStep(e.payload));
|
||||
@@ -56,7 +69,12 @@ export function InstallServer(props: { canCancel: boolean; onCancel: () => void;
|
||||
|
||||
async function browse() {
|
||||
const picked = await open({ directory: true, multiple: false, title: t("install.dialogTitle") });
|
||||
if (typeof picked === "string") setDest(picked.replace(/[\\/]+$/, "") + (picked.toLowerCase().includes("coa") ? "" : "\\CoA Server"));
|
||||
if (typeof picked === "string") setDest(picked.replace(/[\\/]+$/, "") + (picked.toLowerCase().includes("coa") ? "" : docker ? "/CoaServer" : "\\CoA Server"));
|
||||
}
|
||||
|
||||
async function browseGameData() {
|
||||
const picked = await open({ directory: true, multiple: false, title: t("install.data.dialogTitle") });
|
||||
if (typeof picked === "string") setGameData(picked);
|
||||
}
|
||||
|
||||
async function browsePackage() {
|
||||
@@ -69,7 +87,7 @@ export function InstallServer(props: { canCancel: boolean; onCancel: () => void;
|
||||
setPhase("installing");
|
||||
setStep({ step: "Preparing your server", percent: 0, detail: null });
|
||||
try {
|
||||
const s = await api.installNew(dest, pkg.trim() || undefined);
|
||||
const s = await api.installNew(dest, pkg.trim() || undefined, docker ? gameData.trim() : undefined);
|
||||
setInstalled(s);
|
||||
setPhase("done");
|
||||
} catch (e) {
|
||||
@@ -139,9 +157,34 @@ export function InstallServer(props: { canCancel: boolean; onCancel: () => void;
|
||||
</div>
|
||||
</div>
|
||||
|
||||
{pre && pre.problems.length > 0 && (
|
||||
{docker && (
|
||||
<div>
|
||||
<label htmlFor="gamedata" className="text-sm text-muted">{t("install.data.label")}</label>
|
||||
<div className="mt-1 flex gap-2">
|
||||
<input id="gamedata" value={gameData} onChange={(e) => setGameData(e.target.value)} className="selectable flex-1 rounded-md border border-line bg-card px-3 py-2.5 text-[15px] outline-none focus:border-gold" />
|
||||
<Button onClick={browseGameData}>{t("install.browse")}</Button>
|
||||
</div>
|
||||
<p className="mt-1 text-xs text-muted">{t("install.data.hint")}</p>
|
||||
<label htmlFor="linuxpkg" className="mt-4 block text-sm text-muted">{t("install.linuxPkg.label")}</label>
|
||||
<div className="mt-1 flex gap-2">
|
||||
<input id="linuxpkg" value={pkg} onChange={(e) => setPkg(e.target.value)} placeholder={t("install.linuxPkg.hint")} className="selectable flex-1 rounded-md border border-line bg-card px-3 py-2.5 text-[15px] outline-none focus:border-gold" />
|
||||
<Button onClick={browsePackage}>{t("install.browse")}</Button>
|
||||
</div>
|
||||
</div>
|
||||
)}
|
||||
|
||||
{docker && env?.docker_problem && (
|
||||
<Card className="border-warn/40 p-4" role="alert">
|
||||
{pre.problems.map((p) => (
|
||||
<p className="font-medium text-warn">{t("install.docker.title")}</p>
|
||||
<p className="mt-1 text-sm text-muted">{t("install.docker.text")}</p>
|
||||
<pre className="mt-2 max-h-24 overflow-auto whitespace-pre-wrap rounded bg-black/40 p-2 text-xs">{env.docker_problem}</pre>
|
||||
<Button className="mt-3" size="sm" onClick={() => loadEnvironment(false)}>{t("install.docker.retry")}</Button>
|
||||
</Card>
|
||||
)}
|
||||
|
||||
{pre && pre.problems.some((p) => !(docker && !gameData.trim() && p.code.startsWith("data"))) && (
|
||||
<Card className="border-warn/40 p-4" role="alert">
|
||||
{pre.problems.filter((p) => !(docker && !gameData.trim() && p.code.startsWith("data"))).map((p) => (
|
||||
<p key={p.code} className="text-sm text-warn">{p.message}</p>
|
||||
))}
|
||||
</Card>
|
||||
@@ -170,7 +213,7 @@ export function InstallServer(props: { canCancel: boolean; onCancel: () => void;
|
||||
</Card>
|
||||
)}
|
||||
|
||||
<div>
|
||||
{!docker && <div>
|
||||
<button onClick={() => setShowAdvanced((v) => !v)} aria-expanded={showAdvanced} className="flex cursor-pointer items-center gap-1 text-sm text-muted hover:text-ink">
|
||||
{showAdvanced ? <ChevronDown className="h-4 w-4" aria-hidden /> : <ChevronRight className="h-4 w-4" aria-hidden />}
|
||||
{t("install.advanced")}
|
||||
@@ -184,10 +227,10 @@ export function InstallServer(props: { canCancel: boolean; onCancel: () => void;
|
||||
</div>
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
</div>}
|
||||
|
||||
<div className="flex items-center gap-3">
|
||||
<Button variant="primary" size="md" disabled={!pre?.ok} onClick={() => void install()}>
|
||||
<Button variant="primary" size="md" disabled={!pre?.ok || (docker && (!!env?.docker_problem || !gameData.trim() || !pkg.trim()))} onClick={() => void install()}>
|
||||
{t("install.button")}
|
||||
</Button>
|
||||
{props.canCancel && (
|
||||
|
||||
@@ -7,6 +7,7 @@ import { Card } from "@/components/ui/card";
|
||||
import { useHuman, useI18n, useSchemaText, type Key } from "@/i18n";
|
||||
import { auctionWeightKey, canonicalModuleValue, moduleEnableKey, moduleField } from "@/lib/moduleSettings";
|
||||
import { AuctionTypes } from "@/screens/AuctionTypes";
|
||||
import type { UnsavedChangesGuard } from "@/lib/unsavedGuard";
|
||||
|
||||
/** The GitHub mark (lucide dropped its brand icons). */
|
||||
function GithubMark(props: { className?: string }) {
|
||||
@@ -78,13 +79,19 @@ function Tile({ icon, off }: { icon: string; off: boolean }) {
|
||||
}
|
||||
|
||||
/** The server's optional modules: square cards with a switch, the module's status, a link to GitHub and its settings. */
|
||||
export function ModulesPage({ serverId, onChanged }: { serverId: string; onChanged?: () => void }) {
|
||||
export function ModulesPage({ serverId, onChanged, onRegisterGuard }: { serverId: string; onChanged?: () => void; onRegisterGuard?: (guard: UnsavedChangesGuard | null) => void }) {
|
||||
const { t, locale } = useI18n();
|
||||
const human = useHuman();
|
||||
const [modules, setModules] = useState<ModuleView[] | null>(null);
|
||||
const [open, setOpen] = useState<string | null>(null);
|
||||
const [error, setError] = useState<UiError | null>(null);
|
||||
const [changed, setChanged] = useState(false);
|
||||
const [guard, setGuard] = useState<UnsavedChangesGuard | null>(null);
|
||||
|
||||
useEffect(() => {
|
||||
onRegisterGuard?.(guard);
|
||||
return () => onRegisterGuard?.(null);
|
||||
}, [guard, onRegisterGuard]);
|
||||
|
||||
const load = useCallback(async () => {
|
||||
try {
|
||||
@@ -174,7 +181,7 @@ export function ModulesPage({ serverId, onChanged }: { serverId: string; onChang
|
||||
{selected?.has_settings && !selected.page && selectedAt >= 0 && Math.floor(selectedAt / 2) === Math.floor(i / 2) && (i % 2 === 1 || i === modules.length - 1) && (
|
||||
<SettingsPanel key={selected.id} className="sm:col-span-2">
|
||||
<h2 className="font-semibold">{t("mod.settingsOf", { name: selected.name })}</h2>
|
||||
<ModuleSettings serverId={serverId} module={selected} onSaved={() => setChanged(true)} />
|
||||
<ModuleSettings serverId={serverId} module={selected} onSaved={() => setChanged(true)} onRegisterGuard={setGuard} />
|
||||
</SettingsPanel>
|
||||
)}
|
||||
</Fragment>
|
||||
@@ -184,8 +191,8 @@ export function ModulesPage({ serverId, onChanged }: { serverId: string; onChang
|
||||
);
|
||||
}
|
||||
|
||||
function ModuleSettings({ serverId, module, onSaved }: { serverId: string; module: ModuleView; onSaved: () => void }) {
|
||||
const { t, locale } = useI18n();
|
||||
function ModuleSettings({ serverId, module, onSaved, onRegisterGuard }: { serverId: string; module: ModuleView; onSaved: () => void; onRegisterGuard?: (guard: UnsavedChangesGuard | null) => void }) {
|
||||
const { t, tn, locale } = useI18n();
|
||||
const sx = useSchemaText();
|
||||
const human = useHuman();
|
||||
const [advanced, setAdvanced] = useState(false);
|
||||
@@ -208,7 +215,7 @@ function ModuleSettings({ serverId, module, onSaved }: { serverId: string; modul
|
||||
return () => { cancelled = true; };
|
||||
}, [serverId, module.id]);
|
||||
|
||||
async function save() {
|
||||
async function save(): Promise<boolean> {
|
||||
const errors: Record<string, string> = {};
|
||||
for (const [key, value] of Object.entries(edits)) {
|
||||
const field = moduleField(key, locale, items?.find(item => item.key === key)?.field);
|
||||
@@ -222,7 +229,7 @@ function ModuleSettings({ serverId, module, onSaved }: { serverId: string; modul
|
||||
}
|
||||
}
|
||||
setFieldErrors(errors);
|
||||
if (Object.keys(errors).length) return;
|
||||
if (Object.keys(errors).length) return false;
|
||||
setBusy(true);
|
||||
setError(null);
|
||||
setNote(null);
|
||||
@@ -234,14 +241,33 @@ function ModuleSettings({ serverId, module, onSaved }: { serverId: string; modul
|
||||
onSaved();
|
||||
setNote(t("mod.saved", { n: done.length }));
|
||||
}
|
||||
return true;
|
||||
} catch (e) {
|
||||
setError(asUiError(e));
|
||||
return false;
|
||||
} finally {
|
||||
setBusy(false);
|
||||
}
|
||||
}
|
||||
|
||||
const dirty = Object.keys(edits).length > 0;
|
||||
|
||||
useEffect(() => {
|
||||
if (dirty) {
|
||||
onRegisterGuard?.({
|
||||
isDirty: () => Object.keys(edits).length > 0,
|
||||
save: () => save(),
|
||||
discard: () => {
|
||||
setEdits({});
|
||||
setFieldErrors({});
|
||||
setNote(null);
|
||||
},
|
||||
});
|
||||
} else {
|
||||
onRegisterGuard?.(null);
|
||||
}
|
||||
return () => onRegisterGuard?.(null);
|
||||
}, [dirty, edits, onRegisterGuard]);
|
||||
const edit = (key: string, value: string) => setEdits(previous => {
|
||||
const next = { ...previous };
|
||||
if (value === items?.find(item => item.key === key)?.value) delete next[key];
|
||||
@@ -324,6 +350,20 @@ function ModuleSettings({ serverId, module, onSaved }: { serverId: string; modul
|
||||
{note && <span className="text-sm text-ok" role="status">{note}</span>}
|
||||
</div>}
|
||||
{error && <p className="mt-2 text-sm text-bad" role="alert">{error.human.code === "unknown" ? error.technical : human(error.human).message}</p>}
|
||||
{dirty && (
|
||||
<div className="fixed bottom-0 left-60 right-0 z-40 flex items-center justify-between border-t border-line bg-[#0b0c0e]/95 px-10 py-3 shadow-lg">
|
||||
<span className="text-sm text-muted">{tn("set.unsaved", Object.keys(edits).length)}</span>
|
||||
<div className="flex gap-2">
|
||||
<Button variant="ghost" size="sm" disabled={busy} onClick={() => { setEdits({}); setFieldErrors({}); setNote(null); }}>
|
||||
{t("set.discard")}
|
||||
</Button>
|
||||
<Button variant="primary" size="sm" disabled={busy} onClick={() => void save()}>
|
||||
{busy && <Loader2 className="mr-1.5 h-3.5 w-3.5 animate-spin" aria-hidden />}
|
||||
{t("acc.save")}
|
||||
</Button>
|
||||
</div>
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
);
|
||||
}
|
||||
+181
-33
@@ -1,6 +1,6 @@
|
||||
import { dismissClientJob, startClientUpdate, stopClientJob, syncClient, useClientJob } from "@/lib/clientJob";
|
||||
import { useCallback, useEffect, useRef, useState } from "react";
|
||||
import { Loader2, X } from "lucide-react";
|
||||
import { AlertTriangle, Loader2, X } from "lucide-react";
|
||||
import { api, asUiError, type ClientInfo, type Human, type Performance, type Population, type ServerSummary, type ServiceStatus, type StatusView } from "@/lib/api";
|
||||
import { cn, formatBytes, formatUptime } from "@/lib/utils";
|
||||
import { useHuman, useT } from "@/i18n";
|
||||
@@ -9,6 +9,8 @@ import { checkClient, useClientStatus } from "@/lib/clientUpdate";
|
||||
import { ClientDialog, type ClientDialogMode } from "@/screens/ClientDialog";
|
||||
import { RealmlistMenu } from "@/screens/RealmlistMenu";
|
||||
import { RealmPicker } from "@/screens/RealmPicker";
|
||||
import { CrashHistoryModal } from "@/screens/CrashHistoryModal";
|
||||
import { useAutoRestart } from "@/lib/autoRestartPrefs";
|
||||
import { Button } from "@/components/ui/button";
|
||||
import { Card } from "@/components/ui/card";
|
||||
|
||||
@@ -98,6 +100,35 @@ export function Overview({ server, companions = true, onForget, onOpenUpdates, o
|
||||
const upd = useServerUpdate(server.id);
|
||||
const needsDecision = (upd.preview?.conflicts.length ?? 0) > 0;
|
||||
const [startBots, setStartBots] = useState<number | null | undefined>(undefined);
|
||||
const [autoRestart, setAutoRestart] = useAutoRestart(server.id);
|
||||
const autoRestartRef = useRef(autoRestart);
|
||||
autoRestartRef.current = autoRestart;
|
||||
|
||||
const [crashCount, setCrashCount] = useState(0);
|
||||
const crashCountRef = useRef(0);
|
||||
const [showCrashModal, setShowCrashModal] = useState(false);
|
||||
const [hasCrashHistory, setHasCrashHistory] = useState(false);
|
||||
const [crashLoopPaused, setCrashLoopPaused] = useState(false);
|
||||
const [crashRestartNotice, setCrashRestartNotice] = useState<string | null>(null);
|
||||
|
||||
const userStoppedRef = useRef(false);
|
||||
const wasWorldRunningRef = useRef(false);
|
||||
const actionRef = useRef<Action>(null);
|
||||
const crashTimestampsRef = useRef<number[]>([]);
|
||||
const pollRef = useRef<() => Promise<void>>(undefined);
|
||||
|
||||
useEffect(() => {
|
||||
let active = true;
|
||||
void api
|
||||
.listCrashes(server.id, 1)
|
||||
.then((items) => {
|
||||
if (active && items.length > 0) setHasCrashHistory(true);
|
||||
})
|
||||
.catch(() => {});
|
||||
return () => {
|
||||
active = false;
|
||||
};
|
||||
}, [server.id]);
|
||||
|
||||
useEffect(() => {
|
||||
void api
|
||||
@@ -115,18 +146,87 @@ export function Overview({ server, companions = true, onForget, onOpenUpdates, o
|
||||
if (job.phase === "done" || job.phase === "current") void api.clientInfo(server.id).then(setClient).catch(() => undefined);
|
||||
}, [job.phase, server.id]);
|
||||
|
||||
const run = useCallback(
|
||||
async (kind: Exclude<Action, null>) => {
|
||||
if (kind === "stopping") {
|
||||
userStoppedRef.current = true;
|
||||
} else {
|
||||
userStoppedRef.current = false;
|
||||
setCrashLoopPaused(false);
|
||||
setCrashRestartNotice(null);
|
||||
}
|
||||
setFailure(null);
|
||||
setShowDetails(false);
|
||||
setAction(kind);
|
||||
actionRef.current = kind;
|
||||
try {
|
||||
if (kind !== "starting") {
|
||||
const out = await api.stop(server.id);
|
||||
if (!out.ok) throw { human: out.human, technical: out.output };
|
||||
}
|
||||
if (kind !== "stopping") {
|
||||
setAction("starting");
|
||||
actionRef.current = "starting";
|
||||
const out = await api.start(server.id);
|
||||
if (!out.ok) throw { human: out.human, technical: out.output };
|
||||
}
|
||||
} catch (e) {
|
||||
const ui = asUiError(e);
|
||||
setFailure({ human: ui.human ?? asUiError(String(e)).human, technical: ui.technical });
|
||||
} finally {
|
||||
setAction(null);
|
||||
actionRef.current = null;
|
||||
void pollRef.current?.();
|
||||
}
|
||||
},
|
||||
[server.id],
|
||||
);
|
||||
|
||||
const poll = useCallback(async () => {
|
||||
try {
|
||||
const s = await api.status(server.id);
|
||||
if (alive.current) setStatus(s);
|
||||
if (s.observed.world.state === "running") {
|
||||
const isWorldRunning = s.observed.world.state === "running";
|
||||
if (isWorldRunning) {
|
||||
wasWorldRunningRef.current = true;
|
||||
userStoppedRef.current = false;
|
||||
const p = await api.population(server.id).catch(() => null);
|
||||
if (alive.current) setPop(p);
|
||||
} else if (alive.current) setPop(null);
|
||||
} else {
|
||||
if (alive.current) setPop(null);
|
||||
if (
|
||||
wasWorldRunningRef.current &&
|
||||
!userStoppedRef.current &&
|
||||
actionRef.current === null
|
||||
) {
|
||||
wasWorldRunningRef.current = false;
|
||||
setHasCrashHistory(true);
|
||||
const now = Date.now();
|
||||
const recent = crashTimestampsRef.current.filter((ts) => now - ts < 180000);
|
||||
recent.push(now);
|
||||
crashTimestampsRef.current = recent;
|
||||
|
||||
crashCountRef.current += 1;
|
||||
const currentCrashCount = crashCountRef.current;
|
||||
setCrashCount(currentCrashCount);
|
||||
|
||||
if (recent.length >= 3) {
|
||||
setCrashLoopPaused(true);
|
||||
setCrashRestartNotice(null);
|
||||
} else if (autoRestartRef.current) {
|
||||
setCrashRestartNotice(t("crash.restartNotice", { n: currentCrashCount }));
|
||||
void run("starting");
|
||||
}
|
||||
}
|
||||
}
|
||||
} catch {
|
||||
/* transient; next poll retries */
|
||||
}
|
||||
}, [server.id]);
|
||||
}, [server.id, t, run]);
|
||||
|
||||
useEffect(() => {
|
||||
pollRef.current = poll;
|
||||
}, [poll]);
|
||||
|
||||
// The tick rate comes from the server console (one short connection per reading), so it is read less often.
|
||||
const worldUp = status?.observed.world.state === "running";
|
||||
@@ -156,29 +256,6 @@ export function Overview({ server, companions = true, onForget, onOpenUpdates, o
|
||||
};
|
||||
}, [poll]);
|
||||
|
||||
async function run(kind: Exclude<Action, null>) {
|
||||
setFailure(null);
|
||||
setShowDetails(false);
|
||||
setAction(kind);
|
||||
try {
|
||||
if (kind !== "starting") {
|
||||
const out = await api.stop(server.id);
|
||||
if (!out.ok) throw { human: out.human, technical: out.output };
|
||||
}
|
||||
if (kind !== "stopping") {
|
||||
setAction("starting");
|
||||
const out = await api.start(server.id);
|
||||
if (!out.ok) throw { human: out.human, technical: out.output };
|
||||
}
|
||||
} catch (e) {
|
||||
const ui = asUiError(e);
|
||||
setFailure({ human: ui.human ?? asUiError(String(e)).human, technical: ui.technical });
|
||||
} finally {
|
||||
setAction(null);
|
||||
void poll();
|
||||
}
|
||||
}
|
||||
|
||||
async function play() {
|
||||
setFailure(null);
|
||||
setShowDetails(false);
|
||||
@@ -234,13 +311,56 @@ export function Overview({ server, companions = true, onForget, onOpenUpdates, o
|
||||
|
||||
<Card className="mt-6 p-7">
|
||||
<div className="mb-1 text-xs font-medium uppercase tracking-[0.14em] text-muted">{realms ? `${realms.first} · ${t("overview.server")}` : t("overview.server")}</div>
|
||||
<div className={cn("flex items-center gap-3 text-3xl font-semibold", tone)} role="status" aria-live="polite">
|
||||
<span
|
||||
aria-hidden
|
||||
className={cn("h-3 w-3 rounded-full", running && !transitioning ? "bg-ok" : transitioning || anyUp ? "bg-warn" : "bg-muted/50")}
|
||||
/>
|
||||
{headline}
|
||||
<div className="flex flex-wrap items-center justify-between gap-3">
|
||||
<div className={cn("flex items-center gap-3 text-3xl font-semibold", tone)} role="status" aria-live="polite">
|
||||
<span
|
||||
aria-hidden
|
||||
className={cn("h-3 w-3 rounded-full", running && !transitioning ? "bg-ok" : transitioning || anyUp ? "bg-warn" : "bg-muted/50")}
|
||||
/>
|
||||
{headline}
|
||||
</div>
|
||||
{(crashCount > 0 || hasCrashHistory) && (
|
||||
<button
|
||||
type="button"
|
||||
onClick={() => setShowCrashModal(true)}
|
||||
className={cn(
|
||||
"inline-flex cursor-pointer items-center gap-1.5 rounded-full px-3 py-1 text-xs font-medium transition-colors",
|
||||
crashCount > 0
|
||||
? "border border-bad/40 bg-bad/15 text-bad hover:bg-bad/25"
|
||||
: "border border-line bg-card-2 text-muted hover:text-ink hover:border-gold/40",
|
||||
)}
|
||||
title={t("crash.historyTitle")}
|
||||
>
|
||||
<AlertTriangle className="h-3.5 w-3.5" aria-hidden />
|
||||
<span>{crashCount > 0 ? t("crash.badge", { n: crashCount }) : t("crash.historyTitle")}</span>
|
||||
</button>
|
||||
)}
|
||||
</div>
|
||||
{crashRestartNotice && !crashLoopPaused && (
|
||||
<div className="mt-3 flex items-center justify-between rounded-md border border-amber-500/30 bg-amber-500/10 p-3 text-xs text-amber-300">
|
||||
<span>{crashRestartNotice}</span>
|
||||
<button
|
||||
type="button"
|
||||
onClick={() => setCrashRestartNotice(null)}
|
||||
className="cursor-pointer text-amber-300/70 hover:text-amber-300"
|
||||
aria-label={t("btn.close")}
|
||||
>
|
||||
<X className="h-4 w-4" />
|
||||
</button>
|
||||
</div>
|
||||
)}
|
||||
{crashLoopPaused && (
|
||||
<div className="mt-3 flex items-center justify-between rounded-md border border-bad/40 bg-bad/15 p-3 text-xs text-bad">
|
||||
<span>{t("crash.loopPaused")}</span>
|
||||
<button
|
||||
type="button"
|
||||
onClick={() => setShowCrashModal(true)}
|
||||
className="cursor-pointer font-medium underline"
|
||||
>
|
||||
{t("crash.historyTitle")}
|
||||
</button>
|
||||
</div>
|
||||
)}
|
||||
{!transitioning && !running && anyUp && (
|
||||
<p className="mt-2 text-sm text-muted">
|
||||
{t("overview.reportHint")}{" "}
|
||||
@@ -363,6 +483,27 @@ export function Overview({ server, companions = true, onForget, onOpenUpdates, o
|
||||
)}
|
||||
</div>
|
||||
</div>
|
||||
<div className="mt-6 flex flex-wrap items-center justify-between gap-3 border-t border-line/60 pt-4 text-xs text-muted">
|
||||
<label className="flex cursor-pointer items-center gap-2">
|
||||
<input
|
||||
type="checkbox"
|
||||
checked={autoRestart}
|
||||
onChange={(e) => setAutoRestart(e.target.checked)}
|
||||
className="h-3.5 w-3.5 accent-[#c9a24a]"
|
||||
/>
|
||||
<span className="font-medium text-ink/80">{t("crash.autoRestart")}</span>
|
||||
<span className="hidden sm:inline text-muted">— {t("crash.autoRestartDesc")}</span>
|
||||
</label>
|
||||
{(crashCount > 0 || hasCrashHistory) && (
|
||||
<button
|
||||
type="button"
|
||||
onClick={() => setShowCrashModal(true)}
|
||||
className="cursor-pointer text-gold hover:underline"
|
||||
>
|
||||
{t("crash.historyTitle")}
|
||||
</button>
|
||||
)}
|
||||
</div>
|
||||
{anyUp && !running && !transitioning && (
|
||||
<p className="mt-3 text-sm text-muted">{t("overview.partial")}</p>
|
||||
)}
|
||||
@@ -477,6 +618,13 @@ export function Overview({ server, companions = true, onForget, onOpenUpdates, o
|
||||
onPlayAnyway={() => void play()}
|
||||
/>
|
||||
)}
|
||||
|
||||
{showCrashModal && (
|
||||
<CrashHistoryModal
|
||||
serverId={server.id}
|
||||
onClose={() => setShowCrashModal(false)}
|
||||
/>
|
||||
)}
|
||||
</div>
|
||||
);
|
||||
}
|
||||
@@ -15,6 +15,7 @@ import { hasKey, useHuman, useI18n, type Key } from "@/i18n";
|
||||
import { LanguagePicker } from "@/components/LanguagePicker";
|
||||
import { RealmStartupSettings } from "@/screens/RealmStartupSettings";
|
||||
import { RepairCard } from "@/screens/RepairCard";
|
||||
import { AutoRestartSettings } from "@/screens/AutoRestartSettings";
|
||||
|
||||
function mb(bytes: number) {
|
||||
return bytes >= 1 << 20 ? `${(bytes / (1 << 20)).toFixed(1)} MB` : `${Math.max(1, Math.round(bytes / 1024))} KB`;
|
||||
@@ -171,6 +172,7 @@ export function SettingsHome({ serverId, path, onForget }: { serverId: string; p
|
||||
|
||||
<ClientCard serverId={serverId} />
|
||||
<RealmStartupSettings serverId={serverId} />
|
||||
<AutoRestartSettings serverId={serverId} />
|
||||
|
||||
<DiagnosticsCard serverId={serverId} />
|
||||
<RepairCard key={serverId} serverId={serverId} />
|
||||
|
||||
@@ -22,6 +22,7 @@ import { Card } from "@/components/ui/card";
|
||||
import { CollectionRows, RawRows, collectionsOf } from "@/screens/ExtraRows";
|
||||
import { CompanionsCard } from "@/screens/CompanionsCard";
|
||||
import { useHuman, useI18n, useSchemaText, useT, type Key } from "@/i18n";
|
||||
import type { UnsavedChangesGuard } from "@/lib/unsavedGuard";
|
||||
|
||||
type T = (k: Key, v?: Record<string, string | number>) => string;
|
||||
|
||||
@@ -154,7 +155,14 @@ function Row(props: { s: SettingView; value: JsonValue; error: string | null; on
|
||||
);
|
||||
}
|
||||
|
||||
export function SettingsPage(props: { serverId: string; scope: Scope; botModule?: "companions" | "playerbots"; title: string; question: string }) {
|
||||
export function SettingsPage(props: {
|
||||
serverId: string;
|
||||
scope: Scope;
|
||||
botModule?: "companions" | "playerbots";
|
||||
title: string;
|
||||
question: string;
|
||||
onRegisterGuard?: (guard: UnsavedChangesGuard | null) => void;
|
||||
}) {
|
||||
const { serverId, scope } = props;
|
||||
const { t, tn, locale } = useI18n();
|
||||
const squid = scope === "bots" && props.botModule === "playerbots";
|
||||
@@ -317,10 +325,10 @@ export function SettingsPage(props: { serverId: string; scope: Scope; botModule?
|
||||
}
|
||||
|
||||
/** The save bar saves all three kinds of edits: the curated settings, the collection switches and the other documented ones. */
|
||||
async function saveEverything() {
|
||||
if (dirtyKeys.length && !(await save(Object.fromEntries(dirtyKeys.map((k) => [k, draft[k]]))))) return;
|
||||
async function saveEverything(): Promise<boolean> {
|
||||
if (dirtyKeys.length && !(await save(Object.fromEntries(dirtyKeys.map((k) => [k, draft[k]]))))) return false;
|
||||
const extra = [...Object.keys(rawEdits), ...Object.keys(colEdits)];
|
||||
if (!extra.length) return;
|
||||
if (!extra.length) return true;
|
||||
setBusy(true);
|
||||
setSaveErr(null);
|
||||
try {
|
||||
@@ -337,13 +345,33 @@ export function SettingsPage(props: { serverId: string; scope: Scope; botModule?
|
||||
const more = extra.map((key) => ({ key, title: key, restart: "world" as const, dangerous: false }));
|
||||
setSaved((prev) => ({ changed: [...(prev?.changed ?? []), ...more], restart: prev?.restart ?? "world", snapshot: prev?.snapshot ?? null }));
|
||||
void api.status(serverId).then((st) => setRunning(st.observed.world.state === "running"));
|
||||
return true;
|
||||
} catch (e) {
|
||||
setSaveErr(asUiError(e));
|
||||
return false;
|
||||
} finally {
|
||||
setBusy(false);
|
||||
}
|
||||
}
|
||||
|
||||
useEffect(() => {
|
||||
if (pending > 0) {
|
||||
props.onRegisterGuard?.({
|
||||
isDirty: () => pending > 0,
|
||||
save: () => saveEverything(),
|
||||
discard: () => {
|
||||
setDraft({});
|
||||
setErrors({});
|
||||
setRawEdits({});
|
||||
setColEdits({});
|
||||
},
|
||||
});
|
||||
} else {
|
||||
props.onRegisterGuard?.(null);
|
||||
}
|
||||
return () => props.onRegisterGuard?.(null);
|
||||
}, [pending, props.onRegisterGuard]);
|
||||
|
||||
async function openPreset(id: string) {
|
||||
setSaved(null);
|
||||
if (squid) {
|
||||
|
||||
+72
-8
@@ -1,5 +1,5 @@
|
||||
import { useCallback, useEffect, useState } from "react";
|
||||
import { Archive, BarChart3, Bot, Bug, Gauge, Globe, Puzzle, Server, Settings, Terminal, Users, type LucideIcon } from "lucide-react";
|
||||
import { useCallback, useEffect, useRef, useState } from "react";
|
||||
import { Archive, BarChart3, Bot, Bug, Gauge, Globe, Loader2, Puzzle, Server, Settings, Terminal, Users, type LucideIcon } from "lucide-react";
|
||||
import { api, type ServerSummary } from "@/lib/api";
|
||||
import { useT, type Key } from "@/i18n";
|
||||
import logo from "@/assets/logo.png";
|
||||
@@ -16,8 +16,10 @@ import { ModulesPage } from "@/screens/ModulesPage";
|
||||
import { ConsolePage } from "@/screens/ConsolePage";
|
||||
import { DashboardPage } from "@/screens/DashboardPage";
|
||||
import { Button } from "@/components/ui/button";
|
||||
import { Card } from "@/components/ui/card";
|
||||
import { startServerUpdatePolling, useServerUpdate } from "@/lib/serverUpdate";
|
||||
import { startClientPolling } from "@/lib/clientUpdate";
|
||||
import type { UnsavedChangesGuard } from "@/lib/unsavedGuard";
|
||||
|
||||
type Page = "overview" | "bots" | "dashboard" | "server" | "modules" | "players" | "friends" | "backups" | "console" | "report" | "settings";
|
||||
|
||||
@@ -51,6 +53,22 @@ export function Shell(props: {
|
||||
// A module that is switched off takes its page away (the companions' "Bots" page, for one).
|
||||
const [botModule, setBotModule] = useState<"companions" | "playerbots">("companions");
|
||||
const [hiddenPages, setHiddenPages] = useState<string[]>([]);
|
||||
const guardRef = useRef<UnsavedChangesGuard | null>(null);
|
||||
const registerGuard = useCallback((g: UnsavedChangesGuard | null) => {
|
||||
guardRef.current = g;
|
||||
}, []);
|
||||
const [pendingNav, setPendingNav] = useState<(() => void) | null>(null);
|
||||
const [modalSaving, setModalSaving] = useState(false);
|
||||
const [modalError, setModalError] = useState<string | null>(null);
|
||||
|
||||
const requestNavigation = (action: () => void) => {
|
||||
if (guardRef.current && guardRef.current.isDirty()) {
|
||||
setPendingNav(() => action);
|
||||
} else {
|
||||
action();
|
||||
}
|
||||
};
|
||||
|
||||
const reloadModules = useCallback(() => {
|
||||
void api
|
||||
.modulesList(props.activeId)
|
||||
@@ -89,7 +107,7 @@ export function Shell(props: {
|
||||
{NAV.filter((n) => !hiddenPages.includes(n.id) && (n.id !== "dashboard" || botModule === "playerbots")).map(({ id, label, icon: Icon }) => (
|
||||
<li key={id}>
|
||||
<button
|
||||
onClick={() => setPage(id)}
|
||||
onClick={() => requestNavigation(() => setPage(id))}
|
||||
aria-current={page === id ? "page" : undefined}
|
||||
className={cn(
|
||||
"flex h-10 w-full cursor-pointer items-center gap-3 rounded-md px-3 text-left text-[15px] transition-colors",
|
||||
@@ -111,7 +129,7 @@ export function Shell(props: {
|
||||
<select
|
||||
className="mb-2 w-full rounded-md border border-line bg-card px-2 py-2 text-sm"
|
||||
value={props.activeId}
|
||||
onChange={(e) => props.onSelect(e.target.value)}
|
||||
onChange={(e) => requestNavigation(() => props.onSelect(e.target.value))}
|
||||
aria-label={t("nav.serverPicker")}
|
||||
>
|
||||
{props.servers.map((s) => (
|
||||
@@ -121,7 +139,7 @@ export function Shell(props: {
|
||||
))}
|
||||
</select>
|
||||
)}
|
||||
<Button variant="ghost" size="sm" className="w-full justify-start" onClick={props.onAddAnother}>
|
||||
<Button variant="ghost" size="sm" className="w-full justify-start" onClick={() => requestNavigation(props.onAddAnother)}>
|
||||
{t("nav.addAnother")}
|
||||
</Button>
|
||||
</div>
|
||||
@@ -129,15 +147,15 @@ export function Shell(props: {
|
||||
|
||||
<main className="relative h-full flex-1 overflow-y-auto px-10 py-8">
|
||||
{page === "overview" ? (
|
||||
<Overview key={server.id} server={server} companions={botModule === "companions" && !hiddenPages.includes("bots")} onForget={() => props.onForget(server.id)} onOpenUpdates={() => setPage("settings")} onRealmChanged={reloadModules} onReport={() => setPage("report")} />
|
||||
<Overview key={server.id} server={server} companions={botModule === "companions" && !hiddenPages.includes("bots")} onForget={() => props.onForget(server.id)} onOpenUpdates={() => requestNavigation(() => setPage("settings"))} onRealmChanged={reloadModules} onReport={() => requestNavigation(() => setPage("report"))} />
|
||||
) : page === "bots" || page === "server" ? (
|
||||
<SettingsPage key={`${server.id}-${page}-${botModule}`} serverId={server.id} scope={page} botModule={botModule} title={t(current.label)} question={t(current.question)} />
|
||||
<SettingsPage key={`${server.id}-${page}-${botModule}`} serverId={server.id} scope={page} botModule={botModule} title={t(current.label)} question={t(current.question)} onRegisterGuard={registerGuard} />
|
||||
) : page === "dashboard" ? (
|
||||
<DashboardPage key={server.id} serverId={server.id} />
|
||||
) : page === "console" ? (
|
||||
<ConsolePage key={server.id} serverId={server.id} />
|
||||
) : page === "modules" ? (
|
||||
<ModulesPage key={server.id} serverId={server.id} onChanged={reloadModules} />
|
||||
<ModulesPage key={server.id} serverId={server.id} onChanged={reloadModules} onRegisterGuard={registerGuard} />
|
||||
) : page === "report" ? (
|
||||
<ReportPage key={server.id} serverId={server.id} />
|
||||
) : page === "friends" ? (
|
||||
@@ -152,6 +170,52 @@ export function Shell(props: {
|
||||
<Placeholder title={t(current.label)} question={t(current.question)} />
|
||||
)}
|
||||
</main>
|
||||
|
||||
{pendingNav && (
|
||||
<div className="fixed inset-0 z-50 flex items-center justify-center bg-black/60 p-6" role="presentation">
|
||||
<Card className="w-full max-w-md p-6 shadow-2xl" role="dialog" aria-modal="true" aria-label={t("unsaved.title")}>
|
||||
<h2 className="text-lg font-semibold">{t("unsaved.title")}</h2>
|
||||
<p className="mt-2 text-sm text-muted">{t("unsaved.message")}</p>
|
||||
{modalError && <p className="mt-3 text-sm text-bad" role="alert">{modalError}</p>}
|
||||
<div className="mt-6 flex flex-wrap justify-end gap-2">
|
||||
<Button variant="ghost" disabled={modalSaving} onClick={() => { setPendingNav(null); setModalError(null); }}>
|
||||
{t("common.cancel")}
|
||||
</Button>
|
||||
<Button variant="ghost" disabled={modalSaving} onClick={() => {
|
||||
guardRef.current?.discard();
|
||||
const act = pendingNav;
|
||||
setPendingNav(null);
|
||||
setModalError(null);
|
||||
act?.();
|
||||
}}>
|
||||
{t("set.discard")}
|
||||
</Button>
|
||||
<Button variant="primary" disabled={modalSaving} onClick={async () => {
|
||||
if (!guardRef.current) return;
|
||||
setModalSaving(true);
|
||||
setModalError(null);
|
||||
try {
|
||||
const ok = await guardRef.current.save();
|
||||
if (ok) {
|
||||
const act = pendingNav;
|
||||
setPendingNav(null);
|
||||
act?.();
|
||||
} else {
|
||||
setModalError(t("unsaved.saveFailed"));
|
||||
}
|
||||
} catch (e) {
|
||||
setModalError(String(e));
|
||||
} finally {
|
||||
setModalSaving(false);
|
||||
}
|
||||
}}>
|
||||
{modalSaving && <Loader2 className="mr-1.5 h-3.5 w-3.5 animate-spin" aria-hidden />}
|
||||
{t("acc.save")}
|
||||
</Button>
|
||||
</div>
|
||||
</Card>
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
);
|
||||
}
|
||||
Reference in new issue
Block a user