mirror of
https://github.com/Corfirean/coa-server-manager.git
synced 2026-11-18 19:25:56 +00:00
Compare commits
127
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
1a71f18def | ||
|
|
7d7bc530ec | ||
|
|
d86a1676fe | ||
|
|
53a05820c8 | ||
|
|
58c976a388 | ||
|
|
35c4d03bdc | ||
|
|
c45f962d02 | ||
|
|
f52bd8ba5f | ||
|
|
247159e56c | ||
|
|
cdd5be2365 | ||
|
|
7e170744bf | ||
|
|
10daa9b74d | ||
|
|
ed7bf7262b | ||
|
|
7c866b116d | ||
|
|
cfea54e203 | ||
|
|
57aa97da8a | ||
|
|
b9f89a4ae4 | ||
|
|
6fd2130fc4 | ||
|
|
346d97ee89 | ||
|
|
10a6744192 | ||
|
|
7557b347c5 | ||
|
|
2abd64dfe2 | ||
|
|
9ae5fb471b | ||
|
|
59036867d7 | ||
|
|
949614f11a | ||
|
|
9ee0e9f6af | ||
|
|
3405c89fe8 | ||
|
|
4c4d39f1de | ||
|
|
b101c79e96 | ||
|
|
3b7f77d92e | ||
|
|
0589722e71 | ||
|
|
a3717c08bb | ||
|
|
dc2bffc57e | ||
|
|
e34ab45443 | ||
|
|
40f9feab84 | ||
|
|
5b16842720 | ||
|
|
02843bb6d1 | ||
|
|
a9ab7ced7e | ||
|
|
77318895ae | ||
|
|
115c57f54e | ||
|
|
94fd5fb5b9 | ||
|
|
94d4ade1c7 | ||
|
|
376f1dbb46 | ||
|
|
b0951dbee7 | ||
|
|
374a3f9c23 | ||
|
|
d20d5a6410 | ||
|
|
1228807eaf | ||
|
|
ee59708fbf | ||
|
|
3ed9c5dacd | ||
|
|
9099168927 | ||
|
|
a27e0eb6ab | ||
|
|
c46edd2feb | ||
|
|
f934bef303 | ||
|
|
c882a21334 | ||
|
|
a625b065cf | ||
|
|
5c3a9def0c | ||
|
|
25098b5a63 | ||
|
|
45a699d2ca | ||
|
|
be68eb4341 | ||
|
|
06ca748e80 | ||
|
|
58c1e1aee0 | ||
|
|
ad69fb0401 | ||
|
|
7540527d30 | ||
|
|
5328709826 | ||
|
|
478ea8a960 | ||
|
|
c8a0f6872f | ||
|
|
c3791f80f1 | ||
|
|
1acbcc2bb5 | ||
|
|
838cc07e73 | ||
|
|
4c4f8bbb3e | ||
|
|
d85d86a3dc | ||
|
|
0a050a40a2 | ||
|
|
017b977bfa | ||
|
|
337418afe0 | ||
|
|
f920ff8a59 | ||
|
|
072a657649 | ||
|
|
c6e8a34509 | ||
|
|
3f98ba3add | ||
|
|
7a3fefaafd | ||
|
|
fac6ce469a | ||
|
|
f22cedd963 | ||
|
|
0b5f12941c | ||
|
|
f3fc14b55a | ||
|
|
beaec7d27e | ||
|
|
8490dc9983 | ||
|
|
3f8abcbbe8 | ||
|
|
b3c50a7b39 | ||
|
|
bbdad37e40 | ||
|
|
0ed4d5e268 | ||
|
|
b13ee55bb9 | ||
|
|
51a45db8cb | ||
|
|
3f700ee8f4 | ||
|
|
277ebba847 | ||
|
|
9a0b815937 | ||
|
|
78b84e11c2 | ||
|
|
6aea9011f9 | ||
|
|
171d9a2bf8 | ||
|
|
0d6d8a0db8 | ||
|
|
3940506987 | ||
|
|
654b7cddd3 | ||
|
|
f8301d7394 | ||
|
|
cd3a963f70 | ||
|
|
6c771fae20 | ||
|
|
cfe0889a4f | ||
|
|
f25a1d425d | ||
|
|
b5e4a38d7d | ||
|
|
07ec22798f | ||
|
|
5d865fcaea | ||
|
|
a67d51804b | ||
|
|
7c096a4844 | ||
|
|
b90b377fc3 | ||
|
|
a02130f587 | ||
|
|
f4e36f21eb | ||
|
|
65c9945626 | ||
|
|
f13398bbd7 | ||
|
|
f05f94ba01 | ||
|
|
c39a7a0ac7 | ||
|
|
e8367354ef | ||
|
|
461fa035d0 | ||
|
|
3edc600f97 | ||
|
|
c3d87e1ff2 | ||
|
|
d2496603e7 | ||
|
|
2eea0e117c | ||
|
|
2e3fb24e1a | ||
|
|
146b1c50b9 | ||
|
|
c02c635463 | ||
|
|
58b5ddeb07 |
No files matched your search
@@ -21,7 +21,7 @@ jobs:
|
||||
node-version: 22
|
||||
- run: npm ci
|
||||
- name: Tests
|
||||
run: cargo test --workspace
|
||||
run: cargo test --workspace -- --test-threads=1
|
||||
- name: Build, sign and publish
|
||||
uses: tauri-apps/tauri-action@v0
|
||||
env:
|
||||
|
||||
@@ -4,3 +4,5 @@ dist
|
||||
*.log
|
||||
.env
|
||||
src-tauri/gen
|
||||
# Disposable database fixtures and private recovery data
|
||||
.cache/
|
||||
@@ -1,5 +1,13 @@
|
||||
# CoA Server Manager changelog
|
||||
|
||||
## 0.6.1 — 2026-10-04
|
||||
|
||||
- PLAY launches only the client with the selected realmlist; starting the local server remains a separate action.
|
||||
- Server multipliers accept decimals typed with a dot or comma. Talent and rested experience descriptions now explain their actual behavior.
|
||||
- Added database and file checks, and Repair with backups and signed package verification. Unresolved schema damage is reported instead of guessed repairs.
|
||||
- Fixed character database rebuilds retaining migration history that could skip required SQL. Applied migration hash changes are now rejected.
|
||||
- Added optional simultaneous CoA and Wildcard worlds on Windows, with separate processes, ports and status indicators.
|
||||
|
||||
## 0.6.0 — 2026-10-03
|
||||
|
||||
- Added Simplified Chinese for the interface and all server and bot settings.
|
||||
|
||||
Generated
+14
-3
@@ -491,7 +491,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "coa-core"
|
||||
version = "0.6.0"
|
||||
version = "0.6.15"
|
||||
dependencies = [
|
||||
"base64 0.22.1",
|
||||
"chrono",
|
||||
@@ -499,6 +499,7 @@ dependencies = [
|
||||
"ed25519-dalek",
|
||||
"fs4",
|
||||
"hex",
|
||||
"if-addrs",
|
||||
"num-bigint",
|
||||
"rand_core",
|
||||
"reqwest 0.12.28",
|
||||
@@ -519,7 +520,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "coa-release"
|
||||
version = "0.6.0"
|
||||
version = "0.6.15"
|
||||
dependencies = [
|
||||
"chrono",
|
||||
"coa-core",
|
||||
@@ -528,7 +529,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "coa-server-manager"
|
||||
version = "0.6.0"
|
||||
version = "0.6.15"
|
||||
dependencies = [
|
||||
"coa-core",
|
||||
"serde",
|
||||
@@ -1913,6 +1914,16 @@ dependencies = [
|
||||
"icu_properties",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "if-addrs"
|
||||
version = "0.15.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c0a05c691e1fae256cf7013d99dad472dc52d5543322761f83ec8d47eab40d2b"
|
||||
dependencies = [
|
||||
"libc",
|
||||
"windows-sys 0.61.2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "indexmap"
|
||||
version = "1.9.3"
|
||||
|
||||
+1
-1
@@ -3,7 +3,7 @@ resolver = "2"
|
||||
members = ["crates/coa-core", "crates/coa-release", "src-tauri"]
|
||||
|
||||
[workspace.package]
|
||||
version = "0.6.0"
|
||||
version = "0.6.15"
|
||||
edition = "2021"
|
||||
license = "AGPL-3.0-only"
|
||||
|
||||
|
||||
@@ -0,0 +1,104 @@
|
||||
# Urgent update hotfix
|
||||
|
||||
Deadline: 2026-10-06. This checkout starts at the exact v0.6.4 tag, commit
|
||||
6c771fa, and excludes the ongoing isolated-trial/recovery redesign.
|
||||
|
||||
The client accepts checksum compatibility only from a verified signed manifest and only
|
||||
for an Applied migration. It never updates the historical checksum, reruns historical
|
||||
SQL, or excuses a Running/Failed ledger row. A server package must explicitly list the
|
||||
verified published variants and append corrections under new migration IDs.
|
||||
|
||||
Current local evidence: the locked workspace tests passed, including 252 core tests
|
||||
run serially. Six frontend logic tests and the frontend production build passed.
|
||||
The hotfix runtime was tested against the exact signed candidate manifest on the marked
|
||||
CoA/Wildcard fixture. Both published repair checksums were accepted independently in
|
||||
both worlds, with zero migration executions, unchanged historical checksums, and unchanged
|
||||
account, character and inventory counts. The original ledger rows were restored after
|
||||
the test, and all fixture processes were stopped. A real Running or Failed repair row in
|
||||
either world was rejected before staging or creating a transaction, with unchanged world
|
||||
executable and installation metadata. Tests use independent hotfix metadata so experimental
|
||||
transaction formats are not confused with the 0.6.4 upgrade path. Windows journal writes also use flushed
|
||||
atomic replacement with long-path support. Changelog validation passed.
|
||||
|
||||
Additional guards implemented:
|
||||
|
||||
- Read migration history without creating its ledger before downloading or replacing files.
|
||||
- Reject missing journals, invalid identities, paths, hashes and inconsistent operations.
|
||||
Durable completed-cleanup markers distinguish interrupted pruning from a lost journal.
|
||||
- Preserve all backups while an update is unfinished or its journal is damaged.
|
||||
- Verify saved-file hashes and the complete database/configuration recovery point before
|
||||
stopping services or changing files/databases. New snapshots include configuration hashes;
|
||||
update journals bind their backup metadata to a hash.
|
||||
- Surface state-reading errors in Settings and disable applying until the disk state is
|
||||
successfully read. Checking again refreshes that state.
|
||||
- Verify every extracted SQL artifact before taking the update snapshot or replacing
|
||||
server files; missing files, invalid IDs, duplicate migrations and checksum disagreements
|
||||
reject the update early. SQL application repeats the integrity check immediately before use.
|
||||
- Count unapplied migrations in the active and secondary realms, counting shared auth once.
|
||||
Matching versions and files do not hide remaining database work. Preview reads history
|
||||
under the installation lock; a stopped database is temporarily started for inspection
|
||||
and stopped again when no game services are running.
|
||||
- Reread the disk state after every update/recovery attempt, including failed attempts and
|
||||
background updates. Unfinished or unreadable state blocks another application in the UI.
|
||||
- Acquire the installation lock before checking and deleting a backup.
|
||||
|
||||
Latest real-runtime test used the independently copied, doubly marked fixture
|
||||
`C:\games\coa-schema-fixture-chaos-20261005-v1` and signed candidate `0.261005.24`, manifest SHA-256
|
||||
`1284b1273815209c9621b6d173a2211bae316f33462ccbe8b578e53b8d26fb5b`.
|
||||
All 1748 SQL artifacts passed verification after authenticated archive extraction.
|
||||
Removing one repair record separately in CoA and Wildcard increased the pending count
|
||||
by exactly one; restoring its original record restored the original count. No migrations
|
||||
were executed, player counts were preserved and fixture services were stopped afterward.
|
||||
The source checkout remains uncommitted; these results are not an installer acceptance report.
|
||||
|
||||
Additional acceptance on 2026-10-06: a new independent installation/database copy at
|
||||
`C:\games\coa-schema-fixture-chaos-064-transition-20261006` received the authenticated
|
||||
published `0.261005.22` program files, original CRLF repair checksum, and a deliberately
|
||||
missing Wildcard table in both realms. The production hotfix update pipeline committed
|
||||
signed candidate `0.261005.24`, repaired both realms, passed schema checks and actual
|
||||
bundled-Python server startup, and preserved the selected account, character, item and
|
||||
inventory fields byte-for-byte. The fixture was stopped afterward. The harness explicitly
|
||||
instruments the launcher to prevent relay submissions and bind to localhost; this is not
|
||||
proof of packaged UI behavior or operating-system network containment.
|
||||
|
||||
Local installer `C:\games\source\manager-065-local-installer-20261006\CoA Server Manager_0.6.5_x64-setup.exe`
|
||||
has SHA-256 `520ee0391d923b92da0a20591e30006c048cdb60156275d7a829918bf1b77491`.
|
||||
Its updater signature and the published 0.6.4 installer's signature passed independent
|
||||
verification with the configured updater public key. Both executables extracted from
|
||||
their exact NSIS packages started, created responsive windows, and were stopped using
|
||||
an independent application/WebView profile. No installer was executed over a user's
|
||||
installation, and no UI update operation was exercised.
|
||||
|
||||
Legacy limitation: old 0.6.4 transaction copies and configuration snapshots without recorded
|
||||
hashes can be checked for presence and declared database hashes, but their original file
|
||||
contents cannot be authenticated retroactively. Missing copies block restoration. This
|
||||
hotfix does not claim that old unchecksummed copies received full integrity verification.
|
||||
|
||||
Remaining release requirements: reproduce the existing-user failures through the published
|
||||
0.6.4 interface, verify legacy unfinished transaction handling on real-runtime fixtures,
|
||||
and execute the exact installer over 0.6.4 in an isolated Windows environment with UI
|
||||
state/settings/server-list verification. Windows native UI automation is unavailable in
|
||||
this session. Packaged startup and signature checks do not satisfy that installer gate.
|
||||
No public release has been made.
|
||||
|
||||
The user subsequently exercised the packaged UI: candidate 0.261005.24 committed and
|
||||
both CoA and Wildcard were shown running. Repeat-check/restart acceptance is still pending.
|
||||
The screenshots exposed an older published package being offered after the local candidate
|
||||
was installed. Follow-up changes reject older packages before preview/database inspection
|
||||
and application and clear a cached offer after a failed recheck. All 253 core tests and
|
||||
seven frontend tests passed. The earlier installer hash above does not include this follow-up;
|
||||
a separately recorded revision is required. Native UI control was subsequently initialized
|
||||
through the deferred node_repl tool, then the user stopped automation with Escape and
|
||||
performed the UI check manually.
|
||||
|
||||
Another user repeat-check exposed the already installed launcher being offered again.
|
||||
The preview now verifies canonical launcher bytes against the current signed package,
|
||||
caches those bytes by SHA-256, and compares only recognized Manager transformations.
|
||||
The actual disposable fixture's repeat preview passed with all 104 files skipped and
|
||||
zero pending SQL. User edits, recorded custom content, and a package with different
|
||||
launcher bytes are not mistaken for that integration. All 254 core tests passed;
|
||||
the strengthened regression test and seven frontend tests also passed. The first
|
||||
preview of a managed launcher may download/extract its authenticated package to build
|
||||
the optional canonical cache. Earlier installer revisions do not include this fix.
|
||||
|
||||
Do not recommend deleting an installation or replacing its player databases.
|
||||
@@ -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: Choose which item types the auction bot sells
|
||||
---
|
||||
Switch 15 item categories on or off and adjust listing frequency by quality. Labels and descriptions are translated into all six languages. Changes affect new listings; existing auctions remain.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: fixed
|
||||
audience: admins
|
||||
title: Server multipliers now accept decimals typed with a dot or comma
|
||||
---
|
||||
Talent settings now explain that the multiplier does not affect CoA talents. The rested experience setting now correctly describes bonus accumulation.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: fixed
|
||||
audience: admins
|
||||
title: Play launches only the game client without starting your local server
|
||||
---
|
||||
Use the left button to start the server and PLAY to launch the client with your selected realmlist, including connections to other servers.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: changed
|
||||
audience: admins
|
||||
title: Module settings now offer translated controls and an enemy damage slider
|
||||
---
|
||||
Configure scaling, auctions and enchantments with translated controls. Module switches no longer appear twice. Modules without settings hide their settings button; short lists need no search. New server builds support dungeon and raid damage from 25% to 200%.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: fixed
|
||||
audience: admins
|
||||
title: Failed server updates restore databases and files together
|
||||
---
|
||||
Updates save a full backup and recover databases and files together. Interrupted SQL is not replayed. Checks cover Wildcard tables and every supported race/class pair, including existing characters. Unfinished updates block startup until recovered.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: added
|
||||
audience: admins
|
||||
title: Check database structure and repair server files with a safety backup
|
||||
---
|
||||
Settings can check both realm databases and restore official files plus pending SQL. Installation and updates check character-save columns. Clean packages no longer keep old character migration records when rebuilding their database.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: added
|
||||
audience: admins
|
||||
title: Configure partial dungeon parties and open-world life steal in module settings
|
||||
---
|
||||
Choose whether Dungeon Finder enters with the current party and enable open-world life steal with a healing percentage from 0 to 100. Available on server builds that support these options.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: added
|
||||
audience: admins
|
||||
title: Start CoA and Wildcard together from Settings
|
||||
---
|
||||
Both worlds can run on separate ports with their own characters, settings and logs, sharing accounts. Stop saves both worlds before shutting down the shared database.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: added
|
||||
audience: admins
|
||||
title: Configure SQUID Playerbots and prevent conflicting bot systems
|
||||
---
|
||||
The Bots tab shows translated settings for the active bot system. Bot module cards keep enable switches without duplicate settings. Enable one bot system at a time; the Manager checks manual config changes before starting the server. Recovery points also include the SQUID database when installed.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: added
|
||||
audience: players
|
||||
title: Download and update the game client without installing a server
|
||||
---
|
||||
Choose to host a server or connect to someone else's. Players joining a friend can download, update and launch the client, save the host's address and use the Manager without installing a local server.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: added
|
||||
audience: admins
|
||||
title: Imported SquidBots servers warn before replacing their original binary
|
||||
---
|
||||
Imports explain that the original launcher and updater check the server binary hash. Updating that binary requires an explicit choice to keep or replace it.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: added
|
||||
audience: players
|
||||
title: Start your installed server or client without downloading an available update
|
||||
---
|
||||
Choose to update later and keep playing with your installed version. Interrupted server updates still require recovery before startup.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: added
|
||||
audience: admins
|
||||
title: Install a server from a package on Linux, running in Docker (experimental)
|
||||
---
|
||||
Experimental. The Manager creates the database, imports the packaged baseline and starts the server in Docker containers. It needs a Linux server package and your own game data folder.
|
||||
@@ -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: Finish a server update that was blocked by a startup failure
|
||||
---
|
||||
The Manager repairs the launcher import path and lets you retry startup for an already applied update. Successful validation finishes the update without replaying SQL or restoring old databases. Failure details are preserved and rollback remains available.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: added
|
||||
audience: admins
|
||||
title: SquidBots settings follow the options shipped by the module
|
||||
---
|
||||
New settings use the module's descriptions, groups, defaults and value limits while retaining existing translations. Unknown formats or invalid fields use built-in controls so the settings page remains available.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: added
|
||||
audience: admins
|
||||
title: SquidBots shows its bundled release and includes it in problem reports
|
||||
---
|
||||
The Bots and Modules pages and problem reports include the release identifiers. Imported repacks use their recorded bot revision; empty tags are hidden. The settings file's source commit is not presented as the build revision.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: fixed
|
||||
audience: admins
|
||||
title: Server updates accept verified published migration variants without rerunning them
|
||||
---
|
||||
Signed updates can recognise known published checksums without changing your migration history. Interrupted or failed SQL still requires recovery before retrying.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: fixed
|
||||
audience: admins
|
||||
title: Server updates replace older launchers adapted by the Manager for Wildcard
|
||||
---
|
||||
Updates recognize the Manager’s own realm and import adjustments even when older metadata still records the original launcher. New server binaries receive their matching launcher; genuine custom edits still require your decision.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: fixed
|
||||
audience: admins
|
||||
title: Server packages must include a complete database schema check
|
||||
---
|
||||
Release tools generate the expected database structure on an isolated copy of the signed base, verify all archive files and refuse packages without the schema check. Corrective SQL can restore missing Wildcard tables without replaying old updates.
|
||||
@@ -0,0 +1,8 @@
|
||||
---
|
||||
area: manager
|
||||
type: changed
|
||||
audience: admins
|
||||
title: The Auction House Bot card no longer asks for a character GUID
|
||||
---
|
||||
Turning the module and the seller on is enough: a server build with the automatic auction character creates its own account and character. The GUID field moved to the advanced settings.
|
||||
The buyer option hint no longer says it spends the auction character's gold.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: fixed
|
||||
audience: admins
|
||||
title: Choose and remember the local network address friends use to connect
|
||||
---
|
||||
Select an adapter or custom IPv4 address when sharing on LAN. Your choice survives restarts and mode changes; unavailable addresses show a warning instead of silently switching adapters.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: added
|
||||
audience: admins
|
||||
title: The NPC Enchanter card explains how to place and remove the NPC
|
||||
---
|
||||
The card now shows the two commands: `.npc add 601015` where you stand, and `.npc delete` on the targeted NPC.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: fixed
|
||||
audience: admins
|
||||
title: Older server packages cannot replace a newer installation
|
||||
---
|
||||
Update checks stop offering stale packages after an update. To undo an update, use its recovery point instead of applying an older server package.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: fixed
|
||||
audience: admins
|
||||
title: Checking again no longer offers an already installed launcher update
|
||||
---
|
||||
The Manager recognizes its own launcher integration while still detecting user edits and changes in newer signed packages.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: fixed
|
||||
audience: admins
|
||||
title: Large SQUID database imports have more time to finish on first startup
|
||||
---
|
||||
The Manager allows up to 45 minutes when SQUID Playerbots is enabled, covering its initial database import and bot creation. Ordinary server startup and shutdown keep their existing deadlines.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: fixed
|
||||
audience: admins
|
||||
title: Update history conflicts are detected before server files change
|
||||
---
|
||||
Damaged update records block changes and remain visible. Recovery checks saved copies before restoring, and unfinished updates protect backups from deletion and cleanup.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: fixed
|
||||
audience: admins
|
||||
title: Pending database updates remain visible when the server version matches
|
||||
---
|
||||
SQL files are checked before replacing server files. Update and recovery attempts refresh their saved status, including errors. Backup deletion cannot race with an update.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: fixed
|
||||
audience: admins
|
||||
title: Diagnostic files with database checks stay readable after secrets are removed
|
||||
---
|
||||
Removing a line that mentioned a secret could break the JSON files in a diagnostic package. Secret values are now replaced instead, so the files stay valid.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: added
|
||||
audience: admins
|
||||
title: One button collects all diagnostics, including crashes and Windows crash records
|
||||
---
|
||||
Report a problem collects logs, crash reports and small dumps, Windows crash records, update journals and the running server programs in one file, then shows its folder. Crashes without a server crash report are no longer missing.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: added
|
||||
audience: admins
|
||||
title: Problem reports go to the right project
|
||||
---
|
||||
Choose what the problem is about: Manager and other modules, CoA Companions, or SQUID Playerbots. The report opens in that project's GitHub page with the versions filled in. The bot system that is switched on is preselected.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: added
|
||||
audience: admins
|
||||
title: Choose where backups are stored, for example on another drive
|
||||
---
|
||||
Backups can now live in any folder outside the server folder. Existing backups stay listed. A backups folder that you moved and linked from the old place also works again for updates.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: changed
|
||||
audience: admins
|
||||
title: Bot settings with a fixed list of values show a drop-down
|
||||
---
|
||||
SQUID bots 1.9 describes the chat language as a list of languages. The Manager shows it as a drop-down with names instead of a bare number.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: fixed
|
||||
audience: admins
|
||||
title: The bot dashboard loads completely and can be opened in the browser
|
||||
---
|
||||
The dashboard no longer fails on large pages, starts again after a crash left its history files empty, and its Open in the browser button works. With both realms started together the realm drop-down is hidden.
|
||||
@@ -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: fixed
|
||||
audience: admins
|
||||
title: Accounts of the SQUID bots are hidden from the Accounts list
|
||||
---
|
||||
The RNDBOT accounts that hold the random bots no longer fill the Accounts tab, and they cannot be renamed or deleted from there.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: added
|
||||
audience: admins
|
||||
title: A Dashboard tab shows what the SQUID bots are doing
|
||||
---
|
||||
With SQUID Playerbots on, the Dashboard tab downloads the dashboard release that matches your bots, starts it on this computer and shows it inside the Manager.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: added
|
||||
audience: admins
|
||||
title: A stopped server stays stopped after an update, unless you ask it to start
|
||||
---
|
||||
Updating no longer leaves a server running that was stopped before. Settings has a switch to start it afterwards, and the client card has one to open the game after a client update.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: fixed
|
||||
audience: admins
|
||||
title: Checking for updates no longer fails with "Something went wrong" after a crash
|
||||
---
|
||||
A crash or power loss could leave a damaged status file that made every database start fail. The Manager now removes such files itself, still compares the files when the database is unavailable, and shows the real reason.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: fixed
|
||||
audience: admins
|
||||
title: Server updates no longer stop with "has a different checksum" on the Wildcard repair
|
||||
---
|
||||
Servers that applied one of the two published versions of the Wildcard table repair can now update to the other. Nothing in the database changes.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: fixed
|
||||
audience: admins
|
||||
title: A world server started from the coa-bots folder is recognised
|
||||
---
|
||||
The Manager no longer reports a port conflict when the world server runs from the coa-bots folder inside the server folder, and a failed update now says that undoing it can take several minutes.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: changed
|
||||
audience: admins
|
||||
title: Failed server startup after an update automatically restores the previous version
|
||||
---
|
||||
The Manager restores server files and databases, then checks the recovered server. If recovery cannot be confirmed, it preserves the recovery point and blocks further startup until the problem is resolved.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: fixed
|
||||
audience: admins
|
||||
title: Windows update recovery preserves database procedures triggers and views
|
||||
---
|
||||
A verified copy of stopped MySQL restores all databases and accounts together. Interrupted restoration can be retried, and the replaced database directory is retained.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: fixed
|
||||
audience: admins
|
||||
title: Custom races bot setting synchronizes Playerbots excluded race lists
|
||||
---
|
||||
The "Bots can be custom races" setting now configures AiPlayerbot.ExcludedBotRaces in playerbots.conf. Off excludes all added races (recommended), while on allows stable added races (experimental).
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: changed
|
||||
audience: admins
|
||||
title: Custom race client patches update to the latest races and appearances
|
||||
---
|
||||
The module card offers an upgrade for older patches. Archive downloads are verified before installation.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: added
|
||||
audience: admins
|
||||
title: Custom races can be enabled and their client patches installed from Modules
|
||||
---
|
||||
Install the custom race client assets from the module card, then enable the module and restart the server.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: fixed
|
||||
audience: admins
|
||||
title: Blocked updates identify database objects that prevent automatic recovery
|
||||
---
|
||||
Diagnostics include the complete list of unsupported database objects across the recovery point, helping resolve update failures without removing user data.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: fixed
|
||||
audience: admins
|
||||
title: Background world servers no longer stop because the local console is closed
|
||||
---
|
||||
The Manager automatically disables the local interactive console before starting the world server. Its remote console remains available, and no manual configuration changes are needed.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: added
|
||||
audience: admins
|
||||
title: Updates can follow signed channels that select a complete server release
|
||||
---
|
||||
The Manager checks the channel signature and downloads every package part from the same release. Existing installations continue using the previous download source until the new channel is published.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: fixed
|
||||
audience: admins
|
||||
title: Server updates check startup privately before allowing players to connect
|
||||
---
|
||||
Startup checks use temporary local ports. Original settings are restored before opening the server, and interrupted checks retain a recovery journal.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: fixed
|
||||
audience: admins
|
||||
title: Updates repair missing database defaults from the verified release schema
|
||||
---
|
||||
Only missing literal defaults are restored when column properties match. Existing rows, custom defaults, types and nullability are preserved; unresolved incompatibilities still block the update.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: fixed
|
||||
audience: admins
|
||||
title: Server updates no longer replay module installation scripts on existing databases
|
||||
---
|
||||
Update packages contain incremental SQL only. Module table initialization and seed scripts remain available when preparing a clean installation, preventing existing content from being reset during updates.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: added
|
||||
audience: admins
|
||||
title: Windows server updates are tested on a private copy before changing your installation
|
||||
---
|
||||
The Manager tests migrations and server startup using your databases and configurations. A failed rehearsal leaves the installed server unchanged and preserves a diagnostic report.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: added
|
||||
audience: admins
|
||||
title: Server updates can require a tested combination of platform and installed version
|
||||
---
|
||||
Signed release metadata identifies core and module revisions, supported starting versions and database contracts. Incompatible packages are rejected before shutdown; changed schema contracts and incompatible databases block installation before migration.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: fixed
|
||||
audience: admins
|
||||
title: Failed database checks keep a complete report after rollback
|
||||
---
|
||||
Schema errors show readable default values and save every detected difference for troubleshooting, including after the server is restored.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: fixed
|
||||
audience: admins
|
||||
title: Server and Bots settings open without a blank window
|
||||
---
|
||||
Opening settings no longer crashes the interface after loading. Unsaved changes can still be saved or discarded before leaving the page.
|
||||
@@ -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.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: added
|
||||
audience: players
|
||||
title: Players can install custom race patches when connecting to a friend
|
||||
---
|
||||
Install the custom race client patch directly from the Game client section without hosting a server.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: fixed
|
||||
audience: admins
|
||||
title: Large server updates no longer repeatedly rewrite the recovery journal
|
||||
---
|
||||
Updates containing rebuilt navigation data now prepare all recovery copies before replacing files. Interrupted updates remain recoverable without rewriting the full journal for every file.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: fixed
|
||||
audience: admins
|
||||
title: Normalize rehearsal server roots to prevent Windows path prefix errors
|
||||
---
|
||||
Server update rehearsals now canonicalize the installation root before collecting files, resolving a "prefix not found" error during rehearsal preparation on Windows.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: fixed
|
||||
audience: admins
|
||||
title: Client race patches can be repaired and removed while preserving original files
|
||||
---
|
||||
Every overwritten client file gets an original backup. Switching preserves newer launcher files; checksums detect missing or replaced assets. Repair and removal are always available, with rollback if a file operation fails.
|
||||
@@ -24,14 +24,15 @@ num-bigint = "0.4"
|
||||
zip = { version = "2", default-features = false, features = ["deflate"] }
|
||||
sha1 = "0.10"
|
||||
tracing-subscriber = { version = "0.3", default-features = false, features = ["fmt", "std"] }
|
||||
tempfile = "3"
|
||||
if-addrs = "0.15"
|
||||
|
||||
[dev-dependencies]
|
||||
tempfile = "3"
|
||||
rand_core = { version = "0.6", features = ["getrandom"] }
|
||||
ed25519-dalek = { version = "2", features = ["rand_core"] }
|
||||
|
||||
[target.'cfg(windows)'.dependencies]
|
||||
windows-sys = { version = "0.60", features = ["Win32_Foundation", "Win32_System_Threading", "Win32_System_SystemInformation", "Win32_System_Diagnostics_ToolHelp", "Win32_NetworkManagement_IpHelper", "Win32_Networking_WinSock"] }
|
||||
windows-sys = { version = "0.60", features = ["Win32_Foundation", "Win32_Storage_FileSystem", "Win32_System_Threading", "Win32_System_SystemInformation", "Win32_System_Diagnostics_ToolHelp", "Win32_NetworkManagement_IpHelper", "Win32_Networking_WinSock"] }
|
||||
|
||||
[features]
|
||||
testkit = []
|
||||
@@ -0,0 +1,38 @@
|
||||
use std::{fs, path::PathBuf};
|
||||
use coa_core::{manifest::{Kind, Manifest}, package::{self, BuildOptions}, pkgsource::{self, Source}, release, signing, Result};
|
||||
|
||||
fn main() -> Result<()> {
|
||||
let args: Vec<String> = std::env::args().skip(1).collect();
|
||||
let source = Source::Dir(args[1].clone().into());
|
||||
let (previous, _) = pkgsource::fetch_manifest(&source, signing::EMBEDDED_PUBLIC_KEY)?;
|
||||
let tree = PathBuf::from(&args[2]);
|
||||
if args[0] == "extract" {
|
||||
assert!(!tree.exists(), "Use a new release tree");
|
||||
package::extract(&PathBuf::from(&args[1]), &previous, &tree, &|_, _| {})?;
|
||||
println!("Verified and extracted {}: {} historical migrations", previous.version, previous.migrations.len());
|
||||
return Ok(());
|
||||
}
|
||||
assert_eq!(args[0], "pack");
|
||||
let out = PathBuf::from(&args[3]);
|
||||
assert!(!out.exists(), "Release addresses must be immutable");
|
||||
for migration in &previous.migrations {
|
||||
let entry = previous.files.iter().find(|file| file.path.starts_with("_migrations/") && file.sha256 == migration.sha256).expect("Historical SQL entry");
|
||||
assert_eq!(coa_core::fsx::sha256_file(&tree.join(&entry.path))?, entry.sha256, "Historical SQL changed: {}", migration.id);
|
||||
}
|
||||
let mut manifest = package::build(&tree, &out, &BuildOptions {
|
||||
kind: Kind::Update, version: args[4].clone(), core_commit: Some(args[5].clone()),
|
||||
bots_commit: previous.bots.and_then(|revision| revision.commit),
|
||||
built_at: chrono::Utc::now().to_rfc3339(), part_size: package::DEFAULT_PART_SIZE,
|
||||
migrations: previous.migrations.clone(),
|
||||
}, &|line| println!("{line}"))?;
|
||||
manifest.min_manager_version = "0.6.5".into();
|
||||
manifest.validate()?;
|
||||
coa_core::fsx::atomic_write(&out.join("manifest.json"), &serde_json::to_vec_pretty(&manifest)?)?;
|
||||
let key_path = PathBuf::from(std::env::var("USERPROFILE").unwrap()).join(".coa-manager/signing/manifest-signing.key");
|
||||
release::sign_manifest(&out, &fs::read_to_string(key_path)?)?;
|
||||
coa_core::release_schema::verify_package(&out, signing::EMBEDDED_PUBLIC_KEY)?;
|
||||
let reread: Manifest = serde_json::from_slice(&fs::read(out.join("manifest.json"))?)?;
|
||||
assert_eq!(serde_json::to_value(reread.migrations)?, serde_json::to_value(previous.migrations)?);
|
||||
println!("PASS: signed {}; all historical migration bytes, checksums, aliases and order preserved", manifest.version);
|
||||
Ok(())
|
||||
}
|
||||
@@ -0,0 +1,70 @@
|
||||
use std::path::{Path, PathBuf};
|
||||
use coa_core::{backup, driver, fsx, Result};
|
||||
|
||||
fn set(root: &Path, filename: &str, values: &[(&str, &str)]) -> Result<()> {
|
||||
let path = root.join("Core/configs/modules").join(filename);
|
||||
let mut config = coa_core::config::parser::ConfFile::parse_bytes(&std::fs::read(&path)?)?;
|
||||
for (key, value) in values { config.set(key, value, &[]); }
|
||||
fsx::atomic_write(&path, config.to_text().as_bytes())
|
||||
}
|
||||
|
||||
fn ledgers(root: &Path) -> Result<Vec<String>> {
|
||||
backup::with_database(root, |db| ["acore_playerbots", "acore_world", "acore_characters"].into_iter()
|
||||
.map(|schema| db.query(&format!("SELECT path,sha256 FROM `{schema}`.coa_squid_migrations ORDER BY path;"))).collect())
|
||||
}
|
||||
|
||||
fn exercise(root: &Path) -> Result<()> {
|
||||
let meta = coa_core::registry::metadata_dir_for(root)?;
|
||||
let point = backup::create(root, &meta, backup::Kind::Full, backup::Trigger::Manual, Some("Disposable SQUID acceptance".into()), &|stage| println!("{stage}"))?;
|
||||
assert!(backup::verify(&meta, &point.id)?.ok);
|
||||
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| -> Result<()> {
|
||||
backup::with_database(root, |db| db.query("DROP DATABASE IF EXISTS acore_playerbots;").map(|_| ()))?;
|
||||
assert!(driver::run(root, driver::Verb::StartAll)?.ok, "Disabled SQUID must start without its database");
|
||||
assert!(driver::run(root, driver::Verb::StopAll)?.ok);
|
||||
coa_core::multiworld::set_enabled(root, false)?;
|
||||
coa_core::realms::select(root, coa_core::realms::Mode::Coa)?;
|
||||
set(root, "mod_coa_playerbots.conf", &[("CoaBots.Enable", "0")])?;
|
||||
set(root, "playerbots.conf", &[("AiPlayerbot.Enabled", "1"), ("AiPlayerbot.RandomBotAutologin", "0"), ("AiPlayerbot.MinRandomBots", "0"), ("AiPlayerbot.MaxRandomBots", "0"), ("AiPlayerbot.RandomBotGuildCount", "0"), ("AiPlayerbot.RandomBotAccountCount", "0")])?;
|
||||
let started = driver::run(root, driver::Verb::StartAll)?;
|
||||
assert!(started.ok, "Fresh SQUID startup: {}", coa_core::diag::redact(&started.output));
|
||||
let before = ledgers(root)?;
|
||||
assert!(!before[0].is_empty(), "Fresh SQUID history missing");
|
||||
assert!(driver::run(root, driver::Verb::StopAll)?.ok);
|
||||
let started = driver::run(root, driver::Verb::StartAll)?;
|
||||
assert!(started.ok, "Repeated SQUID startup: {}", coa_core::diag::redact(&started.output));
|
||||
assert_eq!(ledgers(root)?, before, "SQUID replay changed its migration history");
|
||||
println!("PASS: SQUID-disabled dual startup without its database; fresh enabled SQUID import and startup; repeated startup preserves all three histories");
|
||||
Ok(())
|
||||
}));
|
||||
assert!(driver::run(root, driver::Verb::StopAll)?.ok);
|
||||
restore(root, &meta, &point)?;
|
||||
result.map_err(|_| coa_core::Error::Invalid("SQUID acceptance failed; disposable databases and configurations restored".into()))?
|
||||
}
|
||||
|
||||
fn restore(root: &Path, meta: &Path, point: &backup::RecoveryPoint) -> Result<()> {
|
||||
assert!(backup::verify(meta, &point.id)?.ok);
|
||||
assert!(driver::run(root, driver::Verb::StopAll)?.ok);
|
||||
coa_core::realms::select(root, point.realm)?;
|
||||
for component in point.components.iter().filter(|component| component.name != "configs") {
|
||||
backup::restore_database(root, meta, &point.id, &component.name)?;
|
||||
}
|
||||
backup::restore_configs(root, meta, &point.id)?;
|
||||
assert!(driver::run(root, driver::Verb::StopAll)?.ok);
|
||||
println!("PASS: disposable SQUID acceptance databases and original realm configurations restored");
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn main() -> Result<()> {
|
||||
let root = PathBuf::from(std::env::args().nth(1).unwrap());
|
||||
assert!(root.file_name().unwrap().to_string_lossy().starts_with("coa-schema-fixture-chaos-064-transition-"));
|
||||
assert_eq!(std::fs::read(root.join(".transition-fixture"))?, b"disposable published-064 transition fixture");
|
||||
assert!(!root.join("Data").symlink_metadata()?.file_type().is_symlink());
|
||||
assert!(driver::run(&root, driver::Verb::StopAll)?.ok);
|
||||
if let Some(id) = std::env::args().nth(2) {
|
||||
let meta = coa_core::registry::metadata_dir_for(&root)?;
|
||||
return restore(&root, &meta, &backup::get(&meta, &id)?);
|
||||
}
|
||||
let result = exercise(&root);
|
||||
assert!(driver::run(&root, driver::Verb::StopAll)?.ok);
|
||||
result
|
||||
}
|
||||
@@ -0,0 +1,54 @@
|
||||
use std::{collections::BTreeMap, path::PathBuf};
|
||||
use coa_core::{backup, driver, registry::MetaDir, update::{self, RepackEnv}, Result};
|
||||
|
||||
fn players(db: &coa_core::db::Db) -> Result<String> {
|
||||
db.query("SELECT CONCAT(id,':',username,':',HEX(salt),':',HEX(verifier)) FROM acore_auth.account WHERE id=900001; SELECT CONCAT(guid,':',account,':',name,':',level,':',money) FROM acore_characters.characters WHERE guid=900001; SELECT CONCAT(guid,':',itemEntry,':',owner_guid,':',enchantments) FROM acore_characters.item_instance WHERE guid=900001; SELECT CONCAT(guid,':',bag,':',slot,':',item) FROM acore_characters.character_inventory WHERE guid=900001;")
|
||||
}
|
||||
|
||||
fn exercise(root: &std::path::Path, package: &str) -> Result<()> {
|
||||
let meta_dir = coa_core::registry::metadata_dir_for(root)?;
|
||||
let (_, meta) = MetaDir::open(&meta_dir)?;
|
||||
let expected = backup::with_database(root, |db| [coa_core::realms::Mode::Coa, coa_core::realms::Mode::Wildcard].into_iter().map(|mode| players(&db.clone().for_realm(mode))).collect::<Result<Vec<_>>>())?;
|
||||
assert!(driver::run(root, driver::Verb::StopAll)?.ok);
|
||||
let source = coa_core::pkgsource::Source::Dir(package.into());
|
||||
let preview = update::preview(root, &meta, &source, coa_core::signing::EMBEDDED_PUBLIC_KEY, &BTreeMap::new())?;
|
||||
assert_eq!(preview.pending_migrations, 0, "Historical SQL must not replay");
|
||||
assert!(!preview.items.iter().any(|item| item.action == update::Action::Conflict), "Unresolved candidate files: {:?}", preview.items);
|
||||
let environment = RepackEnv { root, meta_dir: &meta_dir };
|
||||
let outcome = update::apply(&update::Params {
|
||||
root, meta_dir: &meta_dir, source, trusted_key: coa_core::signing::EMBEDDED_PUBLIC_KEY,
|
||||
resolutions: BTreeMap::new(), cancel: Default::default(), env: &environment, fail_after_ops: None,
|
||||
}, &|stage, progress| println!("{progress}% {stage}"))?;
|
||||
assert_eq!(outcome.txn.state, update::State::Committed, "{:?}", outcome.txn);
|
||||
backup::with_database(root, |db| {
|
||||
for (index, mode) in [coa_core::realms::Mode::Coa, coa_core::realms::Mode::Wildcard].into_iter().enumerate() {
|
||||
let realm = db.clone().for_realm(mode);
|
||||
assert_eq!(players(&realm)?, expected[index], "Player data changed in {mode:?}");
|
||||
let problems = coa_core::schema_check::check(&realm, root)?;
|
||||
assert!(problems.is_empty(), "{problems:?}");
|
||||
}
|
||||
Ok(())
|
||||
})?;
|
||||
let release = coa_core::squid::release(root).expect("SQUID release metadata");
|
||||
println!("SQUID metadata: {release:?}");
|
||||
assert_eq!(coa_core::squid::fields(root)?.len(), 40);
|
||||
let (_, installed) = MetaDir::open(&meta_dir)?;
|
||||
let repeated = update::preview(root, &installed, &coa_core::pkgsource::Source::Dir(package.into()), coa_core::signing::EMBEDDED_PUBLIC_KEY, &BTreeMap::new())?;
|
||||
assert_eq!(repeated.pending_migrations, 0);
|
||||
assert!(repeated.items.iter().all(|item| item.action == update::Action::Skip), "{:?}", repeated.items);
|
||||
println!("PASS: coordinated update committed, both realms started, player fields preserved, historical SQL skipped, repeated preview clean");
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn main() -> Result<()> {
|
||||
let args: Vec<String> = std::env::args().skip(1).collect();
|
||||
let root = PathBuf::from(&args[0]);
|
||||
assert!(root.file_name().unwrap().to_string_lossy().starts_with("coa-schema-fixture-chaos-064-transition-"));
|
||||
assert_eq!(std::fs::read(root.join(".transition-fixture"))?, b"disposable published-064 transition fixture");
|
||||
assert_eq!(std::fs::read(root.join(".release-schema-fixture"))?, b"disposable release-schema fixture");
|
||||
assert!(!root.join("Data").symlink_metadata()?.file_type().is_symlink());
|
||||
assert!(driver::run(&root, driver::Verb::StopAll)?.ok);
|
||||
let outcome = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| exercise(&root, &args[1])));
|
||||
assert!(driver::run(&root, driver::Verb::StopAll)?.ok, "Fixture shutdown failed");
|
||||
outcome.map_err(|_| coa_core::Error::Invalid("Disposable coordinated acceptance failed; stopped services and retained recovery copies".into()))?
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
//! Install a new Docker server from a package folder, for a manual end-to-end check on Linux (needs docker).
|
||||
//! usage: docker_install <package folder> <destination> <game data folder> <public key (base64)>
|
||||
//! The key is the one the package was signed with (the production key is only used by the Manager itself).
|
||||
use coa_core::docker::install::{install, Params};
|
||||
use coa_core::download::Cancel;
|
||||
use coa_core::install::Source;
|
||||
use coa_core::registry::Registry;
|
||||
use std::path::PathBuf;
|
||||
|
||||
fn main() {
|
||||
let a: Vec<String> = std::env::args().skip(1).collect();
|
||||
assert!(a.len() == 4, "usage: docker_install <package folder> <destination> <game data folder> <public key>");
|
||||
let registry = Registry::at(std::env::temp_dir().join("coa-docker-install/installs.json"));
|
||||
let t = std::time::Instant::now();
|
||||
let done = install(
|
||||
&Params { source: Source::Dir(PathBuf::from(&a[0])), dest: PathBuf::from(&a[1]), data_dir: PathBuf::from(&a[2]), trusted_key: &a[3], registry: ®istry, cancel: Cancel::default() },
|
||||
&|s| eprintln!(" {:>3}% {} {}", s.percent, s.step, s.detail.unwrap_or_default()),
|
||||
)
|
||||
.unwrap_or_else(|e| panic!("install failed: {e}"));
|
||||
println!("installed {} at {} in {:?}", done.version, done.path, t.elapsed());
|
||||
}
|
||||
@@ -0,0 +1,93 @@
|
||||
//! Verify published checksum compatibility on a disposable real database, without running SQL migrations.
|
||||
use std::{path::{Path, PathBuf}, sync::atomic::{AtomicUsize, Ordering}};
|
||||
use coa_core::{backup, db::Db, migrations::{self, LedgerRow, Status, Store}, pkgsource::{self, Source}, Result};
|
||||
|
||||
struct Observed<'a> { db: &'a Db, executions: AtomicUsize }
|
||||
impl Store for Observed<'_> {
|
||||
fn load(&self) -> Result<Vec<LedgerRow>> { self.db.load() }
|
||||
fn put(&self, row: &LedgerRow) -> Result<()> { self.db.put(row) }
|
||||
fn run_file(&self, _: &str, _: &Path) -> Result<()> {
|
||||
self.executions.fetch_add(1, Ordering::SeqCst);
|
||||
panic!("Historical SQL must never be replayed");
|
||||
}
|
||||
}
|
||||
|
||||
fn main() -> Result<()> {
|
||||
let args: Vec<_> = std::env::args().skip(1).collect();
|
||||
let root = PathBuf::from(&args[0]);
|
||||
assert!(root.file_name().unwrap().to_string_lossy().starts_with("coa-schema-fixture-chaos-"));
|
||||
assert_eq!(std::fs::read(root.join(".coa-chaos-fixture"))?, b"disposable update chaos fixture");
|
||||
assert_eq!(std::fs::read(root.join(".release-schema-fixture"))?, b"disposable release-schema fixture");
|
||||
let source = Source::Dir(PathBuf::from(&args[1]));
|
||||
let package = pkgsource::fetch_manifest(&source, coa_core::signing::EMBEDDED_PUBLIC_KEY)?.0;
|
||||
let staging = tempfile::tempdir()?;
|
||||
let parts = pkgsource::fetch_parts(&source, &package, &staging.path().join("download"), &Default::default(), &|_, _| {})?;
|
||||
coa_core::package::extract(&parts, &package, &staging.path().join("tree"), &|_, _| {})?;
|
||||
migrations::verify_files(&package.migrations, &staging.path().join("tree/_migrations"))?;
|
||||
println!("PASS: all {} signed-package SQL artifacts verified before any database mutation", package.migrations.len());
|
||||
let migration = package.migrations.iter().find(|m| m.id == "manager_repair__20261005_missing_wildcard_tables").unwrap();
|
||||
let hashes = ["c1d8dbf2271234283a48a39e4b4aea1106b83b70581f1e3c4aa9fff438e8e4d2", "9e4a36245c3f83255415c122c01f08ceb3e3b83898d3d427ac4e2fbcf61e9638"];
|
||||
for hash in hashes { assert!(migration.sha256 == hash || migration.compatible_sha256.iter().any(|h| h == hash)); }
|
||||
let fixture_meta = coa_core::registry::metadata_dir_for(&root)?;
|
||||
let test_meta = tempfile::tempdir()?;
|
||||
coa_core::fsx::atomic_write(&test_meta.path().join("install.json"), &std::fs::read(fixture_meta.join("install.json"))?)?;
|
||||
coa_core::registry::MetaDir::open(test_meta.path())?;
|
||||
std::fs::create_dir_all(test_meta.path().join("updates"))?;
|
||||
let result = backup::with_database(&root, |db| {
|
||||
let mut modes = vec![coa_core::realms::Mode::Coa];
|
||||
if coa_core::realms::state(&root)?.wildcard_created { modes.push(coa_core::realms::Mode::Wildcard); }
|
||||
for mode in modes {
|
||||
let db = db.clone().for_realm(mode);
|
||||
let saved = db.load()?.into_iter().find(|row| row.id == migration.id && row.db == migration.db).expect("Published repair must already be applied");
|
||||
assert_eq!(saved.status, Status::Applied);
|
||||
let counts = db.query("SELECT CONCAT((SELECT COUNT(*) FROM acore_characters.characters),':',(SELECT COUNT(*) FROM acore_characters.item_instance),':',(SELECT COUNT(*) FROM acore_auth.account));")?;
|
||||
let check = || -> Result<()> {
|
||||
for hash in hashes {
|
||||
db.put(&LedgerRow { sha256: hash.into(), ..saved.clone() })?;
|
||||
let observed = Observed { db: &db, executions: AtomicUsize::new(0) };
|
||||
migrations::preflight(&db, std::slice::from_ref(migration))?;
|
||||
let report = migrations::apply_pending(&observed, std::slice::from_ref(migration), &root.join(".unused-hotfix-sql"), &|| panic!("Already applied SQL needs no snapshot"))?;
|
||||
assert!(report.applied.is_empty());
|
||||
assert_eq!(observed.executions.load(Ordering::SeqCst), 0);
|
||||
assert_eq!(db.load()?.into_iter().find(|r| r.id == migration.id && r.db == migration.db).unwrap().sha256, hash);
|
||||
}
|
||||
let meta = test_meta.path();
|
||||
let file_hash = coa_core::fsx::sha256_file(&root.join("Core/worldserver.exe"))?;
|
||||
let install_hash = coa_core::fsx::sha256_file(&meta.join("install.json"))?;
|
||||
let transaction_count = std::fs::read_dir(meta.join("updates"))?.count();
|
||||
for status in [Status::Running, Status::Failed] {
|
||||
db.put(&LedgerRow { status, ..saved.clone() })?;
|
||||
let env = coa_core::update::RepackEnv { root: &root, meta_dir: meta };
|
||||
let rejected = coa_core::update::apply(&coa_core::update::Params {
|
||||
root: &root, meta_dir: meta, source: Source::Dir(PathBuf::from(&args[1])),
|
||||
trusted_key: coa_core::signing::EMBEDDED_PUBLIC_KEY, cancel: Default::default(),
|
||||
resolutions: Default::default(), env: &env, fail_after_ops: None,
|
||||
}, &|_, _| {});
|
||||
let message = rejected.unwrap_err().to_string();
|
||||
assert!(message.contains("partially applied"), "Unexpected rejection: {message}");
|
||||
assert_eq!(std::fs::read_dir(meta.join("updates"))?.count(), transaction_count);
|
||||
assert_eq!(coa_core::fsx::sha256_file(&root.join("Core/worldserver.exe"))?, file_hash);
|
||||
assert_eq!(coa_core::fsx::sha256_file(&meta.join("install.json"))?, install_hash);
|
||||
}
|
||||
db.put(&saved)?;
|
||||
let env = coa_core::update::RepackEnv { root: &root, meta_dir: meta };
|
||||
let pending_before = env.pending_migrations(&package)?;
|
||||
db.query("DELETE FROM acore_world.coa_manager_migrations WHERE db='characters' AND id='manager_repair__20261005_missing_wildcard_tables';")?;
|
||||
assert_eq!(env.pending_migrations(&package)?, pending_before + 1,
|
||||
"Missing history in either realm must remain visible even with identical server files");
|
||||
db.put(&saved)?;
|
||||
assert_eq!(env.pending_migrations(&package)?, pending_before);
|
||||
Ok(())
|
||||
};
|
||||
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(check));
|
||||
db.put(&saved)?;
|
||||
result.map_err(|_| coa_core::Error::Invalid("History regression assertion failed; the injected ledger row was restored.".into()))??;
|
||||
assert_eq!(db.query("SELECT CONCAT((SELECT COUNT(*) FROM acore_characters.characters),':',(SELECT COUNT(*) FROM acore_characters.item_instance),':',(SELECT COUNT(*) FROM acore_auth.account));")?, counts);
|
||||
println!("PASS: {} published checksums; Running/Failed rejected before staging; missing migration counted; zero SQL replays; history and player counts preserved", mode.name());
|
||||
}
|
||||
Ok(())
|
||||
});
|
||||
assert!(coa_core::driver::run(&root, coa_core::driver::Verb::StopAll)?.ok);
|
||||
result?;
|
||||
Ok(())
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
//! Read-only update preview against the marked disposable acceptance fixture.
|
||||
use std::{collections::BTreeMap,path::PathBuf};
|
||||
fn main()->coa_core::Result<()> {
|
||||
let args:Vec<_>=std::env::args().skip(1).collect();
|
||||
let root=PathBuf::from(&args[0]);
|
||||
assert!(root.file_name().unwrap().to_string_lossy().starts_with("coa-schema-fixture-chaos-064-transition-"));
|
||||
assert_eq!(std::fs::read(root.join(".transition-fixture"))?,b"disposable published-064 transition fixture");
|
||||
let meta_dir=coa_core::registry::metadata_dir_for(&root)?;
|
||||
let (_,meta)=coa_core::registry::MetaDir::open(&meta_dir)?;
|
||||
let preview=coa_core::update::preview(&root,&meta,&coa_core::pkgsource::Source::Dir(args[1].clone().into()),coa_core::signing::EMBEDDED_PUBLIC_KEY,&BTreeMap::new())?;
|
||||
assert_eq!(preview.from_version.as_deref(),Some(preview.to_version.as_str()));
|
||||
assert_eq!(preview.pending_migrations,0);
|
||||
assert!(preview.items.iter().all(|item|item.action==coa_core::update::Action::Skip),"{:?}",preview.items.iter().filter(|item|item.action!=coa_core::update::Action::Skip).collect::<Vec<_>>());
|
||||
println!("PASS: real fixture repeated preview: {} files unchanged, zero pending SQL, no update offered",preview.items.len());
|
||||
Ok(())
|
||||
}
|
||||
@@ -0,0 +1,165 @@
|
||||
//! Real signed-package transition on an independent, explicitly marked disposable copy.
|
||||
//! The Env wrapper instruments only launcher isolation; migration/backup/update code is production code.
|
||||
use std::{collections::BTreeMap, path::{Path, PathBuf}};
|
||||
use coa_core::{backup, driver, fsx, migrations, pkgsource::{self, Source}, registry::{InstallMeta, MetaDir}, update::{self, Env, RepackEnv}, Result};
|
||||
|
||||
struct Offline<'a>(RepackEnv<'a>);
|
||||
impl Env for Offline<'_> {
|
||||
fn ensure_stopped(&self) -> Result<()> { self.0.ensure_stopped() }
|
||||
fn preflight(&self, m: &coa_core::manifest::Manifest) -> Result<()> { self.0.preflight(m) }
|
||||
fn verify_snapshot(&self, id: &str) -> Result<()> { self.0.verify_snapshot(id) }
|
||||
fn snapshot(&self) -> Result<String> { self.0.snapshot() }
|
||||
fn restore_snapshot(&self, id: &str) -> Result<()> { self.0.restore_snapshot(id) }
|
||||
fn migrate(&self, m: &coa_core::manifest::Manifest, p: &Path) -> Result<migrations::ApplyReport> { self.0.migrate(m,p) }
|
||||
fn validate(&self) -> Result<()> {
|
||||
let path=self.0.root.join("Scripts/manage.py");
|
||||
let source=std::fs::read_to_string(&path)?.replace("\r\n", "\n");
|
||||
// Explicit test instrumentation prevents relay transmissions and binds services locally.
|
||||
let guarded=source.replace("def spawn(name, command, cwd, log):\n", "def spawn(name, command, cwd, log):\n for filename in ('worldserver.conf', 'authserver.conf'):\n path = ROOT / 'Core/configs' / filename\n if path.exists():\n text = path.read_text(encoding='utf-8-sig')\n for key, value in (('BindIP', '\"127.0.0.1\"'), ('Ra.IP', '\"127.0.0.1\"'), ('SOAP.Enabled', '0')):\n text = re.sub(r'(?m)^\\s*' + re.escape(key) + r'\\s*=.*$', '', text)\n text += '\\n' + key + ' = ' + value + '\\n'\n path.write_text(text, encoding='utf-8')\n").replace("def relay_worker():\n", "def relay_worker():\n save_process('relay-ready', os.getpid())\n while not (STATE / 'stop-relay').exists():\n time.sleep(0.5)\n return\n");
|
||||
assert_ne!(source,guarded,"Fixture launcher isolation failed");
|
||||
fsx::atomic_write(&path,guarded.as_bytes())?;
|
||||
self.0.validate()
|
||||
}
|
||||
}
|
||||
fn players(db: &coa_core::db::Db) -> Result<String> {
|
||||
db.query("SELECT CONCAT(id,':',username,':',HEX(salt),':',HEX(verifier)) FROM acore_auth.account WHERE id=900001; SELECT CONCAT(guid,':',account,':',name,':',level,':',money) FROM acore_characters.characters WHERE guid=900001; SELECT CONCAT(guid,':',itemEntry,':',owner_guid,':',enchantments) FROM acore_characters.item_instance WHERE guid=900001; SELECT CONCAT(guid,':',bag,':',slot,':',item) FROM acore_characters.character_inventory WHERE guid=900001;")
|
||||
}
|
||||
fn main() -> Result<()> {
|
||||
let args:Vec<_>=std::env::args().skip(1).collect();
|
||||
let root=PathBuf::from(&args[0]);
|
||||
assert!(root.file_name().unwrap().to_string_lossy().starts_with("coa-schema-fixture-chaos-064-transition-"));
|
||||
assert_eq!(std::fs::read(root.join(".transition-fixture"))?,b"disposable published-064 transition fixture");
|
||||
if args.get(3).is_some_and(|mode| mode=="legacy-recovery") {
|
||||
return run_fixture(&root,||legacy_recovery(&root));
|
||||
}
|
||||
assert!(!root.join(".transition-started").exists(),"Use a new independent fixture");
|
||||
fsx::atomic_write(&root.join(".transition-started"),b"started")?;
|
||||
let meta=coa_core::registry::metadata_dir_for(&root)?;
|
||||
assert!(!meta.exists(),"Do not reuse experimental or user metadata");
|
||||
run_fixture(&root,||exercise(&root,&meta,&args[1],&args[2]))
|
||||
}
|
||||
fn run_fixture(root:&Path,operation:impl FnOnce()->Result<()>)->Result<()> {
|
||||
let result=std::panic::catch_unwind(std::panic::AssertUnwindSafe(operation));
|
||||
assert!(driver::run(root,driver::Verb::StopAll)?.ok,"Fixture shutdown failed");
|
||||
result.map_err(|_|coa_core::Error::Invalid("Disposable acceptance assertion failed; services were stopped and recovery copies retained.".into()))?
|
||||
}
|
||||
fn legacy_recovery(root:&Path)->Result<()> {
|
||||
let meta=coa_core::registry::metadata_dir_for(root)?;
|
||||
assert!(driver::run(root,driver::Verb::StopAll)?.ok);
|
||||
let expected=backup::with_database(root,|db| [coa_core::realms::Mode::Coa,coa_core::realms::Mode::Wildcard].into_iter().map(|mode|players(&db.clone().for_realm(mode))).collect::<Result<Vec<_>>>())?;
|
||||
assert!(driver::run(root,driver::Verb::StopAll)?.ok);
|
||||
let dirs=std::fs::read_dir(meta.join("updates"))?.collect::<std::io::Result<Vec<_>>>()?;
|
||||
assert_eq!(dirs.len(),1,"Requires exactly the preceding successful disposable transition");
|
||||
let txn_dir=dirs[0].path();
|
||||
let journal=txn_dir.join("txn.json");
|
||||
let mut legacy:serde_json::Value=fsx::read_json(&journal)?;
|
||||
assert_eq!(legacy["state"],"committed");
|
||||
let point=legacy["recovery_point"].as_str().unwrap().to_string();
|
||||
let point_path=meta.join("backups").join(&point).join("backup.json");
|
||||
let mut point_json:serde_json::Value=fsx::read_json(&point_path)?;
|
||||
point_json["manager_version"]="0.6.4".into();
|
||||
for component in point_json["components"].as_array_mut().unwrap() { component.as_object_mut().unwrap().remove("file_sha256"); }
|
||||
fsx::atomic_write_json(&point_path,&point_json)?;
|
||||
legacy.as_object_mut().unwrap().remove("recovery_hashes");
|
||||
legacy.as_object_mut().unwrap().remove("databases_started");
|
||||
legacy["state"]="applied".into();
|
||||
fsx::atomic_write_json(&journal,&legacy)?;
|
||||
assert!(update::ensure_recovered(&meta).is_err(),"Legacy unfinished update must block startup");
|
||||
let id=legacy["id"].as_str().unwrap();
|
||||
let env=RepackEnv {root,meta_dir:&meta};
|
||||
println!("Recovering legacy-format transaction and recovery point on disposable installation");
|
||||
assert_eq!(update::rollback(root,&meta,id,&env)?.state,update::State::RolledBack);
|
||||
for op in legacy["ops"].as_array().unwrap() {
|
||||
let relative=op["path"].as_str().unwrap();
|
||||
if op["had_previous"]==true {
|
||||
assert_eq!(fsx::sha256_file(&fsx::safe_join(root,relative)?)?,fsx::sha256_file(&fsx::safe_join(&txn_dir.join("before"),relative)?)?,"Legacy file restoration mismatch: {relative}");
|
||||
} else { assert!(!fsx::safe_join(root,relative)?.exists()); }
|
||||
}
|
||||
assert_eq!(std::fs::read(meta.join("install.json"))?,std::fs::read(txn_dir.join("before/manager-install.json"))?);
|
||||
backup::with_database(root,|db| {
|
||||
for (index,mode) in [coa_core::realms::Mode::Coa,coa_core::realms::Mode::Wildcard].into_iter().enumerate() {
|
||||
let db=db.clone().for_realm(mode);
|
||||
assert_eq!(players(&db)?,expected[index]);
|
||||
assert_eq!(db.query("SELECT COUNT(*) FROM acore_world.coa_manager_migrations WHERE id IN ('manager_repair__20261005_reconcile_wildcard_tables','manager_repair__20261005_reconcile_missing_class_starts');")?,"0");
|
||||
assert_eq!(db.query("SELECT sha256 FROM acore_world.coa_manager_migrations WHERE id='manager_repair__20261005_missing_wildcard_tables';")?,"9e4a36245c3f83255415c122c01f08ceb3e3b83898d3d427ac4e2fbcf61e9638");
|
||||
}
|
||||
Ok(())
|
||||
})?;
|
||||
assert!(driver::run(root,driver::Verb::StopAll)?.ok);
|
||||
assert!(update::pending_checked(&meta)?.is_none());
|
||||
assert!(update::rollback(root,&meta,id,&env).is_err(),"Completed recovery must not run again");
|
||||
println!("PASS: legacy journal blocked startup; old files, metadata, migration histories and player fields restored; completed recovery rejects replay. Original baseline had a missing table, so healthy startup is not claimed after rollback.");
|
||||
Ok(())
|
||||
}
|
||||
fn exercise(root:&Path,meta:&Path,baseline:&str,candidate:&str)->Result<()> {
|
||||
let mut install:InstallMeta=fsx::read_json(&PathBuf::from("C:/games/coa-schema-fixture-chaos-20261005-v1.manager/install.json"))?;
|
||||
install.server_path=root.to_string_lossy().into_owned();
|
||||
install.id=uuid::Uuid::new_v4().to_string();
|
||||
install.manager_version="0.6.4".into();
|
||||
MetaDir::create(root,&install)?;
|
||||
// Private ports, and no inherited PID records or paths to the source database.
|
||||
let mut cfg:serde_json::Value=fsx::read_json(&root.join("Settings/repack.json"))?;
|
||||
let mut listeners=Vec::new();
|
||||
for key in ["mysqlPort","authPort","worldPort","raPort"] {
|
||||
let listener=std::net::TcpListener::bind("127.0.0.1:0")?;
|
||||
cfg[key]=listener.local_addr()?.port().into(); listeners.push(listener);
|
||||
}
|
||||
fsx::atomic_write_json(&root.join("Settings/repack.json"),&cfg)?;
|
||||
let mut profile:serde_json::Value=fsx::read_json(&root.join("Settings/realm-profile.json"))?;
|
||||
for key in ["secondary_world_port","secondary_ra_port"] {
|
||||
let listener=std::net::TcpListener::bind("127.0.0.1:0")?;
|
||||
profile[key]=listener.local_addr()?.port().into(); listeners.push(listener);
|
||||
}
|
||||
fsx::atomic_write_json(&root.join("Settings/realm-profile.json"),&profile)?;
|
||||
drop(listeners);
|
||||
let state=root.join(".state");
|
||||
if state.exists() { std::fs::remove_dir_all(&state)?; }
|
||||
let secondary_state=root.join(".realms/secondary/.state");
|
||||
if secondary_state.exists() { std::fs::remove_dir_all(&secondary_state)?; }
|
||||
let source=Source::Dir(baseline.into());
|
||||
let (manifest,_)=pkgsource::fetch_manifest(&source,coa_core::signing::EMBEDDED_PUBLIC_KEY)?;
|
||||
let temp=tempfile::tempdir()?;
|
||||
let parts=pkgsource::fetch_parts(&source,&manifest,&temp.path().join("download"),&Default::default(),&|_,_|{})?;
|
||||
let tree=temp.path().join("tree");
|
||||
coa_core::package::extract(&parts,&manifest,&tree,&|_,_|{})?;
|
||||
for file in &manifest.files {
|
||||
if file.path.starts_with("_migrations/") {continue;}
|
||||
fsx::atomic_write(&fsx::safe_join(root,&file.path)?,&std::fs::read(fsx::safe_join(&tree,&file.path)?)?)?;
|
||||
install.original_hashes.insert(file.path.clone(),file.sha256.clone());
|
||||
}
|
||||
install.core.version=Some(manifest.version);
|
||||
fsx::atomic_write_json(&meta.join("install.json"),&install)?;
|
||||
// Both worlds must remain local, including generated secondary configuration.
|
||||
for relative in ["Settings/worldserver.conf.template","Settings/authserver.conf.template"] {
|
||||
let p=root.join(relative);
|
||||
let mut conf=coa_core::config::parser::ConfFile::parse_bytes(&std::fs::read(&p)?)?;
|
||||
conf.set("BindIP","\"127.0.0.1\"",&[]); conf.set("Ra.IP","\"127.0.0.1\"",&[]); conf.set("SOAP.Enabled","0",&[]);
|
||||
fsx::atomic_write(&p,conf.to_text().as_bytes())?;
|
||||
}
|
||||
let expected=backup::with_database(root,|db| {
|
||||
let mut saved=Vec::new();
|
||||
for mode in [coa_core::realms::Mode::Coa,coa_core::realms::Mode::Wildcard] {
|
||||
let db=db.clone().for_realm(mode);
|
||||
saved.push(players(&db)?);
|
||||
db.query("DROP TABLE IF EXISTS acore_characters.coa_wildcard_skill_card; DELETE FROM acore_world.coa_manager_migrations WHERE id IN ('manager_repair__20261005_reconcile_wildcard_tables','manager_repair__20261005_reconcile_missing_class_starts'); UPDATE acore_world.coa_manager_migrations SET sha256='9e4a36245c3f83255415c122c01f08ceb3e3b83898d3d427ac4e2fbcf61e9638' WHERE id='manager_repair__20261005_missing_wildcard_tables' AND status='applied';")?;
|
||||
}
|
||||
Ok(saved)
|
||||
})?;
|
||||
let source=Source::Dir(candidate.into());
|
||||
let candidate_manifest=pkgsource::fetch_manifest(&source,coa_core::signing::EMBEDDED_PUBLIC_KEY)?.0;
|
||||
let choices:BTreeMap<_,_>=update::plan(root,&install,&candidate_manifest,&BTreeMap::new(),None)?.into_iter().filter(|p|p.action==update::Action::Conflict).map(|p|(p.path,update::Resolution::Replace)).collect();
|
||||
let env=Offline(RepackEnv{root,meta_dir:meta});
|
||||
let outcome=update::apply(&update::Params {root,meta_dir:meta,source,trusted_key:coa_core::signing::EMBEDDED_PUBLIC_KEY,cancel:Default::default(),resolutions:choices,env:&env,fail_after_ops:None},&|stage,pct|println!("{pct}% {stage}"))?;
|
||||
assert_eq!(outcome.txn.state,update::State::Committed,"{:?}",outcome.txn.message);
|
||||
backup::with_database(root,|db| {
|
||||
for (index,mode) in [coa_core::realms::Mode::Coa,coa_core::realms::Mode::Wildcard].into_iter().enumerate() {
|
||||
let db=db.clone().for_realm(mode);
|
||||
assert_eq!(players(&db)?,expected[index],"Player data changed in {}",mode.name());
|
||||
assert!(coa_core::schema_check::check(&db,root)?.is_empty());
|
||||
assert_eq!(migrations::pending_count(&db,&candidate_manifest.migrations)?,0);
|
||||
}
|
||||
Ok(())
|
||||
})?;
|
||||
println!("PASS: signed historical package to candidate; missing Wildcard table repaired in both realms; player fields and inventory preserved; schema and startup verified. Launcher isolation was test instrumentation, not packaged UI acceptance.");
|
||||
Ok(())
|
||||
}
|
||||
@@ -29,7 +29,7 @@ fn main() {
|
||||
let dst = staging.join(db).join(format!("{id}.sql"));
|
||||
std::fs::create_dir_all(dst.parent().unwrap()).unwrap();
|
||||
std::fs::write(&dst, &bytes).unwrap();
|
||||
list.push(Migration { id, db: db.into(), sha256: fsx::sha256_bytes(&bytes), destructive: false });
|
||||
list.push(Migration { compatible_sha256: vec![], id, db: db.into(), sha256: fsx::sha256_bytes(&bytes), destructive: false });
|
||||
};
|
||||
for (kind, dirs) in [("auth", ["db_auth", "pending_db_auth"]), ("characters", ["db_characters", "pending_db_characters"]), ("world", ["db_world", "pending_db_world"])] {
|
||||
for d in dirs {
|
||||
|
||||
@@ -0,0 +1,43 @@
|
||||
//! Probe only a disposable fixture: enable both worlds, verify isolation, gracefully stop both.
|
||||
use coa_core::{Error, Result, driver::{self, Verb}, realms::{self, Mode}, multiworld, process::{self, ServiceState}};
|
||||
use std::path::PathBuf;
|
||||
|
||||
fn main() -> Result<()> {
|
||||
let root = PathBuf::from(std::env::args().nth(1).ok_or_else(|| Error::Invalid("fixture path required".into()))?);
|
||||
if !root.file_name().is_some_and(|n| n.to_string_lossy().contains("fixture")) { return Err(Error::Invalid("Refusing a non-fixture server.".into())); }
|
||||
let action = std::env::args().nth(2).unwrap_or_else(|| "smoke".into());
|
||||
if action == "stop" { driver::run(&root, Verb::StopAll)?; return Ok(()); }
|
||||
driver::run(&root, Verb::StopAll)?;
|
||||
if action == "wildcard" { realms::select(&root, Mode::Wildcard)?; }
|
||||
multiworld::set_enabled(&root, true)?;
|
||||
let result = (|| {
|
||||
let out = driver::run(&root, Verb::StartAll)?;
|
||||
if !out.ok { return Err(Error::Invalid(out.output)); }
|
||||
let first = process::observe(&root, &coa_core::layout::read_ports(&root));
|
||||
let second_root = multiworld::root(&root);
|
||||
let second = process::observe(&second_root, &coa_core::layout::read_ports(&second_root));
|
||||
assert_eq!(first.world.state, ServiceState::Running);
|
||||
assert_eq!(second.world.state, ServiceState::Running);
|
||||
assert_ne!(first.world.pid, second.world.pid);
|
||||
assert_ne!(first.world.port, second.world.port);
|
||||
assert!(second.mysql.pid.is_none() && second.auth.pid.is_none());
|
||||
let db = coa_core::db::Db::from_repack(&root, coa_core::db::Account::Admin)?;
|
||||
let realms = db.query("SELECT id,port,flag FROM acore_auth.realmlist WHERE id IN (1,2) ORDER BY id;")?;
|
||||
println!("Two distinct world PIDs; shared auth/MySQL; realm rows:\n{realms}");
|
||||
for mode in [Mode::Coa, Mode::Wildcard] {
|
||||
let problems = coa_core::schema_check::check(&db.clone().for_realm(mode), &root)?;
|
||||
println!("{}: {} database problems", mode.name(), problems.len());
|
||||
for p in problems.iter().take(5) { println!("{}.{}.{}: {}", p.database, p.table, p.column, p.detail); }
|
||||
}
|
||||
assert!(multiworld::set_enabled(&root, false).is_err());
|
||||
assert!(realms::select(&root, Mode::Wildcard).is_err());
|
||||
Ok(())
|
||||
})();
|
||||
let stopped = driver::run(&root, Verb::StopAll)?;
|
||||
if !stopped.ok { return Err(Error::Invalid(stopped.output)); }
|
||||
assert!(!multiworld::is_running(&root));
|
||||
assert_eq!(process::observe(&root, &coa_core::layout::read_ports(&root)).mysql.state, ServiceState::Stopped);
|
||||
result?;
|
||||
println!("Both worlds shut down before the shared database.");
|
||||
Ok(())
|
||||
}
|
||||
@@ -58,7 +58,7 @@ fn main() -> Result<()> {
|
||||
let path = staged.join(format!("{kind}/manager_realm_fixture.sql"));
|
||||
std::fs::create_dir_all(path.parent().unwrap())?;
|
||||
std::fs::write(&path, sql)?;
|
||||
manifest.migrations.push(Migration { id: "manager_realm_fixture".into(), db: kind.into(), sha256: coa_core::fsx::sha256_file(&path)?, destructive: false });
|
||||
manifest.migrations.push(Migration { compatible_sha256: vec![], id: "manager_realm_fixture".into(), db: kind.into(), sha256: coa_core::fsx::sha256_file(&path)?, destructive: false });
|
||||
}
|
||||
let result = env.migrate(&manifest, &staged)?;
|
||||
assert!(result.failed.is_none());
|
||||
|
||||
@@ -0,0 +1,62 @@
|
||||
//! Signed-package repair smoke test. Only a disposable fixture may be used.
|
||||
use std::path::PathBuf;
|
||||
use base64::{engine::general_purpose::STANDARD, Engine};
|
||||
use ed25519_dalek::{Signer, SigningKey};
|
||||
use coa_core::{Result, Error, fsx, package::{self, BuildOptions}, manifest::{Kind, Migration}, registry::{InstallKind, InstallMeta, MetaDir, metadata_dir_for}, pkgsource::Source, realms::Mode};
|
||||
|
||||
fn main() -> Result<()> {
|
||||
let root = PathBuf::from(std::env::args().nth(1).ok_or_else(|| Error::Invalid("fixture path required".into()))?);
|
||||
if !root.file_name().is_some_and(|n| n.to_string_lossy().contains("fixture")) { return Err(Error::Invalid("Refusing a non-fixture server.".into())); }
|
||||
let work = tempfile::tempdir()?;
|
||||
let base_tree = work.path().join("base-tree");
|
||||
let update_tree = work.path().join("update-tree");
|
||||
let base_pkg = work.path().join("base-pkg");
|
||||
let update_pkg = work.path().join("update-pkg");
|
||||
let probe = "Core/reference/repair-e2e.txt";
|
||||
fsx::atomic_write(&base_tree.join(probe), b"base")?;
|
||||
fsx::atomic_write(&update_tree.join(probe), b"correct official file")?;
|
||||
let sql = "CREATE TABLE IF NOT EXISTS acore_world.manager_repair_probe (id INT PRIMARY KEY); INSERT IGNORE INTO acore_world.manager_repair_probe VALUES (42);";
|
||||
let id = "20261004_repair_e2e";
|
||||
fsx::atomic_write(&update_tree.join(format!("_migrations/world/{id}.sql")), sql.as_bytes())?;
|
||||
let options = |kind, version: &str, migrations| BuildOptions { kind, version: version.into(), core_commit: None, built_at: "fixture".into(), part_size: 1 << 20, bots_commit: None, migrations };
|
||||
let base = package::build(&base_tree, &base_pkg, &options(Kind::Base, "1.0.0", vec![]), &|_| {})?;
|
||||
let update = package::build(&update_tree, &update_pkg, &options(Kind::Update, "1.0.1", vec![Migration { compatible_sha256: vec![], id: id.into(), db: "world".into(), sha256: fsx::sha256_bytes(sql.as_bytes()), destructive: false }]), &|_| {})?;
|
||||
// A test-only trust key, unrelated to production signing material.
|
||||
let key = SigningKey::from_bytes(&[23; 32]);
|
||||
let public = STANDARD.encode(key.verifying_key().as_bytes());
|
||||
for pkg in [&base_pkg, &update_pkg] {
|
||||
fsx::atomic_write(&pkg.join("manifest.json.sig"), STANDARD.encode(key.sign(&std::fs::read(pkg.join("manifest.json"))?).to_bytes()).as_bytes())?;
|
||||
}
|
||||
let dir = metadata_dir_for(&root)?;
|
||||
let mut meta = InstallMeta::new(InstallKind::New, &root);
|
||||
meta.core.version = Some(update.version.clone());
|
||||
MetaDir::create(&root, &meta)?;
|
||||
fsx::atomic_write_json(&dir.join("manifests/base.json"), &base)?;
|
||||
fsx::atomic_write_json(&dir.join("manifests/update-1.0.1.json"), &update)?;
|
||||
fsx::atomic_write(&root.join(probe), b"corrupted")?;
|
||||
let settings = std::fs::read(root.join("Settings/repack.json"))?;
|
||||
let counts = coa_core::backup::with_database(&root, |db| db.query("SELECT COUNT(*) FROM acore_auth.account; SELECT COUNT(*) FROM acore_characters.characters; SELECT COUNT(*) FROM acore_characters_wildcard.characters;"))?;
|
||||
let report = coa_core::repair::run(&root, &dir, &Source::Dir(base_pkg), &Source::Dir(update_pkg), &public, &|s,p| println!("{p}% {s}"))?;
|
||||
assert_eq!(std::fs::read(root.join(probe))?, b"correct official file");
|
||||
assert!(report.error.is_none(), "{:?}", report.error);
|
||||
assert_eq!(report.applied.len(), 2, "Migration must run in both worlds");
|
||||
assert!(report.database.iter().all(|d| d.problems.is_empty() && d.migrations.iter().all(|m| m.status == coa_core::migrations::Status::Applied)));
|
||||
assert_eq!(std::fs::read(root.join("Settings/repack.json"))?, settings);
|
||||
assert!(coa_core::backup::verify(&dir, &report.backup)?.ok);
|
||||
coa_core::backup::with_database(&root, |db| {
|
||||
assert_eq!(db.query("SELECT COUNT(*) FROM acore_auth.account; SELECT COUNT(*) FROM acore_characters.characters; SELECT COUNT(*) FROM acore_characters_wildcard.characters;")?, counts);
|
||||
for mode in [Mode::Coa, Mode::Wildcard] {
|
||||
assert_eq!(db.clone().for_realm(mode).query("SELECT id FROM acore_world.manager_repair_probe;")?, "42");
|
||||
}
|
||||
// Corrupt only the second realm, proving that checks read its actual schema.
|
||||
let wildcard = db.clone().for_realm(Mode::Wildcard);
|
||||
wildcard.query("ALTER TABLE acore_characters.character_action DROP COLUMN type;")?;
|
||||
let problems = coa_core::schema_check::check(&wildcard, &root)?;
|
||||
assert!(problems.iter().any(|p| p.table == "character_action" && p.column == "type"));
|
||||
assert!(coa_core::schema_check::check(&db.clone().for_realm(Mode::Coa), &root)?.is_empty());
|
||||
wildcard.query("ALTER TABLE acore_characters.character_action ADD COLUMN type TINYINT UNSIGNED NOT NULL DEFAULT 0;")?;
|
||||
Ok(())
|
||||
})?;
|
||||
println!("Repair verified: signed file restored, both realms migrated, backup valid, accounts/characters/settings preserved, missing column isolated to its realm.");
|
||||
Ok(())
|
||||
}
|
||||
@@ -0,0 +1,26 @@
|
||||
//! Check full schema contracts and blocking custom columns, only against a disposable fixture.
|
||||
use coa_core::{Result, Error, backup, schema_check, realms::Mode};
|
||||
use std::path::PathBuf;
|
||||
fn main() -> Result<()> {
|
||||
let root = PathBuf::from(std::env::args().nth(1).ok_or_else(|| Error::Invalid("fixture path required".into()))?);
|
||||
if !root.file_name().is_some_and(|n| n.to_string_lossy().contains("fixture")) { return Err(Error::Invalid("Refusing a non-fixture server.".into())); }
|
||||
backup::with_database(&root, |db| {
|
||||
let coa = db.clone().for_realm(Mode::Coa);
|
||||
let wildcard = db.clone().for_realm(Mode::Wildcard);
|
||||
assert!(schema_check::check(&coa, &root)?.is_empty());
|
||||
assert!(schema_check::check(&wildcard, &root)?.is_empty());
|
||||
let reference = tempfile::tempdir()?;
|
||||
schema_check::capture(&coa, reference.path())?;
|
||||
assert!(schema_check::check(&coa, reference.path())?.is_empty());
|
||||
wildcard.query("ALTER TABLE acore_characters.character_action ADD COLUMN manager_required INT NOT NULL;")?;
|
||||
let result = (|| {
|
||||
assert!(schema_check::check(&wildcard, &root)?.iter().any(|p| p.table == "character_action" && p.column == "manager_required"));
|
||||
assert!(schema_check::check(&coa, &root)?.is_empty());
|
||||
Ok(())
|
||||
})();
|
||||
wildcard.query("ALTER TABLE acore_characters.character_action DROP COLUMN manager_required;")?;
|
||||
result
|
||||
})?;
|
||||
println!("Full schema contract and a blocking NOT NULL column verified; second-realm corruption does not affect CoA checks.");
|
||||
Ok(())
|
||||
}
|
||||
@@ -33,7 +33,7 @@ fn main() {
|
||||
let sql = "CREATE TABLE IF NOT EXISTS coa_manager_update_test (id INT PRIMARY KEY); INSERT IGNORE INTO coa_manager_update_test VALUES (1);";
|
||||
put(&src, "_migrations/world/2026_09_30_00_update_e2e.sql", sql);
|
||||
let mut m = build(&src, &pkg, &BuildOptions { kind: Kind::Update, version: "0.2.0".into(), core_commit: None, built_at: chrono::Utc::now().to_rfc3339(), part_size: 1 << 20, bots_commit: None, migrations: vec![] }, &|_| {}).unwrap();
|
||||
m.migrations.push(Migration { id: "2026_09_30_00_update_e2e".into(), db: "world".into(), sha256: fsx::sha256_bytes(sql.as_bytes()), destructive: false });
|
||||
m.migrations.push(Migration { compatible_sha256: vec![], id: "2026_09_30_00_update_e2e".into(), db: "world".into(), sha256: fsx::sha256_bytes(sql.as_bytes()), destructive: false });
|
||||
std::fs::write(pkg.join("manifest.json"), serde_json::to_vec_pretty(&m).unwrap()).unwrap();
|
||||
let key = format!("{}/.coa-manager/signing/manifest-signing.key", std::env::var("USERPROFILE").unwrap());
|
||||
let seed: [u8; 32] = STANDARD.decode(std::fs::read_to_string(key).unwrap().trim()).unwrap().try_into().unwrap();
|
||||
|
||||
@@ -0,0 +1,76 @@
|
||||
//! Failure injection on a NEW disposable fixture created by tools/make-fixture.ps1.
|
||||
//! Uses real MySQL dumps, SQL execution, signed packages and update rollback.
|
||||
use std::{collections::BTreeMap, path::{Path, PathBuf}};
|
||||
use coa_core::{backup, db::{Account, Db}, download::Cancel, driver::{self, Verb}, fsx,
|
||||
manifest::{Kind, Migration}, package::{self, BuildOptions}, pkgsource::Source,
|
||||
registry::{InstallKind, InstallMeta, MetaDir},
|
||||
update::{self, Env, RepackEnv}, Error, Result};
|
||||
use base64::Engine;
|
||||
use ed25519_dalek::{Signer, SigningKey};
|
||||
|
||||
fn main() -> Result<()> {
|
||||
let arg = std::env::args().nth(1).expect("usage: update_recovery_e2e <new fixture>");
|
||||
let root = PathBuf::from(arg);
|
||||
assert!(root.file_name().unwrap().to_string_lossy().starts_with("coa-update-recovery-fixture-"));
|
||||
assert!(!root.join("recovery-e2e-started").exists(), "Use a new fixture; never reuse an owned server");
|
||||
fsx::atomic_write(&root.join("recovery-e2e-started"), b"disposable fixture")?;
|
||||
let result = exercise(&root);
|
||||
let stopped = driver::run(&root, Verb::StopAll)?;
|
||||
assert!(stopped.ok);
|
||||
result
|
||||
}
|
||||
|
||||
fn exercise(root: &Path) -> Result<()> {
|
||||
let meta = coa_core::registry::metadata_dir_for(root)?;
|
||||
let mut installed = InstallMeta::new(InstallKind::New, root);
|
||||
installed.core.version = Some("1.0.0".into());
|
||||
MetaDir::create(root, &installed)?;
|
||||
backup::with_database(root, |db| {
|
||||
db.query("CREATE TABLE acore_characters.manager_recovery_probe (id INT); INSERT INTO acore_characters.manager_recovery_probe VALUES (42); CREATE TABLE acore_world.manager_recovery_probe (id INT); INSERT INTO acore_world.manager_recovery_probe VALUES (43);")?;
|
||||
db.query("CREATE VIEW acore_characters.manager_recovery_view AS SELECT id FROM acore_characters.manager_recovery_probe; CREATE TRIGGER acore_characters.manager_recovery_trigger BEFORE INSERT ON acore_characters.manager_recovery_probe FOR EACH ROW SET NEW.id=NEW.id+1; CREATE PROCEDURE acore_characters.manager_recovery_proc() SELECT id FROM acore_characters.manager_recovery_probe;")?;
|
||||
Ok(())
|
||||
})?;
|
||||
let source = root.join("fixture-update-source");
|
||||
fsx::atomic_write(&source.join("Core/recovery-probe.txt"), b"updated")?;
|
||||
let mut migrations = Vec::new();
|
||||
for (db, id, sql) in [
|
||||
("characters", "probe_chars", "UPDATE manager_recovery_probe SET id=999;"),
|
||||
("world", "probe_world", "DROP TABLE manager_recovery_probe; THIS IS INTENTIONALLY INVALID SQL;"),
|
||||
] {
|
||||
fsx::atomic_write(&source.join(format!("_migrations/{db}/{id}.sql")), sql.as_bytes())?;
|
||||
migrations.push(Migration { compatible_sha256: vec![], db: db.into(), id: id.into(), sha256: fsx::sha256_bytes(sql.as_bytes()), destructive: false });
|
||||
}
|
||||
let pkg = root.join("fixture-package");
|
||||
let manifest = package::build(&source, &pkg, &BuildOptions {
|
||||
kind: Kind::Update, version: "2.0.0".into(), core_commit: None, bots_commit: None,
|
||||
built_at: "fixture".into(), part_size: 1 << 20, migrations,
|
||||
}, &|_| {})?;
|
||||
let key = SigningKey::generate(&mut rand_core::OsRng);
|
||||
let signature = base64::engine::general_purpose::STANDARD.encode(key.sign(&std::fs::read(pkg.join("manifest.json"))?).to_bytes());
|
||||
fsx::atomic_write(&pkg.join("manifest.json.sig"), signature.as_bytes())?;
|
||||
let trusted = base64::engine::general_purpose::STANDARD.encode(key.verifying_key().to_bytes());
|
||||
let env = RepackEnv { root, meta_dir: &meta };
|
||||
let error = update::apply(&update::Params {
|
||||
root, meta_dir: &meta, source: Source::Dir(pkg), trusted_key: &trusted,
|
||||
cancel: Cancel::default(), resolutions: BTreeMap::new(), env: &env, fail_after_ops: None,
|
||||
}, &|step, pct| println!("{pct}% {step}" )).unwrap_err();
|
||||
assert!(error.to_string().contains("probe_world"), "{error}");
|
||||
assert!(error.to_string().contains("private update rehearsal failed"), "{error}");
|
||||
assert!(!root.join("Core/recovery-probe.txt").exists());
|
||||
assert!(update::unfinished(&meta).is_none());
|
||||
assert_eq!(MetaDir::open(&meta)?.1.core.version.as_deref(), Some("1.0.0"));
|
||||
backup::with_database(root, |db| {
|
||||
assert_eq!(db.query("SELECT id FROM acore_characters.manager_recovery_probe;")?, "42");
|
||||
assert_eq!(db.query("SELECT id FROM acore_world.manager_recovery_probe;")?, "43");
|
||||
assert_eq!(db.query("SELECT id FROM acore_characters.manager_recovery_view;")?, "42");
|
||||
assert_eq!(db.recovery_objects("acore_characters")?.iter().filter(|object| object["name"].as_str().is_some_and(|name| name.starts_with("manager_recovery_"))).count(), 3);
|
||||
assert!(!coa_core::migrations::status(db, &manifest.migrations)?.iter().any(|m| m.status == coa_core::migrations::Status::Applied));
|
||||
Ok(())
|
||||
})?;
|
||||
// A recovery point can be reused if the process died midway through restoring multiple schemas.
|
||||
let point = backup::list(&meta).into_iter().find(|p| p.trigger == backup::Trigger::BeforeUpdate).ok_or_else(|| Error::Invalid("missing backup".into()))?;
|
||||
env.restore_snapshot(&point.id)?;
|
||||
assert_eq!(Db::from_repack(root, Account::Admin)?.realm(), coa_core::realms::Mode::Coa);
|
||||
println!("PASS: private rehearsal caught failed SQL before changing the installed world, characters, ledger, objects, files or version; complete recovery succeeded");
|
||||
Ok(())
|
||||
}
|
||||
@@ -0,0 +1,19 @@
|
||||
use coa_core::update::{Env, RepackEnv};
|
||||
use std::path::PathBuf;
|
||||
|
||||
fn main() {
|
||||
let root = PathBuf::from(std::env::args().nth(1).expect("disposable fixture path"));
|
||||
assert_eq!(std::fs::read(root.join(".release-schema-fixture")).unwrap(), b"disposable release-schema fixture");
|
||||
let meta = coa_core::registry::metadata_dir_for(&root).unwrap();
|
||||
let env = RepackEnv { root: &root, meta_dir: &meta };
|
||||
let result = env.validate();
|
||||
let _ = coa_core::driver::run(&root, coa_core::driver::Verb::StopAll);
|
||||
if let Err(error) = result {
|
||||
eprintln!("{}", error);
|
||||
for log in ["Core/Logs/auth-console.log", "Core/Logs/world-console.log", "Core/Logs/supervisor.log"] {
|
||||
eprintln!("{log}:\n{}", coa_core::diag::redact(&coa_core::health::tail(&root.join(log), 8192)));
|
||||
}
|
||||
std::process::exit(1);
|
||||
}
|
||||
println!("Published server startup validation passed on the disposable fixture");
|
||||
}
|
||||
@@ -0,0 +1,58 @@
|
||||
//! Reproduce applied migration history with five missing tables on a disposable MySQL fixture.
|
||||
use std::path::PathBuf;
|
||||
use coa_core::{backup, fsx, manifest::Migration, migrations::{self, LedgerRow, Status, Store}, release_schema, schema_check, Error, Result};
|
||||
|
||||
fn main() -> Result<()> {
|
||||
let mut args = std::env::args().skip(1);
|
||||
let root = PathBuf::from(args.next().ok_or_else(|| Error::Invalid("fixture path required".into()))?);
|
||||
let old_sql = PathBuf::from(args.next().ok_or_else(|| Error::Invalid("core SQL directory required".into()))?);
|
||||
let repairs = PathBuf::from(args.next().ok_or_else(|| Error::Invalid("repair SQL directory required".into()))?);
|
||||
if !root.file_name().is_some_and(|n| n.to_string_lossy().starts_with("coa-update-recovery-fixture-"))
|
||||
|| !root.join("recovery-e2e-started").exists() {
|
||||
return Err(Error::Invalid("Refusing a non-disposable recovery fixture.".into()));
|
||||
}
|
||||
let tree = tempfile::tempdir()?;
|
||||
backup::with_database(&root, |db| {
|
||||
let db = db.clone().for_realm(coa_core::realms::Mode::Coa);
|
||||
let characters = db.query("SELECT COUNT(*) FROM acore_characters.characters;")?;
|
||||
db.load()?;
|
||||
// Record exactly the old file hashes, as in the user's all-applied report.
|
||||
let mut migrations = Vec::new();
|
||||
for name in ["rev_20260929_92_coa_wildcard_skill_cards", "rev_20260929_93_coa_wildcard_skill_card_duplicates", "rev_20260929_94_coa_wildcard_specialization_cache"] {
|
||||
let path = old_sql.join(format!("{name}.sql"));
|
||||
let hash = fsx::sha256_file(&path)?;
|
||||
db.put(&LedgerRow { db: "characters".into(), id: name.into(), sha256: hash.clone(), status: Status::Applied, error: None, baseline: false })?;
|
||||
migrations.push(Migration { compatible_sha256: vec![], db: "characters".into(), id: name.into(), sha256: hash, destructive: false });
|
||||
}
|
||||
for (_, tables) in schema_check::WILDCARD_TABLES.iter().filter(|(kind,_)| *kind == "characters") {
|
||||
for table in *tables { db.query(&format!("DROP TABLE IF EXISTS acore_characters.`{table}`;"))?; }
|
||||
}
|
||||
assert!(migrations::status(&db, &migrations)?.iter().all(|m| m.status == Status::Applied));
|
||||
assert!(!db.tables("acore_characters")?.iter().any(|t| t == "coa_wildcard_skill_card"));
|
||||
let empty_core = tempfile::tempdir()?;
|
||||
let files = release_schema::collect(empty_core.path(), None, Some(&repairs))?;
|
||||
assert_eq!(files.len(), 1);
|
||||
let repair = &files[0];
|
||||
migrations.push(Migration { compatible_sha256: vec![], db: repair.db.clone(), id: repair.id.clone(), sha256: repair.sha256.clone(), destructive: false });
|
||||
let staged = tree.path().join("sql/characters");
|
||||
fsx::atomic_write(&staged.join(format!("{}.sql", repair.id)), &std::fs::read(&repair.abs)?)?;
|
||||
let report = migrations::apply_pending(&db, &migrations, &tree.path().join("sql"), &|| Ok("disposable fixture".into()))?;
|
||||
assert!(report.failed.is_none());
|
||||
assert_eq!(report.applied, [repair.id.clone()]);
|
||||
assert_eq!(db.query("SELECT COUNT(*) FROM acore_characters.characters;")?, characters);
|
||||
db.query("INSERT INTO acore_characters.coa_wildcard_skill_card VALUES (77,123,456);")?;
|
||||
db.run_sql_file("acore_characters", &repair.abs)?;
|
||||
assert_eq!(db.query("SELECT progress FROM acore_characters.coa_wildcard_skill_card WHERE account=77 AND card=123;")?, "456");
|
||||
assert!(migrations::apply_pending(&db, &migrations, &tree.path().join("sql"), &|| Ok("disposable fixture".into()))?.applied.is_empty());
|
||||
schema_check::capture(&db, tree.path())?;
|
||||
db.query("DROP TABLE acore_characters.coa_wildcard_skill_card_purchase;")?;
|
||||
assert!(schema_check::check(&db, tree.path())?.iter().any(|p| p.table == "coa_wildcard_skill_card_purchase" && p.detail == "Missing table"));
|
||||
db.run_sql_file("acore_characters", &repair.abs)?;
|
||||
db.query("ALTER TABLE acore_characters.coa_wildcard_skill_card DROP COLUMN progress;")?;
|
||||
assert!(schema_check::check(&db, tree.path())?.iter().any(|p| p.table == "coa_wildcard_skill_card" && p.column == "progress"));
|
||||
db.query("ALTER TABLE acore_characters.coa_wildcard_skill_card ADD COLUMN progress INT UNSIGNED NOT NULL DEFAULT 0;")?;
|
||||
Ok(())
|
||||
})?;
|
||||
println!("Applied history with all five tables missing repaired; characters and existing card rows preserved; full contract detects missing tables and columns.");
|
||||
Ok(())
|
||||
}
|
||||
@@ -27,7 +27,18 @@ const LIST_SQL: &str = "SELECT a.id, a.username, \
|
||||
a.online, IFNULL(a.last_login, ''), \
|
||||
(SELECT COUNT(*) FROM acore_characters.characters c WHERE c.account = a.id) \
|
||||
FROM acore_auth.account a \
|
||||
WHERE a.username NOT LIKE 'COABOTHOST%' AND a.username <> 'COAMANAGER' ORDER BY a.id;";
|
||||
WHERE a.username NOT LIKE 'COABOTHOST%' AND a.username <> 'COAMANAGER' AND a.username NOT LIKE '{SQUID}%' ORDER BY a.id;";
|
||||
|
||||
/// The accounts of SQUID's random bots share a name prefix (`AiPlayerbot.RandomBotAccountPrefix`, default `rndbot`).
|
||||
/// They belong to the bot system like the companions' accounts and are never listed or touched here.
|
||||
pub fn squid_bot_prefix(root: &Path) -> String {
|
||||
std::fs::read(root.join("Core/configs/modules/playerbots.conf"))
|
||||
.ok()
|
||||
.and_then(|bytes| crate::config::parser::ConfFile::parse_bytes(&bytes).ok())
|
||||
.and_then(|conf| conf.get("AiPlayerbot.RandomBotAccountPrefix").map(|v| crate::config::parser::unquote(v).to_string()))
|
||||
.filter(|prefix| !prefix.is_empty() && prefix.len() <= 32 && prefix.chars().all(|c| c.is_ascii_alphanumeric()))
|
||||
.unwrap_or_else(|| "rndbot".into())
|
||||
}
|
||||
|
||||
/// Rows of tab-separated columns as the `mysql` client prints them.
|
||||
pub fn parse_list(out: &str) -> Vec<AccountInfo> {
|
||||
@@ -51,7 +62,7 @@ pub fn parse_list(out: &str) -> Vec<AccountInfo> {
|
||||
|
||||
pub fn list(root: &Path) -> Result<Vec<AccountInfo>> {
|
||||
let db = Db::from_repack(root, Account::Admin)?;
|
||||
Ok(parse_list(&db.query(LIST_SQL)?))
|
||||
Ok(parse_list(&db.query(&LIST_SQL.replace("{SQUID}", &squid_bot_prefix(root).to_ascii_uppercase()))?))
|
||||
}
|
||||
|
||||
fn upper(name: &str) -> Result<String> {
|
||||
@@ -64,6 +75,9 @@ fn upper(name: &str) -> Result<String> {
|
||||
pub fn rename(root: &Path, ra: &mut Ra, old: &str, new: &str, password: &str) -> Result<()> {
|
||||
let (old, new) = (upper(old)?, upper(new)?);
|
||||
validate_account(&new, password)?;
|
||||
if is_reserved(&old) || old.starts_with(&squid_bot_prefix(root).to_ascii_uppercase()) {
|
||||
return Err(Error::Invalid("This account belongs to the Manager or the bots and cannot be renamed.".into()));
|
||||
}
|
||||
if old == new {
|
||||
return Err(Error::Invalid("That is already the name of this account.".into()));
|
||||
}
|
||||
@@ -93,8 +107,8 @@ fn is_reserved(upper_name: &str) -> bool {
|
||||
/// companions' own accounts, an account that is not there and one that is logged in right now.
|
||||
pub fn delete(root: &Path, ra: &mut Ra, name: &str) -> Result<()> {
|
||||
let name = upper(name)?;
|
||||
if is_reserved(&name) {
|
||||
return Err(Error::Invalid("This account belongs to the Manager or the companions and cannot be deleted.".into()));
|
||||
if is_reserved(&name) || name.starts_with(&squid_bot_prefix(root).to_ascii_uppercase()) {
|
||||
return Err(Error::Invalid("This account belongs to the Manager or the bots and cannot be deleted.".into()));
|
||||
}
|
||||
let db = Db::from_repack(root, Account::Admin)?;
|
||||
match db.query(&format!("SELECT online FROM acore_auth.account WHERE username = '{name}';"))?.trim() {
|
||||
@@ -125,7 +139,19 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn the_internal_accounts_are_filtered_out_by_the_query() {
|
||||
assert!(LIST_SQL.contains("COABOTHOST%") && LIST_SQL.contains("COAMANAGER"));
|
||||
assert!(LIST_SQL.contains("COABOTHOST%") && LIST_SQL.contains("COAMANAGER") && LIST_SQL.contains("{SQUID}%"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_squid_bot_prefix_comes_from_the_bot_settings_and_defaults_to_rndbot() {
|
||||
let root = tempfile::tempdir().unwrap();
|
||||
assert_eq!(squid_bot_prefix(root.path()), "rndbot");
|
||||
let conf = root.path().join("Core/configs/modules/playerbots.conf");
|
||||
std::fs::create_dir_all(conf.parent().unwrap()).unwrap();
|
||||
std::fs::write(&conf, "AiPlayerbot.RandomBotAccountPrefix = \"MyBots\"\n").unwrap();
|
||||
assert_eq!(squid_bot_prefix(root.path()), "MyBots");
|
||||
std::fs::write(&conf, "AiPlayerbot.RandomBotAccountPrefix = \"x' OR 1=1 --\"\n").unwrap();
|
||||
assert_eq!(squid_bot_prefix(root.path()), "rndbot", "an unsafe prefix is ignored");
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -31,6 +31,7 @@ fn hidden(key: &str) -> bool {
|
||||
k.contains("password")
|
||||
|| k.contains("databaseinfo")
|
||||
|| k.ends_with("port")
|
||||
|| k == "console.enable"
|
||||
|| k.starts_with("ra.")
|
||||
|| k.starts_with("logger.")
|
||||
|| k.starts_with("appender.")
|
||||
@@ -229,7 +230,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn what_belongs_to_the_manager_is_hidden() {
|
||||
for k in ["LoginDatabaseInfo", "WorldServerPort", "BindIP", "Ra.Enable", "Ra.Password", "Logger.root", "Appender.Console", "DataDir", "Updates.EnableDatabases", "LoginDatabase.WorkerThreads", "InstanceServerPort"] {
|
||||
for k in ["LoginDatabaseInfo", "WorldServerPort", "BindIP", "Ra.Enable", "Ra.Password", "Console.Enable", "console.enable", "Logger.root", "Appender.Console", "DataDir", "Updates.EnableDatabases", "LoginDatabase.WorkerThreads", "InstanceServerPort"] {
|
||||
assert!(hidden(k), "{k}");
|
||||
}
|
||||
for k in ["Rate.XP.Kill", "PlayerLimit", "SupportEnabled", "Instance.ResetTimeHour", "Warden.Enabled", "CharacterCreating.Disabled"] {
|
||||
|
||||
+221
-20
@@ -51,6 +51,8 @@ pub struct Component {
|
||||
pub sha256: Option<String>,
|
||||
pub tables: Option<usize>,
|
||||
pub files: Option<Vec<String>>,
|
||||
#[serde(default)]
|
||||
pub file_sha256: std::collections::BTreeMap<String, String>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
@@ -65,12 +67,86 @@ pub struct RecoveryPoint {
|
||||
pub components: Vec<Component>,
|
||||
#[serde(default)]
|
||||
pub realm: crate::realms::Mode,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub(crate) mysql_snapshot: Option<crate::mysql_snapshot::Snapshot>,
|
||||
}
|
||||
|
||||
fn backups_dir(meta: &Path) -> PathBuf {
|
||||
const LOCATION_FILE: &str = "backup-location.json";
|
||||
|
||||
#[derive(Serialize, Deserialize)]
|
||||
struct StoredLocation {
|
||||
path: String,
|
||||
}
|
||||
|
||||
fn default_dir(meta: &Path) -> PathBuf {
|
||||
meta.join("backups")
|
||||
}
|
||||
|
||||
/// The folder the owner chose for backups (for example on another drive), if any.
|
||||
fn custom_dir(meta: &Path) -> Option<PathBuf> {
|
||||
let stored: StoredLocation = fsx::read_json(&meta.join(LOCATION_FILE)).ok()?;
|
||||
let path = PathBuf::from(stored.path.trim());
|
||||
path.is_absolute().then_some(path)
|
||||
}
|
||||
|
||||
/// Where new backups go.
|
||||
fn backups_dir(meta: &Path) -> PathBuf {
|
||||
custom_dir(meta).unwrap_or_else(|| default_dir(meta))
|
||||
}
|
||||
|
||||
/// Every folder that may hold backups: the chosen one first, then the default one, so backups made before the
|
||||
/// folder was changed stay visible and restorable.
|
||||
fn backup_roots(meta: &Path) -> Vec<PathBuf> {
|
||||
let mut roots: Vec<PathBuf> = custom_dir(meta).into_iter().collect();
|
||||
let default = default_dir(meta);
|
||||
if !roots.contains(&default) { roots.push(default); }
|
||||
roots
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize)]
|
||||
pub struct BackupLocation {
|
||||
pub path: String,
|
||||
pub default_path: String,
|
||||
pub is_default: bool,
|
||||
}
|
||||
|
||||
pub fn location(meta: &Path) -> BackupLocation {
|
||||
let default = default_dir(meta);
|
||||
let current = backups_dir(meta);
|
||||
BackupLocation { is_default: current == default, path: current.to_string_lossy().into_owned(), default_path: default.to_string_lossy().into_owned() }
|
||||
}
|
||||
|
||||
/// Choose where new backups are stored (`None` = the default folder next to the server). Existing backups stay where
|
||||
/// they are and remain listed.
|
||||
pub fn set_location(root: &Path, meta: &Path, path: Option<&str>) -> Result<BackupLocation> {
|
||||
let _lock = crate::update::operation_lock(meta)?;
|
||||
crate::update::ensure_recovered(meta)?;
|
||||
match path.map(str::trim).filter(|p| !p.is_empty()) {
|
||||
None => {
|
||||
let file = meta.join(LOCATION_FILE);
|
||||
if file.exists() { fs::remove_file(file)?; }
|
||||
}
|
||||
Some(chosen) => {
|
||||
let dir = PathBuf::from(chosen);
|
||||
if !dir.is_absolute() { return Err(Error::Invalid("Choose a full folder path, for example D:\\CoA backups.".into())); }
|
||||
if fsx::ensure_within(root, &dir).is_ok() {
|
||||
return Err(Error::Invalid("Backups cannot be stored inside the server folder: they would be part of what is being backed up.".into()));
|
||||
}
|
||||
fs::create_dir_all(&dir).map_err(|e| Error::Invalid(format!("The folder cannot be created: {e}")))?;
|
||||
let probe = dir.join(format!(".coa-write-test-{}", uuid::Uuid::new_v4().simple()));
|
||||
fs::write(&probe, b"x").map_err(|e| Error::Invalid(format!("The folder is not writable: {e}")))?;
|
||||
let _ = fs::remove_file(&probe);
|
||||
fsx::atomic_write_json(&meta.join(LOCATION_FILE), &StoredLocation { path: dir.to_string_lossy().into_owned() })?;
|
||||
}
|
||||
}
|
||||
Ok(location(meta))
|
||||
}
|
||||
|
||||
/// The `backup.json` of a recovery point, wherever its folder is.
|
||||
pub(crate) fn point_json(meta: &Path, id: &str) -> Result<PathBuf> {
|
||||
Ok(point_dir(meta, id)?.join("backup.json"))
|
||||
}
|
||||
|
||||
fn id_ok(id: &str) -> bool {
|
||||
!id.is_empty() && id.len() < 100 && id.chars().all(|c| c.is_ascii_alphanumeric() || matches!(c, '-' | '_' | '.')) && !id.contains("..")
|
||||
}
|
||||
@@ -79,19 +155,34 @@ fn point_dir(meta: &Path, id: &str) -> Result<PathBuf> {
|
||||
if !id_ok(id) {
|
||||
return Err(Error::PathRejected(format!("bad backup id {id:?}")));
|
||||
}
|
||||
if let Some(found) = backup_roots(meta).into_iter().map(|root| root.join(id)).find(|dir| dir.is_dir()) {
|
||||
return Ok(found);
|
||||
}
|
||||
Ok(backups_dir(meta).join(id))
|
||||
}
|
||||
|
||||
pub fn list(meta: &Path) -> Vec<RecoveryPoint> {
|
||||
let mut out: Vec<RecoveryPoint> = fs::read_dir(backups_dir(meta))
|
||||
.map(|rd| rd.filter_map(|e| e.ok()).filter_map(|e| fsx::read_json(&e.path().join("backup.json")).ok()).collect())
|
||||
.unwrap_or_default();
|
||||
let mut out: Vec<RecoveryPoint> = Vec::new();
|
||||
for root in backup_roots(meta) {
|
||||
let found: Vec<RecoveryPoint> = fs::read_dir(&root)
|
||||
.map(|rd| rd.filter_map(|e| e.ok()).filter_map(|e| fsx::read_json(&e.path().join("backup.json")).ok()).collect())
|
||||
.unwrap_or_default();
|
||||
for point in found {
|
||||
if !out.iter().any(|p| p.id == point.id) { out.push(point); }
|
||||
}
|
||||
}
|
||||
out.sort_by(|a, b| b.id.cmp(&a.id));
|
||||
out
|
||||
}
|
||||
|
||||
pub fn get(meta: &Path, id: &str) -> Result<RecoveryPoint> {
|
||||
fsx::read_json(&point_dir(meta, id)?.join("backup.json")).map_err(|_| Error::Invalid(format!("backup {id} was not found")))
|
||||
let dir = point_dir(meta, id)?;
|
||||
// The folder holding the backups may itself be a junction or symlink to another drive (the owner moved it there);
|
||||
// what must hold is that the recovery point stays inside that folder.
|
||||
let holder = dir.parent().ok_or_else(|| Error::PathRejected(format!("bad backup folder for {id}")))?;
|
||||
let point: RecoveryPoint = fsx::read_json(&fsx::ensure_within(holder, &dir.join("backup.json"))?).map_err(|_| Error::Invalid(format!("backup {id} was not found or its metadata is damaged")))?;
|
||||
if point.id != id || point.schema != 1 { return Err(Error::Invalid(format!("Backup {id} has inconsistent identity or an unsupported schema."))); }
|
||||
Ok(point)
|
||||
}
|
||||
|
||||
/// Files that make up "configuration": everything a user or the Manager may have changed, minus secrets.
|
||||
@@ -139,13 +230,16 @@ fn copy_configs(root: &Path, dir: &Path) -> Result<Component> {
|
||||
let files = config_files(root);
|
||||
let target = dir.join("files");
|
||||
let mut bytes = 0;
|
||||
let mut file_sha256 = std::collections::BTreeMap::new();
|
||||
for rel in &files {
|
||||
let src = fsx::safe_join(root, rel)?;
|
||||
let dst = fsx::safe_join(&target, rel)?;
|
||||
fs::create_dir_all(dst.parent().unwrap())?;
|
||||
bytes += fs::copy(&src, &dst)?;
|
||||
let content = fs::read(&src)?;
|
||||
fsx::atomic_write(&dst, &content)?;
|
||||
bytes += content.len() as u64;
|
||||
file_sha256.insert(rel.clone(), fsx::sha256_bytes(&content));
|
||||
}
|
||||
Ok(Component { name: "configs".into(), path: "files".into(), bytes, sha256: None, tables: None, files: Some(files) })
|
||||
Ok(Component { name: "configs".into(), path: "files".into(), bytes, sha256: None, tables: None, files: Some(files), file_sha256 })
|
||||
}
|
||||
|
||||
/// Make sure the database is up for `f`. If we had to start it (and nothing else is running), stop it again.
|
||||
@@ -156,19 +250,28 @@ pub fn with_database<T>(root: &Path, f: impl FnOnce(&Db) -> Result<T>) -> Result
|
||||
if !mysql_was_up {
|
||||
let out = driver::run(root, Verb::StartMysql)?;
|
||||
if !out.ok {
|
||||
return Err(Error::Invalid(out.human.map(|h| h.title.to_string()).unwrap_or_else(|| "The database could not be started.".into())));
|
||||
// Keep the launcher's own last lines: the title alone ("Something went wrong") hides the cause.
|
||||
return Err(Error::Invalid(format!("The database could not be started. {}", driver::startup_failure(root, &out))));
|
||||
}
|
||||
}
|
||||
let result = f(&db);
|
||||
if !mysql_was_up {
|
||||
let now = process::observe(root, &read_ports(root));
|
||||
if now.world.state == ServiceState::Stopped && now.auth.state == ServiceState::Stopped {
|
||||
if now.world.state == ServiceState::Stopped && now.auth.state == ServiceState::Stopped && !crate::multiworld::is_running(root) {
|
||||
let _ = driver::run(root, Verb::StopAll);
|
||||
}
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
/// Run `f` only if the database is already up; `None` (and nothing started) otherwise.
|
||||
pub fn with_running_database<T>(root: &Path, f: impl FnOnce(&Db) -> Result<T>) -> Result<Option<T>> {
|
||||
let db = Db::from_repack(root, Account::Admin)?;
|
||||
let observed = process::observe(root, &read_ports(root));
|
||||
if observed.mysql.state != ServiceState::Running || !db.ping() { return Ok(None); }
|
||||
f(&db).map(Some)
|
||||
}
|
||||
|
||||
fn wanted_databases(kind: Kind) -> &'static [&'static str] {
|
||||
match kind {
|
||||
Kind::Quick | Kind::Database => &["characters", "auth"],
|
||||
@@ -179,7 +282,7 @@ fn wanted_databases(kind: Kind) -> &'static [&'static str] {
|
||||
|
||||
/// Create a recovery point. The server may be running: dumps are consistent snapshots (`--single-transaction`).
|
||||
pub fn create(root: &Path, meta: &Path, kind: Kind, trigger: Trigger, label: Option<String>, progress: &dyn Fn(&str)) -> Result<RecoveryPoint> {
|
||||
let id = format!("{}-{}", chrono::Utc::now().format("%Y%m%d-%H%M%S"), match trigger {
|
||||
let id = format!("{}-{}-{}", chrono::Utc::now().format("%Y%m%d-%H%M%S"), match trigger {
|
||||
Trigger::Manual => "manual",
|
||||
Trigger::Automatic => "auto",
|
||||
Trigger::BeforeUpdate => "before-update",
|
||||
@@ -188,7 +291,7 @@ pub fn create(root: &Path, meta: &Path, kind: Kind, trigger: Trigger, label: Opt
|
||||
Trigger::BeforeBots => "before-bots",
|
||||
Trigger::BeforeRepair => "before-repair",
|
||||
Trigger::BeforeDangerousChange => "before-change",
|
||||
});
|
||||
}, uuid::Uuid::new_v4().simple());
|
||||
let final_dir = point_dir(meta, &id)?;
|
||||
let partial = backups_dir(meta).join(format!("{id}.partial"));
|
||||
fs::create_dir_all(&partial)?;
|
||||
@@ -203,6 +306,9 @@ pub fn create(root: &Path, meta: &Path, kind: Kind, trigger: Trigger, label: Opt
|
||||
databases.push((format!("{}-characters", other.name()), other.schema("characters")?));
|
||||
if kind == Kind::Full { databases.push((format!("{}-world", other.name()), other.schema("world")?)); }
|
||||
}
|
||||
if kind != Kind::Config && with_database(root, |db| db.schema_exists("acore_playerbots"))? {
|
||||
databases.push(("playerbots".into(), "acore_playerbots"));
|
||||
}
|
||||
for (name, schema) in databases {
|
||||
progress(&format!("Backing up {name} database"));
|
||||
let component = with_database(root, |db| {
|
||||
@@ -212,7 +318,7 @@ pub fn create(root: &Path, meta: &Path, kind: Kind, trigger: Trigger, label: Opt
|
||||
let tables = db.tables(schema)?.len();
|
||||
let file = format!("{name}.sql.zst");
|
||||
let (bytes, sha) = db.dump_to(schema, &partial.join(&file))?;
|
||||
Ok(Component { name, path: file, bytes, sha256: Some(sha), tables: Some(tables), files: None })
|
||||
Ok(Component { name, path: file, bytes, sha256: Some(sha), tables: Some(tables), files: None, file_sha256: Default::default() })
|
||||
})?;
|
||||
components.push(component);
|
||||
}
|
||||
@@ -230,6 +336,16 @@ pub fn create(root: &Path, meta: &Path, kind: Kind, trigger: Trigger, label: Opt
|
||||
return Err(e);
|
||||
}
|
||||
};
|
||||
let mysql_snapshot = if kind == Kind::Full && trigger == Trigger::BeforeUpdate && cfg!(windows) && !crate::docker::is_docker(root) {
|
||||
progress("Saving a complete stopped MySQL recovery copy");
|
||||
match crate::mysql_snapshot::capture(root, &partial) {
|
||||
Ok(snapshot) => Some(snapshot),
|
||||
Err(error) => {
|
||||
if let Ok(owned) = fsx::ensure_within(&backups_dir(meta), &partial) { let _ = fs::remove_dir_all(owned); }
|
||||
return Err(error);
|
||||
}
|
||||
}
|
||||
} else { None };
|
||||
let point = RecoveryPoint {
|
||||
realm: crate::realms::state(root)?.active,
|
||||
schema: 1,
|
||||
@@ -240,6 +356,7 @@ pub fn create(root: &Path, meta: &Path, kind: Kind, trigger: Trigger, label: Opt
|
||||
created_at: chrono::Utc::now().to_rfc3339(),
|
||||
manager_version: crate::MANAGER_VERSION.into(),
|
||||
components,
|
||||
mysql_snapshot,
|
||||
};
|
||||
fsx::atomic_write_json(&partial.join("backup.json"), &point)?;
|
||||
fs::rename(&partial, &final_dir)?;
|
||||
@@ -252,6 +369,7 @@ pub fn create(root: &Path, meta: &Path, kind: Kind, trigger: Trigger, label: Opt
|
||||
|
||||
/// Keep the newest `keep` automatic recovery points; manual and safety ones are never pruned.
|
||||
pub fn prune_automatic(meta: &Path, keep: usize) {
|
||||
if crate::update::ensure_recovered(meta).is_err() { return; }
|
||||
let autos: Vec<_> = list(meta).into_iter().filter(|p| p.trigger == Trigger::Automatic).collect();
|
||||
for p in autos.into_iter().skip(keep) {
|
||||
if let Ok(dir) = point_dir(meta, &p.id) {
|
||||
@@ -270,8 +388,24 @@ pub fn verify(meta: &Path, id: &str) -> Result<VerifyReport> {
|
||||
let point = get(meta, id)?;
|
||||
let dir = point_dir(meta, id)?;
|
||||
let mut problems = Vec::new();
|
||||
if let Some(snapshot) = &point.mysql_snapshot {
|
||||
if let Err(error) = crate::mysql_snapshot::verify(&dir, snapshot) { problems.push(error.to_string()); }
|
||||
}
|
||||
let mut names = std::collections::BTreeSet::new();
|
||||
let mut schemas = std::collections::BTreeSet::new();
|
||||
for c in &point.components {
|
||||
let path = dir.join(&c.path);
|
||||
if !names.insert(&c.name) { problems.push(format!("{} appears more than once", c.name)); }
|
||||
let path = fsx::ensure_within(&dir, &fsx::safe_join(&dir, &c.path)?)?;
|
||||
if c.name != "configs" && (c.sha256.is_none() || c.tables.is_none()) { problems.push(format!("{} lacks database integrity metadata", c.name)); }
|
||||
if c.name == "configs" {
|
||||
if c.sha256.is_some() || c.files.is_none() { problems.push("configuration integrity metadata is inconsistent".into()); }
|
||||
} else {
|
||||
let schema = if c.name.contains('-') || c.name == "playerbots" { db::schema_of(&c.name) } else { point.realm.schema(&c.name) };
|
||||
match schema {
|
||||
Ok(schema) if schemas.insert(schema) => {}
|
||||
_ => problems.push(format!("{} has an unknown or duplicate database target", c.name)),
|
||||
}
|
||||
}
|
||||
match (&c.sha256, &c.files) {
|
||||
(Some(sha), _) => match fsx::sha256_file(&path) {
|
||||
Ok(actual) if actual.eq_ignore_ascii_case(sha) => {}
|
||||
@@ -280,12 +414,16 @@ pub fn verify(meta: &Path, id: &str) -> Result<VerifyReport> {
|
||||
},
|
||||
(None, Some(files)) => {
|
||||
for f in files {
|
||||
if !c.file_sha256.is_empty() && !c.file_sha256.contains_key(f) { problems.push(format!("configuration file {f} lacks its checksum")); }
|
||||
if !fsx::safe_join(&path, f).map(|p| p.is_file()).unwrap_or(false) {
|
||||
problems.push(format!("configuration file {f} is missing"));
|
||||
} else if let Some(expected) = c.file_sha256.get(f) {
|
||||
let file = fsx::ensure_within(&dir, &fsx::safe_join(&path, f)?)?;
|
||||
if fsx::sha256_file(&file)?.as_str() != expected { problems.push(format!("configuration file {f} is damaged")); }
|
||||
}
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
_ => problems.push(format!("{} lacks an integrity inventory", c.name)),
|
||||
}
|
||||
}
|
||||
Ok(VerifyReport { ok: problems.is_empty(), problems })
|
||||
@@ -293,6 +431,11 @@ pub fn verify(meta: &Path, id: &str) -> Result<VerifyReport> {
|
||||
|
||||
/// Delete one recovery point (its own folder only).
|
||||
pub fn delete(meta: &Path, id: &str) -> Result<()> {
|
||||
let _lock = crate::update::operation_lock(meta)?;
|
||||
crate::update::ensure_recovered(meta)?;
|
||||
if crate::update::unfinished(meta).is_some_and(|t| t.recovery_point.as_deref() == Some(id)) {
|
||||
return Err(Error::Invalid("This recovery point is required by an unfinished update and cannot be deleted.".into()));
|
||||
}
|
||||
let dir = point_dir(meta, id)?;
|
||||
get(meta, id)?; // must be a real recovery point
|
||||
fs::remove_dir_all(dir)?;
|
||||
@@ -338,13 +481,13 @@ pub fn restore_database(root: &Path, meta: &Path, id: &str, name: &str) -> Resul
|
||||
return Err(Error::Invalid("This backup is damaged and cannot be restored.".into()));
|
||||
}
|
||||
let now = process::observe(root, &read_ports(root));
|
||||
if now.world.state != ServiceState::Stopped || now.auth.state != ServiceState::Stopped {
|
||||
if now.world.state != ServiceState::Stopped || now.auth.state != ServiceState::Stopped || crate::multiworld::is_running(root) {
|
||||
return Err(Error::Invalid("Stop the server before restoring a database.".into()));
|
||||
}
|
||||
let live = if name.contains('-') { db::schema_of(name)? } else { point.realm.schema(name)? };
|
||||
let live = if name.contains('-') || name == "playerbots" { db::schema_of(name)? } else { point.realm.schema(name)? };
|
||||
let expected_tables = comp.tables.unwrap_or(0);
|
||||
let dump = point_dir(meta, id)?.join(&comp.path);
|
||||
let stamp = chrono::Utc::now().format("%Y%m%d%H%M%S").to_string();
|
||||
let stamp = uuid::Uuid::new_v4().simple().to_string()[..16].to_string();
|
||||
|
||||
// 1. Safety copy of the current state, so even a wrong restore is reversible.
|
||||
let safety = create(root, meta, Kind::Database, Trigger::BeforeRestore, Some(format!("before restoring {name} from {id}")), &|_| {})?;
|
||||
@@ -361,7 +504,7 @@ pub fn restore_database(root: &Path, meta: &Path, id: &str, name: &str) -> Resul
|
||||
db.import_from(&staging, &dump)?;
|
||||
// 3. Sanity checks.
|
||||
let staged = db.tables(&staging)?;
|
||||
if staged.is_empty() || (expected_tables > 0 && staged.len() != expected_tables) {
|
||||
if comp.tables.is_some_and(|expected| staged.len() != expected) || (comp.tables.is_none() && staged.is_empty()) {
|
||||
return Err(Error::Invalid(format!("The restored copy looks incomplete ({} of {expected_tables} tables); nothing was changed.", staged.len())));
|
||||
}
|
||||
if db.extra_objects(&staging)? > 0 || db.extra_objects(live)? > 0 {
|
||||
@@ -377,7 +520,7 @@ pub fn restore_database(root: &Path, meta: &Path, id: &str, name: &str) -> Resul
|
||||
for t in &staged {
|
||||
renames.push(format!("`{staging}`.`{t}` TO `{live}`.`{t}`"));
|
||||
}
|
||||
db.query(&format!("RENAME TABLE {};", renames.join(", ")))?;
|
||||
if !renames.is_empty() { db.query(&format!("RENAME TABLE {};", renames.join(", ")))?; }
|
||||
Ok(DbRestore { previous_schema: old, safety_backup: safety.id.clone(), tables_restored: staged.len() })
|
||||
})
|
||||
}
|
||||
@@ -399,6 +542,36 @@ mod tests {
|
||||
(dir, root, meta)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn backup_deletion_obeys_the_installation_lock() {
|
||||
let (_d, root, meta) = setup();
|
||||
let point = create(&root, &meta, Kind::Config, Trigger::Manual, None, &|_| {}).unwrap();
|
||||
let lock = crate::update::operation_lock(&meta).unwrap();
|
||||
assert!(delete(&meta, &point.id).is_err());
|
||||
assert!(get(&meta, &point.id).is_ok());
|
||||
drop(lock);
|
||||
delete(&meta, &point.id).unwrap();
|
||||
assert!(get(&meta, &point.id).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn damaged_configuration_is_detected_before_restore_and_copies_are_retained() {
|
||||
let (_d, root, meta) = setup();
|
||||
let point = create(&root, &meta, Kind::Config, Trigger::Automatic, None, &|_| {}).unwrap();
|
||||
let file = point_dir(&meta, &point.id).unwrap().join("files/Core/configs/worldserver.conf");
|
||||
fs::write(&file, b"corrupted").unwrap();
|
||||
assert!(!verify(&meta, &point.id).unwrap().ok);
|
||||
let original = fs::read(root.join("Core/configs/worldserver.conf")).unwrap();
|
||||
assert!(restore_configs(&root, &meta, &point.id).is_err());
|
||||
assert_eq!(fs::read(root.join("Core/configs/worldserver.conf")).unwrap(), original);
|
||||
assert_eq!(list(&meta).len(), 1);
|
||||
fs::create_dir_all(meta.join("updates/broken")).unwrap();
|
||||
fs::write(meta.join("updates/broken/txn.json"), b"{damaged").unwrap();
|
||||
assert!(delete(&meta, &point.id).is_err());
|
||||
prune_automatic(&meta, 0);
|
||||
assert!(file.exists());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn config_backup_excludes_secrets_and_clutter_and_restores_byte_exact() {
|
||||
let (_d, root, meta) = setup();
|
||||
@@ -427,6 +600,34 @@ mod tests {
|
||||
assert!(list(&meta).len() >= 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn backups_can_live_in_a_chosen_folder_and_old_ones_stay_visible() {
|
||||
let (d, root, meta) = setup();
|
||||
let before = create(&root, &meta, Kind::Config, Trigger::Manual, Some("default folder".into()), &|_| {}).unwrap();
|
||||
assert!(location(&meta).is_default);
|
||||
|
||||
// inside the server folder is refused, a relative path is refused
|
||||
assert!(set_location(&root, &meta, Some(root.join("backups").to_str().unwrap())).is_err());
|
||||
assert!(set_location(&root, &meta, Some("backups")).is_err());
|
||||
|
||||
let elsewhere = d.path().join("other drive").join("CoA backups");
|
||||
let loc = set_location(&root, &meta, Some(elsewhere.to_str().unwrap())).unwrap();
|
||||
assert!(!loc.is_default && elsewhere.is_dir());
|
||||
let after = create(&root, &meta, Kind::Config, Trigger::Manual, Some("chosen folder".into()), &|_| {}).unwrap();
|
||||
assert!(elsewhere.join(&after.id).join("backup.json").is_file(), "new backups go to the chosen folder");
|
||||
assert!(!default_dir(&meta).join(&after.id).exists());
|
||||
let ids: Vec<_> = list(&meta).into_iter().map(|p| p.id).collect();
|
||||
assert!(ids.contains(&before.id) && ids.contains(&after.id), "the old backup is still listed");
|
||||
assert!(verify(&meta, &before.id).unwrap().ok && verify(&meta, &after.id).unwrap().ok);
|
||||
assert_eq!(point_json(&meta, &after.id).unwrap(), elsewhere.join(&after.id).join("backup.json"));
|
||||
restore_configs(&root, &meta, &after.id).unwrap();
|
||||
delete(&meta, &after.id).unwrap();
|
||||
assert!(!elsewhere.join(&after.id).exists());
|
||||
|
||||
assert!(set_location(&root, &meta, None).unwrap().is_default);
|
||||
assert!(list(&meta).iter().any(|p| p.id == before.id));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn verify_detects_tampering_and_restore_refuses_damaged_backup() {
|
||||
let (_d, root, meta) = setup();
|
||||
|
||||
@@ -0,0 +1,86 @@
|
||||
//! Signed channel pointers select one immutable package for an entire transaction.
|
||||
use serde::{Deserialize, Serialize};
|
||||
use crate::{Error, Result};
|
||||
use crate::pkgsource::{fetch_small, Source};
|
||||
|
||||
#[derive(Debug, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "camelCase", deny_unknown_fields)]
|
||||
pub struct Pointer {
|
||||
pub schema: u32,
|
||||
pub channel: String,
|
||||
pub version: String,
|
||||
pub release_tag: String,
|
||||
pub snapshot: String,
|
||||
}
|
||||
|
||||
#[derive(Deserialize, Serialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct Envelope {
|
||||
pub payload: String,
|
||||
pub signature: String,
|
||||
}
|
||||
|
||||
pub fn verify(bytes: &[u8], channel: &str, key: &str) -> Result<Pointer> {
|
||||
let envelope: Envelope = serde_json::from_slice(bytes).map_err(|e| Error::InvalidManifest(e.to_string()))?;
|
||||
crate::signing::verify(envelope.payload.as_bytes(), &envelope.signature, key)?;
|
||||
let pointer: Pointer = serde_json::from_str(&envelope.payload).map_err(|e| Error::InvalidManifest(e.to_string()))?;
|
||||
if pointer.schema != 1 || pointer.channel != channel
|
||||
|| pointer.release_tag != format!("server-{}", pointer.version)
|
||||
|| pointer.version.is_empty()
|
||||
|| !pointer.version.bytes().all(|b| b.is_ascii_digit() || b == b'.')
|
||||
|| pointer.snapshot.len() != 64
|
||||
|| !pointer.snapshot.bytes().all(|b| b.is_ascii_hexdigit()) {
|
||||
return Err(Error::InvalidManifest("Invalid channel pointer".into()));
|
||||
}
|
||||
Ok(pointer)
|
||||
}
|
||||
|
||||
pub fn resolve(channel: &str) -> Result<Source> {
|
||||
if channel != "stable" && channel != "edge" {
|
||||
return Err(Error::InvalidManifest("Unknown release channel".into()));
|
||||
}
|
||||
let source = Source::Url("https://raw.githubusercontent.com/Corfirean/coa-server-build/channels".into());
|
||||
let bytes = fetch_small(&source, &format!("{channel}.json"))?;
|
||||
let pointer = verify(&bytes, channel, crate::signing::EMBEDDED_PUBLIC_KEY)?;
|
||||
Ok(Source::Url(format!("https://github.com/Corfirean/coa-server-build/releases/download/{}", pointer.release_tag)))
|
||||
}
|
||||
|
||||
pub fn sign(pointer: &Pointer, seed: &str) -> Result<Vec<u8>> {
|
||||
use base64::{engine::general_purpose::STANDARD, Engine};
|
||||
use ed25519_dalek::{Signer, SigningKey};
|
||||
let seed: [u8; 32] = STANDARD.decode(seed.trim()).map_err(|_| Error::Invalid("Invalid signing key".into()))?
|
||||
.try_into().map_err(|_| Error::Invalid("Invalid signing key length".into()))?;
|
||||
let payload = serde_json::to_string(pointer).map_err(|e| Error::Invalid(e.to_string()))?;
|
||||
let signature = STANDARD.encode(SigningKey::from_bytes(&seed).sign(payload.as_bytes()).to_bytes());
|
||||
let bytes = serde_json::to_vec(&Envelope { payload, signature }).map_err(|e| Error::Invalid(e.to_string()))?;
|
||||
verify(&bytes, &pointer.channel, crate::signing::EMBEDDED_PUBLIC_KEY)?;
|
||||
Ok(bytes)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use base64::{engine::general_purpose::STANDARD, Engine};
|
||||
use ed25519_dalek::{Signer, SigningKey};
|
||||
|
||||
fn signed(pointer: &Pointer) -> (Vec<u8>, String) {
|
||||
let sk = SigningKey::from_bytes(&[17; 32]);
|
||||
let payload = serde_json::to_string(pointer).unwrap();
|
||||
let signature = STANDARD.encode(sk.sign(payload.as_bytes()).to_bytes());
|
||||
(serde_json::to_vec(&Envelope { payload, signature }).unwrap(), STANDARD.encode(sk.verifying_key().to_bytes()))
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn verifies_identity_signature_and_immutable_tag() {
|
||||
let mut p = Pointer { schema: 1, channel: "stable".into(), version: "0.261010.40".into(), release_tag: "server-0.261010.40".into(), snapshot: "a".repeat(64) };
|
||||
let (bytes, key) = signed(&p);
|
||||
assert_eq!(verify(&bytes, "stable", &key).unwrap().version, p.version);
|
||||
assert!(verify(&bytes, "edge", &key).is_err());
|
||||
let mut changed: Envelope = serde_json::from_slice(&bytes).unwrap();
|
||||
changed.payload = changed.payload.replace("40", "41");
|
||||
assert!(verify(&serde_json::to_vec(&changed).unwrap(), "stable", &key).is_err());
|
||||
p.release_tag = "stable".into();
|
||||
let (bytes, key) = signed(&p);
|
||||
assert!(verify(&bytes, "stable", &key).is_err());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,170 @@
|
||||
{
|
||||
"character_inventory": [
|
||||
"guid",
|
||||
"bag",
|
||||
"slot",
|
||||
"item"
|
||||
],
|
||||
"characters": [
|
||||
"guid",
|
||||
"account",
|
||||
"name",
|
||||
"race",
|
||||
"class",
|
||||
"gender",
|
||||
"level",
|
||||
"xp",
|
||||
"money",
|
||||
"skin",
|
||||
"face",
|
||||
"hairStyle",
|
||||
"hairColor",
|
||||
"facialStyle",
|
||||
"bankSlots",
|
||||
"restState",
|
||||
"playerFlags",
|
||||
"map",
|
||||
"instance_id",
|
||||
"instance_mode_mask",
|
||||
"position_x",
|
||||
"position_y",
|
||||
"position_z",
|
||||
"orientation",
|
||||
"trans_x",
|
||||
"trans_y",
|
||||
"trans_z",
|
||||
"trans_o",
|
||||
"transguid",
|
||||
"taximask",
|
||||
"cinematic",
|
||||
"totaltime",
|
||||
"leveltime",
|
||||
"rest_bonus",
|
||||
"logout_time",
|
||||
"is_logout_resting",
|
||||
"resettalents_cost",
|
||||
"resettalents_time",
|
||||
"extra_flags",
|
||||
"stable_slots",
|
||||
"at_login",
|
||||
"zone",
|
||||
"death_expire_time",
|
||||
"taxi_path",
|
||||
"arenaPoints",
|
||||
"totalHonorPoints",
|
||||
"todayHonorPoints",
|
||||
"yesterdayHonorPoints",
|
||||
"totalKills",
|
||||
"todayKills",
|
||||
"yesterdayKills",
|
||||
"chosenTitle",
|
||||
"knownCurrencies",
|
||||
"watchedFaction",
|
||||
"drunk",
|
||||
"health",
|
||||
"power1",
|
||||
"power2",
|
||||
"power3",
|
||||
"power4",
|
||||
"power5",
|
||||
"power6",
|
||||
"power7",
|
||||
"latency",
|
||||
"talentGroupsCount",
|
||||
"activeTalentGroup",
|
||||
"exploredZones",
|
||||
"equipmentCache",
|
||||
"ammoId",
|
||||
"knownTitles",
|
||||
"actionBars",
|
||||
"grantableLevels",
|
||||
"innTriggerId",
|
||||
"extraBonusTalentCount"
|
||||
],
|
||||
"character_spell": [
|
||||
"guid",
|
||||
"spell",
|
||||
"specMask"
|
||||
],
|
||||
"character_skills": [
|
||||
"guid",
|
||||
"skill",
|
||||
"value",
|
||||
"max"
|
||||
],
|
||||
"character_homebind": [
|
||||
"guid",
|
||||
"mapId",
|
||||
"zoneId",
|
||||
"posX",
|
||||
"posY",
|
||||
"posZ"
|
||||
],
|
||||
"character_reputation": [
|
||||
"guid",
|
||||
"faction",
|
||||
"standing",
|
||||
"flags"
|
||||
],
|
||||
"character_action": [
|
||||
"guid",
|
||||
"spec",
|
||||
"button",
|
||||
"action",
|
||||
"type"
|
||||
],
|
||||
"character_talent": [
|
||||
"guid",
|
||||
"spell",
|
||||
"specMask"
|
||||
],
|
||||
"item_instance": [
|
||||
"itemEntry",
|
||||
"owner_guid",
|
||||
"creatorGuid",
|
||||
"giftCreatorGuid",
|
||||
"count",
|
||||
"duration",
|
||||
"charges",
|
||||
"flags",
|
||||
"enchantments",
|
||||
"randomPropertyId",
|
||||
"durability",
|
||||
"playedTime",
|
||||
"text",
|
||||
"guid"
|
||||
],
|
||||
"character_stats": [
|
||||
"guid",
|
||||
"maxhealth",
|
||||
"maxpower1",
|
||||
"maxpower2",
|
||||
"maxpower3",
|
||||
"maxpower4",
|
||||
"maxpower5",
|
||||
"maxpower6",
|
||||
"maxpower7",
|
||||
"strength",
|
||||
"agility",
|
||||
"stamina",
|
||||
"intellect",
|
||||
"spirit",
|
||||
"armor",
|
||||
"resHoly",
|
||||
"resFire",
|
||||
"resNature",
|
||||
"resFrost",
|
||||
"resShadow",
|
||||
"resArcane",
|
||||
"blockPct",
|
||||
"dodgePct",
|
||||
"parryPct",
|
||||
"critPct",
|
||||
"rangedCritPct",
|
||||
"spellCritPct",
|
||||
"attackPower",
|
||||
"rangedAttackPower",
|
||||
"spellPower",
|
||||
"resilience"
|
||||
]
|
||||
}
|
||||
@@ -10,7 +10,7 @@ use crate::backup;
|
||||
use crate::error::{Error, Result};
|
||||
use crate::fsx;
|
||||
use crate::migrations::{apply_pending, status, Status};
|
||||
use crate::release::{collect_bots_sql, collect_core_sql};
|
||||
use crate::release::{collect_bots_sql, collect_core_install_sql};
|
||||
|
||||
pub struct Params<'a> {
|
||||
pub repack: &'a Path,
|
||||
@@ -177,11 +177,11 @@ pub fn build(p: &Params, say: &dyn Fn(&str)) -> Result<()> {
|
||||
}
|
||||
fsx::atomic_write_json(&repack_json, &cfg)?;
|
||||
|
||||
let mut sql = collect_core_sql(p.core)?;
|
||||
let mut sql = collect_core_install_sql(p.core)?;
|
||||
if let Some(b) = p.bots {
|
||||
sql.extend(collect_bots_sql(b)?);
|
||||
}
|
||||
let migrations: Vec<_> = sql.iter().map(|f| crate::manifest::Migration { id: f.id.clone(), db: f.db.clone(), sha256: f.sha256.clone(), destructive: false }).collect();
|
||||
let migrations: Vec<_> = sql.iter().map(|f| crate::manifest::Migration { compatible_sha256: vec![], id: f.id.clone(), db: f.db.clone(), sha256: f.sha256.clone(), destructive: false }).collect();
|
||||
let staging = std::env::temp_dir().join("coa-cleanbase-sql");
|
||||
let _ = fs::remove_dir_all(&staging);
|
||||
for f in &sql {
|
||||
@@ -218,12 +218,17 @@ pub fn build(p: &Params, say: &dyn Fn(&str)) -> Result<()> {
|
||||
db.query(&sql)?;
|
||||
// 2. characters: a brand-new schema from the core's base scripts
|
||||
db.query("DROP DATABASE IF EXISTS `acore_characters`; CREATE DATABASE `acore_characters` CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;")?;
|
||||
// The ledger lives in world, so dropping characters does not clear its migration history.
|
||||
// Never carry that history into a freshly rebuilt character database.
|
||||
if db.tables("acore_world")?.iter().any(|t| t == "coa_manager_migrations") {
|
||||
db.query("DELETE FROM acore_world.coa_manager_migrations WHERE `db`='characters';")?;
|
||||
}
|
||||
for f in &base_chars {
|
||||
db.run_sql_file("acore_characters", f)?;
|
||||
}
|
||||
// 3. every migration up to the core commit (already-recorded ones are skipped)
|
||||
let before = status(db, &migrations)?;
|
||||
let pending: Vec<_> = migrations.iter().zip(&before).filter(|(_, i)| i.status == Status::Pending).map(|(m, _)| m.clone()).collect();
|
||||
let pending: Vec<_> = migrations.iter().zip(&before).filter(|(_, i)| i.status != Status::Applied).map(|(m, _)| m.clone()).collect();
|
||||
say(&format!("Applying {} database updates", pending.len()));
|
||||
let report = apply_pending(db, &pending, &staging, &|| Ok("(scratch database)".into()))?;
|
||||
if let Some((id, why)) = report.failed {
|
||||
@@ -251,6 +256,10 @@ pub fn build(p: &Params, say: &dyn Fn(&str)) -> Result<()> {
|
||||
if accounts != "0" || chars != "0" || templates != 21 {
|
||||
return Err(Error::Invalid(format!("The database is not clean ({accounts} accounts, {chars} player characters, {templates} templates).")));
|
||||
}
|
||||
if let Some(p) = crate::schema_check::check(db, p.tree)?.first() {
|
||||
return Err(Error::Invalid(format!("The rebuilt base database is incomplete: {}.{}.{}: {}", p.database, p.table, p.column, p.detail)));
|
||||
}
|
||||
crate::schema_check::capture(db, out)?;
|
||||
Ok(())
|
||||
})?;
|
||||
|
||||
@@ -270,7 +279,7 @@ pub fn build(p: &Params, say: &dyn Fn(&str)) -> Result<()> {
|
||||
fsx::atomic_write_json(&repack_json, &shipped)?;
|
||||
|
||||
say("Adding the release files");
|
||||
copy_dir(p.tree, p.out, &|_| false, p.tree)?;
|
||||
copy_dir(p.tree, p.out, &|rel| rel == crate::schema_check::CONTRACT, p.tree)?;
|
||||
if let Some(data) = p.data {
|
||||
say("Copying game data");
|
||||
fs::create_dir_all(p.out.join("Data"))?;
|
||||
@@ -285,7 +294,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn scaffolding_keeps_the_launcher_and_drops_runtime_state_and_live_data() {
|
||||
for keep in ["Runtime/python/python.exe", "Scripts/manage.py", "Settings/worldserver.conf.template", "mysql/bin/mysqld.exe", "mysql/share/english/errmsg.sys", "BugReport/relay.py", "Core/libssl-3-x64.dll", "README.txt"] {
|
||||
for keep in ["Runtime/python/python.exe", "Scripts/manage.py", "Settings/worldserver.conf.template", "mysql/bin/mysqld.exe", "mysql/share/english/errmsg.sys", "mysql/lib/private/icudt.dat", "BugReport/relay.py", "Core/libssl-3-x64.dll", "README.txt"] {
|
||||
assert!(scaffolding(keep), "{keep}");
|
||||
}
|
||||
for drop in [".state/world.json", "mysql/data/acore_world/x.ibd", "mysql/logs/error.log", "Core/worldserver.exe", "Core/Logs/Server.log", "BugReport/reports/a.json", "Source/server-source.zip", "Scripts/__pycache__/x.pyc", "Testing/notes.md", "mysql/data.7z"] {
|
||||
|
||||
@@ -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);
|
||||
@@ -180,7 +183,7 @@ fn backup_dir(meta: &Path) -> PathBuf {
|
||||
meta.join("backups").join("client")
|
||||
}
|
||||
|
||||
fn host_ok(h: &str) -> bool {
|
||||
pub fn host_ok(h: &str) -> bool {
|
||||
!h.is_empty() && h.len() <= 253 && h.chars().all(|c| c.is_ascii_alphanumeric() || matches!(c, '.' | '-' | ':')) && !h.starts_with('-')
|
||||
}
|
||||
|
||||
@@ -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"));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,858 @@
|
||||
//! Management of client-side patches and assets for Custom Races.
|
||||
//!
|
||||
//! Handles detecting, enabling/disabling (via `.disabled` extension renaming),
|
||||
//! and downloading/extracting client patches (Esteria and additional races)
|
||||
//! into the player's WoW client directory.
|
||||
|
||||
use std::fs::{self, File};
|
||||
use std::io::{self, Read, Write};
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::download::Cancel;
|
||||
use crate::error::{Error, Result};
|
||||
use crate::fsx;
|
||||
|
||||
pub const CLIENT_VERSION: &str = "1.5";
|
||||
pub const MANIFEST_FILENAME: &str = "custom_races_patch_manifest.txt";
|
||||
pub const ARCHIVES: &[(&str, &str)] = &[
|
||||
(
|
||||
"CoA-Custom-1.5-main-20261009-cb2a0ca4.zip",
|
||||
"https://github.com/ilusixn/azerothcore-wotlk-coa/releases/download/coa-custom-1.5/CoA-Custom-1.5-main-20261009-cb2a0ca4.zip",
|
||||
),
|
||||
(
|
||||
"CoA-Custom-1.5-client-part1.zip",
|
||||
"https://github.com/ilusixn/azerothcore-wotlk-coa/releases/download/coa-custom-1.5/CoA-Custom-1.5-client-part1.zip",
|
||||
),
|
||||
(
|
||||
"CoA-Custom-1.5-client-part2.zip",
|
||||
"https://github.com/ilusixn/azerothcore-wotlk-coa/releases/download/coa-custom-1.5/CoA-Custom-1.5-client-part2.zip",
|
||||
),
|
||||
];
|
||||
|
||||
pub const RACE_MPQS: &[&str] = &[
|
||||
"patch-T.MPQ",
|
||||
"patch-ZE1.MPQ",
|
||||
"patch-ZE2.MPQ",
|
||||
"patch-ZE3.MPQ",
|
||||
"patch-ZE5.MPQ",
|
||||
"patch-ZE6.MPQ",
|
||||
"patch-ZE7.MPQ",
|
||||
"patch-ZE8.MPQ",
|
||||
"patch-ZE9.MPQ",
|
||||
"patch-ZEA.MPQ",
|
||||
"patch-ZG.MPQ",
|
||||
"patch-ZH.MPQ",
|
||||
"patch-ZHA.MPQ",
|
||||
"patch-ZHM.MPQ",
|
||||
"patch-ZM.MPQ",
|
||||
"patch-ZVU.MPQ",
|
||||
"patch-ZES.MPQ",
|
||||
"patch-ZJ.MPQ",
|
||||
"patch-ZZE.MPQ",
|
||||
"patch-ZZR.MPQ",
|
||||
];
|
||||
|
||||
pub const EXCLUDED_BOT_RACES_RECOMMENDED: &str =
|
||||
"19,27,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128";
|
||||
|
||||
pub const EXCLUDED_BOT_RACES_EXPERIMENTAL: &str =
|
||||
"16,19,27,32,50,52,53,65,66,67,68,69,70,71,72,74,77,80,81";
|
||||
|
||||
/// Finds all active playerbots.conf files on this server (root, coa-bots folder, and secondary realm).
|
||||
pub fn playerbots_conf_paths(root: &Path) -> Vec<PathBuf> {
|
||||
let mut paths = Vec::new();
|
||||
let candidates = [
|
||||
root.join("Core/configs/modules/playerbots.conf"),
|
||||
root.join("coa-bots/Core/configs/modules/playerbots.conf"),
|
||||
root.join("coa-bots/core/configs/modules/playerbots.conf"),
|
||||
crate::multiworld::root(root).join("Core/configs/modules/playerbots.conf"),
|
||||
];
|
||||
for path in candidates {
|
||||
if path.is_file() {
|
||||
paths.push(path);
|
||||
}
|
||||
}
|
||||
if paths.is_empty() {
|
||||
for dist in [
|
||||
root.join("Core/configs/modules/playerbots.conf.dist"),
|
||||
root.join("coa-bots/Core/configs/modules/playerbots.conf.dist"),
|
||||
] {
|
||||
if dist.is_file() {
|
||||
let target = dist.with_extension("");
|
||||
if fs::copy(&dist, &target).is_ok() {
|
||||
paths.push(target);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
paths
|
||||
}
|
||||
|
||||
/// Checks whether playerbots are configured to allow custom races.
|
||||
/// Returns true if AiPlayerbot.ExcludedBotRaces exists and does not exclude general custom races.
|
||||
pub fn is_bot_custom_races_allowed(root: &Path) -> Option<bool> {
|
||||
for path in playerbots_conf_paths(root) {
|
||||
if let Ok(bytes) = fs::read(&path) {
|
||||
if let Ok(conf) = crate::config::parser::ConfFile::parse_bytes(&bytes) {
|
||||
if let Some(val) = conf.get("AiPlayerbot.ExcludedBotRaces") {
|
||||
let clean = val.trim().trim_matches(['"', '\'']);
|
||||
return Some(!clean.contains("33") && !clean.contains("128"));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// Sets AiPlayerbot.ExcludedBotRaces in all discovered playerbots.conf files.
|
||||
pub fn sync_bot_races_config(root: &Path, allow_custom_races: bool) -> Result<()> {
|
||||
let excluded = if allow_custom_races {
|
||||
EXCLUDED_BOT_RACES_EXPERIMENTAL
|
||||
} else {
|
||||
EXCLUDED_BOT_RACES_RECOMMENDED
|
||||
};
|
||||
for path in playerbots_conf_paths(root) {
|
||||
if let Ok(bytes) = fs::read(&path) {
|
||||
if let Ok(mut conf) = crate::config::parser::ConfFile::parse_bytes(&bytes) {
|
||||
conf.set(
|
||||
"AiPlayerbot.ExcludedBotRaces",
|
||||
&format!("\"{excluded}\""),
|
||||
&[
|
||||
"CoA Custom: races new random bots never get",
|
||||
"Off (recommended): excludes all added races",
|
||||
"On (experimental): allows stable added races",
|
||||
],
|
||||
);
|
||||
fsx::atomic_write(&path, conf.to_text().as_bytes())?;
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "kebab-case")]
|
||||
pub enum ClientPatchState {
|
||||
NotInstalled,
|
||||
Enabled,
|
||||
Disabled,
|
||||
PartiallyInstalled,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct ClientPatchStatus {
|
||||
pub state: ClientPatchState,
|
||||
pub installed_mpqs: usize,
|
||||
pub total_mpqs: usize,
|
||||
pub has_root_files: bool,
|
||||
pub client_path: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Serialize, Deserialize)]
|
||||
struct PatchFile {
|
||||
path: String,
|
||||
sha256: String,
|
||||
}
|
||||
|
||||
fn patch_files(client: &Path) -> Result<Vec<PatchFile>> {
|
||||
let bundled: std::collections::BTreeMap<String, String> = serde_json::from_str(include_str!("custom_races_hashes.json"))?;
|
||||
let manifest = fs::read_to_string(client.join(MANIFEST_FILENAME)).unwrap_or_default();
|
||||
let mut files = std::collections::BTreeMap::new();
|
||||
for line in manifest.lines() {
|
||||
let path = if let Some(name) = line.strip_prefix("MPQ:") {
|
||||
if name.contains(['/', '\\']) { return Err(Error::Invalid("Invalid custom races patch manifest.".into())); }
|
||||
Some(format!("Data/{name}"))
|
||||
} else if let Some(name) = line.strip_prefix("ROOT:") {
|
||||
if name.contains(['/', '\\']) { return Err(Error::Invalid("Invalid custom races patch manifest.".into())); }
|
||||
Some(name.to_string())
|
||||
} else { None };
|
||||
if let Some(path) = path {
|
||||
fsx::safe_join(client, &path)?;
|
||||
files.insert(path.clone(), bundled.get(&path).cloned().unwrap_or_default());
|
||||
}
|
||||
}
|
||||
if files.is_empty() { files = bundled; }
|
||||
for line in manifest.lines().filter_map(|line| line.strip_prefix("SHA256:")) {
|
||||
let (hash, path) = line.split_once(':').ok_or_else(|| Error::Invalid("Invalid custom races checksum.".into()))?;
|
||||
if hash.len() != 64 || !hash.bytes().all(|b| b.is_ascii_hexdigit()) || !files.contains_key(path) {
|
||||
return Err(Error::Invalid("Invalid custom races checksum.".into()));
|
||||
}
|
||||
files.insert(path.into(), hash.into());
|
||||
}
|
||||
Ok(files.into_iter().map(|(path, sha256)| PatchFile { path, sha256 }).collect())
|
||||
}
|
||||
|
||||
fn suffix(path: &Path, extension: &str) -> PathBuf {
|
||||
path.with_file_name(format!("{}.{extension}", path.file_name().unwrap_or_default().to_string_lossy()))
|
||||
}
|
||||
|
||||
fn matches_patch(path: &Path, file: &PatchFile) -> bool {
|
||||
path.is_file() && fsx::sha256_file(path).is_ok_and(|hash| hash == file.sha256)
|
||||
}
|
||||
|
||||
/// Only complete, verified payloads are reported as enabled or disabled.
|
||||
pub fn client_patch_status(client_path: &Path) -> ClientPatchStatus {
|
||||
let data = client_path.join("Data");
|
||||
let installed_mpqs = RACE_MPQS.iter().filter(|name| data.join(name).is_file() || suffix(&data.join(name), "disabled").is_file()).count();
|
||||
let has_root_files = client_path.join("EsteriaAppearance.dll").is_file() || client_path.join("dinput8.dll").is_file() || client_path.join("dinput8.dll.disabled").is_file();
|
||||
let manifest = fs::read_to_string(client_path.join(MANIFEST_FILENAME)).unwrap_or_default();
|
||||
let current = manifest.lines().any(|line| line == format!("# CoA Custom {CLIENT_VERSION}"));
|
||||
let state = if !manifest.is_empty() && current && !client_path.join(".coa-races-transaction").exists() {
|
||||
match patch_files(client_path) {
|
||||
Ok(files) if files.iter().all(|f| matches_patch(&client_path.join(&f.path), f) && !suffix(&client_path.join(&f.path), "disabled").exists()) => ClientPatchState::Enabled,
|
||||
Ok(files) if files.iter().all(|f| matches_patch(&suffix(&client_path.join(&f.path), "disabled"), f)) => ClientPatchState::Disabled,
|
||||
_ => ClientPatchState::PartiallyInstalled,
|
||||
}
|
||||
} else if !manifest.is_empty() || patch_files(client_path).is_ok_and(|files| files.iter().filter(|file| file.path.starts_with("Data/") && file.path != "Data/patch-T.MPQ").any(|file| matches_patch(&client_path.join(&file.path), file) || matches_patch(&suffix(&client_path.join(&file.path), "disabled"), file))) {
|
||||
ClientPatchState::PartiallyInstalled
|
||||
} else { ClientPatchState::NotInstalled };
|
||||
ClientPatchStatus { state, installed_mpqs, total_mpqs: RACE_MPQS.len(), has_root_files,
|
||||
client_path: Some(client_path.to_string_lossy().into_owned()) }
|
||||
}
|
||||
|
||||
#[derive(Serialize, Deserialize)]
|
||||
struct SavedFile { path: String, existed: bool }
|
||||
|
||||
struct PatchTransaction<'a> { root: &'a Path, entries: Vec<SavedFile>, finished: bool }
|
||||
impl<'a> PatchTransaction<'a> {
|
||||
fn new(root: &'a Path) -> Result<Self> {
|
||||
recover_patch_transaction(root)?;
|
||||
fs::create_dir(root.join(".coa-races-transaction"))?;
|
||||
Ok(Self { root, entries: Vec::new(), finished: false })
|
||||
}
|
||||
fn save(&mut self, path: &Path) -> Result<()> {
|
||||
let relative = path.strip_prefix(self.root).map_err(|_| Error::Invalid("Patch path escaped the client directory.".into()))?.to_string_lossy().replace('\\', "/");
|
||||
fsx::safe_join(self.root, &relative)?;
|
||||
if self.entries.iter().any(|entry| entry.path == relative) { return Ok(()); }
|
||||
let index = self.entries.len();
|
||||
self.entries.push(SavedFile { path: relative, existed: path.is_file() });
|
||||
fsx::atomic_write_json(&self.root.join(".coa-races-transaction/journal.json"), &self.entries)?;
|
||||
if path.is_file() { fs::rename(path, self.root.join(".coa-races-transaction").join(index.to_string()))?; }
|
||||
Ok(())
|
||||
}
|
||||
fn copy(&mut self, source: &Path, target: &Path) -> Result<()> {
|
||||
self.save(target)?;
|
||||
fs::create_dir_all(target.parent().ok_or_else(|| Error::Invalid("Patch file has no parent directory.".into()))?)?;
|
||||
fs::copy(source, target)?;
|
||||
Ok(())
|
||||
}
|
||||
fn move_file(&mut self, source: &Path, target: &Path) -> Result<()> {
|
||||
self.save(source)?;
|
||||
let index = self.entries.iter().position(|entry| self.root.join(&entry.path) == source).unwrap();
|
||||
// Copy from the journal so rollback retains the previous bytes.
|
||||
let saved = self.root.join(".coa-races-transaction").join(index.to_string());
|
||||
self.copy(&saved, target)
|
||||
}
|
||||
fn finish(mut self) -> Result<()> {
|
||||
fsx::atomic_write(&self.root.join(".coa-races-transaction/committed"), b"committed")?;
|
||||
self.finished = true;
|
||||
fs::remove_dir_all(self.root.join(".coa-races-transaction"))?;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
impl Drop for PatchTransaction<'_> {
|
||||
fn drop(&mut self) { if !self.finished { let _ = recover_patch_transaction(self.root); } }
|
||||
}
|
||||
|
||||
fn recover_patch_transaction(root: &Path) -> Result<()> {
|
||||
let directory = root.join(".coa-races-transaction");
|
||||
if !directory.is_dir() { return Ok(()); }
|
||||
if !directory.join("committed").exists() && directory.join("journal.json").exists() {
|
||||
let entries: Vec<SavedFile> = fsx::read_json(&directory.join("journal.json"))?;
|
||||
for (index, entry) in entries.iter().enumerate().rev() {
|
||||
let path = fsx::safe_join(root, &entry.path)?;
|
||||
let saved = directory.join(index.to_string());
|
||||
if saved.is_file() {
|
||||
if path.is_file() { fs::remove_file(&path)?; }
|
||||
fs::rename(saved, path)?;
|
||||
} else if !entry.existed && path.is_file() { fs::remove_file(path)?; }
|
||||
}
|
||||
}
|
||||
fs::remove_dir_all(directory)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn patch_lock(client: &Path) -> Result<File> {
|
||||
use fs4::fs_std::FileExt;
|
||||
let lock = fs::OpenOptions::new().read(true).write(true).create(true).truncate(false).open(client.join(".coa-races.lock"))?;
|
||||
if !lock.try_lock_exclusive()? { return Err(Error::Invalid("Another custom races operation is using this client.".into())); }
|
||||
Ok(lock)
|
||||
}
|
||||
|
||||
fn preserve_original(tx: &mut PatchTransaction<'_>, active: &Path) -> Result<()> {
|
||||
let original = suffix(active, "original");
|
||||
if original.is_file() && fsx::sha256_file(active)? == fsx::sha256_file(&original)? { return Ok(()); }
|
||||
if original.is_file() {
|
||||
let previous = suffix(active, &format!("original.previous-{}", uuid::Uuid::new_v4().simple()));
|
||||
tx.copy(&original, &previous)?;
|
||||
}
|
||||
tx.copy(active, &original)
|
||||
}
|
||||
|
||||
/// Preserve launcher replacements, and switch every file owned by the package.
|
||||
pub fn set_client_patch_enabled(client: &Path, enabled: bool) -> Result<()> {
|
||||
if !client.is_dir() { return Err(Error::Invalid("Game client directory not found.".into())); }
|
||||
if crate::client::is_running(client) { return Err(Error::Invalid("Close the game before changing custom races patches.".into())); }
|
||||
let _lock = patch_lock(client)?;
|
||||
recover_patch_transaction(client)?;
|
||||
if !client.join(MANIFEST_FILENAME).is_file() { return Ok(()); }
|
||||
let files = patch_files(client)?;
|
||||
if enabled {
|
||||
for file in &files {
|
||||
let active = client.join(&file.path);
|
||||
if !matches_patch(&active, file) && !matches_patch(&suffix(&active, "disabled"), file) {
|
||||
return Err(Error::Invalid(format!("Custom races file {} was replaced or is missing. Repair the client patch before enabling it.", file.path)));
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut tx = PatchTransaction::new(client)?;
|
||||
for file in files {
|
||||
let active = client.join(&file.path);
|
||||
let disabled = suffix(&active, "disabled");
|
||||
let original = suffix(&active, "original");
|
||||
if enabled {
|
||||
if active.is_file() && !matches_patch(&active, &file) { preserve_original(&mut tx, &active)?; }
|
||||
if matches_patch(&disabled, &file) { tx.move_file(&disabled, &active)?; }
|
||||
} else if matches_patch(&active, &file) {
|
||||
if disabled.is_file() && !matches_patch(&disabled, &file) {
|
||||
tx.move_file(&disabled, &suffix(&disabled, &format!("replaced-{}", uuid::Uuid::new_v4().simple())))?;
|
||||
}
|
||||
tx.move_file(&active, &disabled)?;
|
||||
if original.is_file() { tx.copy(&original, &active)?; }
|
||||
} else if active.is_file() {
|
||||
preserve_original(&mut tx, &active)?;
|
||||
}
|
||||
}
|
||||
tx.finish()
|
||||
}
|
||||
|
||||
pub fn uninstall_client_patches(client: &Path) -> Result<()> {
|
||||
if crate::client::is_running(client) { return Err(Error::Invalid("Close the game before removing custom races patches.".into())); }
|
||||
let _lock = patch_lock(client)?;
|
||||
recover_patch_transaction(client)?;
|
||||
if !client.join(MANIFEST_FILENAME).is_file() { return Ok(()); }
|
||||
let mut tx = PatchTransaction::new(client)?;
|
||||
for file in patch_files(client)? {
|
||||
let active = client.join(&file.path);
|
||||
if matches_patch(&active, &file) {
|
||||
tx.save(&active)?;
|
||||
let original = suffix(&active, "original");
|
||||
if original.is_file() { tx.copy(&original, &active)?; }
|
||||
}
|
||||
let disabled = suffix(&active, "disabled");
|
||||
if active.is_file() && !matches_patch(&active, &file) && !suffix(&active, "original").is_file() {
|
||||
tx.move_file(&active, &suffix(&active, &format!("replaced-{}", uuid::Uuid::new_v4().simple())))?;
|
||||
}
|
||||
if disabled.is_file() {
|
||||
if !matches_patch(&disabled, &file) { tx.move_file(&disabled, &suffix(&disabled, &format!("replaced-{}", uuid::Uuid::new_v4().simple())))?; }
|
||||
else { tx.save(&disabled)?; }
|
||||
}
|
||||
}
|
||||
tx.save(&client.join(MANIFEST_FILENAME))?;
|
||||
tx.finish()
|
||||
}
|
||||
|
||||
fn verify_archive(path: &Path, filename: &str) -> Result<()> {
|
||||
let expected = match filename {
|
||||
"CoA-Custom-1.5-main-20261009-cb2a0ca4.zip" => "117f5d99add18191676be6648fb0f2e99019a06c18705c71454e371e7df2afd2",
|
||||
"CoA-Custom-1.5-client-part1.zip" => "19eb372805b3268653914da03377d67f056e5b50d818a8a06a5f260aad03211e",
|
||||
"CoA-Custom-1.5-client-part2.zip" => "122f2882da255913e01610e33c6446ded897fecbe60b6d5ee026149becf8f278",
|
||||
_ => return Err(Error::Invalid("Unknown custom races archive.".into())),
|
||||
};
|
||||
if fsx::sha256_file(path)? != expected {
|
||||
return Err(Error::Invalid(format!("Custom races archive {filename} failed verification. Remove it and try again.")));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Locate an archive locally in Downloads or cache, or download it from GitHub.
|
||||
fn resolve_or_download_archive(
|
||||
filename: &str,
|
||||
url: &str,
|
||||
client: &reqwest::blocking::Client,
|
||||
cancel: &Cancel,
|
||||
report: &dyn Fn(&str, f32),
|
||||
base_percent: f32,
|
||||
percent_slice: f32,
|
||||
) -> Result<PathBuf> {
|
||||
// 1. Check user Downloads folder
|
||||
if let Some(userprofile) = std::env::var_os("USERPROFILE") {
|
||||
let downloads = PathBuf::from(userprofile).join("Downloads");
|
||||
let candidate = downloads.join(filename);
|
||||
if candidate.is_file() {
|
||||
if let Ok(meta) = candidate.metadata() {
|
||||
if meta.len() > 1000 {
|
||||
tracing::info!(path = %candidate.display(), "using existing archive in Downloads");
|
||||
verify_archive(&candidate, filename)?;
|
||||
return Ok(candidate);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 2. Check temp / cache directory
|
||||
let cache_dir = std::env::temp_dir().join("coa-client-races");
|
||||
fs::create_dir_all(&cache_dir)?;
|
||||
let target = cache_dir.join(filename);
|
||||
if target.is_file() {
|
||||
if let Ok(meta) = target.metadata() {
|
||||
if meta.len() > 1000 {
|
||||
verify_archive(&target, filename)?;
|
||||
return Ok(target);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 3. Download from GitHub Releases
|
||||
report(&format!("Downloading {filename}..."), base_percent);
|
||||
let part_path = cache_dir.join(format!("{filename}.part"));
|
||||
|
||||
let resp = client
|
||||
.get(url)
|
||||
.send()
|
||||
.map_err(|e| Error::NetworkUnreachable(format!("Could not reach download server: {e}")))?;
|
||||
|
||||
if !resp.status().is_success() {
|
||||
return Err(Error::NetworkUnreachable(format!(
|
||||
"Download failed with status {} for {url}",
|
||||
resp.status()
|
||||
)));
|
||||
}
|
||||
|
||||
let total_bytes = resp.content_length().unwrap_or(0);
|
||||
let mut downloaded = 0u64;
|
||||
let mut src = resp;
|
||||
let mut dst = File::create(&part_path)?;
|
||||
|
||||
let mut buf = [0u8; 64 * 1024];
|
||||
let mut last_report = std::time::Instant::now();
|
||||
|
||||
loop {
|
||||
if cancel.is_set() {
|
||||
let _ = fs::remove_file(&part_path);
|
||||
return Err(Error::Invalid("Operation cancelled.".into()));
|
||||
}
|
||||
|
||||
let n = src
|
||||
.read(&mut buf)
|
||||
.map_err(|e| Error::NetworkUnreachable(format!("Download interrupted: {e}")))?;
|
||||
if n == 0 {
|
||||
break;
|
||||
}
|
||||
|
||||
dst.write_all(&buf[..n])?;
|
||||
downloaded += n as u64;
|
||||
|
||||
if last_report.elapsed() > std::time::Duration::from_millis(200) {
|
||||
let ratio = if total_bytes > 0 {
|
||||
(downloaded as f32 / total_bytes as f32).clamp(0.0, 1.0)
|
||||
} else {
|
||||
0.5
|
||||
};
|
||||
report(
|
||||
&format!(
|
||||
"Downloading {filename} ({:.1} MB)...",
|
||||
downloaded as f64 / 1_048_576.0
|
||||
),
|
||||
base_percent + ratio * percent_slice,
|
||||
);
|
||||
last_report = std::time::Instant::now();
|
||||
}
|
||||
}
|
||||
|
||||
dst.flush()?;
|
||||
drop(dst);
|
||||
|
||||
verify_archive(&part_path, filename)?;
|
||||
fs::rename(&part_path, &target)?;
|
||||
Ok(target)
|
||||
}
|
||||
|
||||
/// Download (if needed) and extract custom races client assets into the target WoW client.
|
||||
pub fn install_client_patches(
|
||||
client_path: &Path,
|
||||
cancel: &Cancel,
|
||||
report: &dyn Fn(&str, f32),
|
||||
) -> Result<()> {
|
||||
if !client_path.is_dir() {
|
||||
return Err(Error::Invalid("Game client directory does not exist.".into()));
|
||||
}
|
||||
|
||||
if crate::client::is_running(client_path) {
|
||||
return Err(Error::Invalid("Close the game before installing custom races patches.".into()));
|
||||
}
|
||||
let _lock = patch_lock(client_path)?;
|
||||
recover_patch_transaction(client_path)?;
|
||||
let staging = tempfile::Builder::new().prefix(".coa-races-stage-").tempdir_in(client_path)?;
|
||||
let data_dir = staging.path().join("Data");
|
||||
fs::create_dir_all(&data_dir)?;
|
||||
|
||||
// 2. Resolve/download archives (0.05 .. 0.50)
|
||||
let http = reqwest::blocking::Client::builder()
|
||||
.user_agent(concat!("CoA-Server-Manager/", env!("CARGO_PKG_VERSION")))
|
||||
.timeout(std::time::Duration::from_secs(600))
|
||||
.build()
|
||||
.map_err(|e| Error::Invalid(format!("Cannot prepare downloader: {e}")))?;
|
||||
|
||||
let mut resolved_archives = Vec::new();
|
||||
let n_archives = ARCHIVES.len() as f32;
|
||||
for (i, (fname, url)) in ARCHIVES.iter().enumerate() {
|
||||
let base_pct = 0.05 + (i as f32 / n_archives) * 0.45;
|
||||
let slice = 0.45 / n_archives;
|
||||
let archive_path =
|
||||
resolve_or_download_archive(fname, url, &http, cancel, report, base_pct, slice)?;
|
||||
resolved_archives.push(archive_path);
|
||||
}
|
||||
|
||||
// 3. Extract archives (0.50 .. 0.95)
|
||||
let mut installed_mpqs = Vec::new();
|
||||
let mut installed_roots = Vec::new();
|
||||
|
||||
for (i, arch_path) in resolved_archives.iter().enumerate() {
|
||||
if cancel.is_set() {
|
||||
return Err(Error::Invalid("Operation cancelled.".into()));
|
||||
}
|
||||
|
||||
let arch_name = arch_path
|
||||
.file_name()
|
||||
.map(|n| n.to_string_lossy().into_owned())
|
||||
.unwrap_or_default();
|
||||
report(
|
||||
&format!("Unpacking {arch_name}..."),
|
||||
0.50 + (i as f32 / n_archives) * 0.45,
|
||||
);
|
||||
|
||||
let file = File::open(arch_path)?;
|
||||
let mut zip = zip::ZipArchive::new(file)
|
||||
.map_err(|e| Error::Invalid(format!("Failed to open zip {arch_name}: {e}")))?;
|
||||
|
||||
let num_files = zip.len();
|
||||
for file_idx in 0..num_files {
|
||||
if cancel.is_set() {
|
||||
return Err(Error::Invalid("Operation cancelled.".into()));
|
||||
}
|
||||
|
||||
let mut zfile = zip
|
||||
.by_index(file_idx)
|
||||
.map_err(|e| Error::Invalid(format!("Zip entry error in {arch_name}: {e}")))?;
|
||||
|
||||
if zfile.is_dir() {
|
||||
continue;
|
||||
}
|
||||
|
||||
let zname = zfile.name().to_string();
|
||||
let zname_norm = zname.replace('\\', "/");
|
||||
|
||||
if zname_norm.contains("files/client/") {
|
||||
let base = Path::new(&zname_norm)
|
||||
.file_name()
|
||||
.map(|n| n.to_string_lossy().into_owned())
|
||||
.unwrap_or_default();
|
||||
|
||||
if base.to_ascii_lowercase().ends_with(".mpq") {
|
||||
let dest = data_dir.join(&base);
|
||||
let mut out = File::create(&dest)?;
|
||||
io::copy(&mut zfile, &mut out)?;
|
||||
let disabled = data_dir.join(format!("{base}.disabled"));
|
||||
if disabled.is_file() { fs::remove_file(disabled)?; }
|
||||
installed_mpqs.push(base);
|
||||
} else if base.eq_ignore_ascii_case("dinput8.dll") {
|
||||
let dest = staging.path().join(&base);
|
||||
let mut out = File::create(&dest)?;
|
||||
io::copy(&mut zfile, &mut out)?;
|
||||
let disabled = staging.path().join(format!("{base}.disabled"));
|
||||
if disabled.is_file() { fs::remove_file(disabled)?; }
|
||||
installed_roots.push(base);
|
||||
}
|
||||
} else if zname_norm.contains("files/client_root/") {
|
||||
let base = Path::new(&zname_norm)
|
||||
.file_name()
|
||||
.map(|n| n.to_string_lossy().into_owned())
|
||||
.unwrap_or_default();
|
||||
|
||||
if !base.is_empty() {
|
||||
let dest = staging.path().join(&base);
|
||||
let mut out = File::create(&dest)?;
|
||||
io::copy(&mut zfile, &mut out)?;
|
||||
let disabled = staging.path().join(format!("{base}.disabled"));
|
||||
if disabled.is_file() { fs::remove_file(disabled)?; }
|
||||
installed_roots.push(base);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if !RACE_MPQS.iter().all(|name| installed_mpqs.iter().any(|installed| installed == name)) {
|
||||
return Err(Error::Invalid("Custom races archives are missing required client patches.".into()));
|
||||
}
|
||||
|
||||
// 4. Record manifest
|
||||
report("Finalizing manifest...", 0.98);
|
||||
let manifest_path = client_path.join(MANIFEST_FILENAME);
|
||||
installed_mpqs.sort();
|
||||
installed_mpqs.dedup();
|
||||
installed_roots.sort();
|
||||
installed_roots.dedup();
|
||||
|
||||
let mut manifest_body = format!("# CoA Custom {CLIENT_VERSION}\n# Custom Race MPQ files\n");
|
||||
for m in &installed_mpqs {
|
||||
manifest_body.push_str(&format!("MPQ:{m}\n"));
|
||||
}
|
||||
manifest_body.push_str("# Custom Race root files\n");
|
||||
for r in &installed_roots {
|
||||
manifest_body.push_str(&format!("ROOT:{r}\n"));
|
||||
}
|
||||
|
||||
let bundled: std::collections::BTreeMap<String, String> = serde_json::from_str(include_str!("custom_races_hashes.json"))?;
|
||||
let mut payload = Vec::new();
|
||||
for path in installed_mpqs.iter().map(|name| format!("Data/{name}")).chain(installed_roots.iter().cloned()) {
|
||||
let staged = fsx::safe_join(staging.path(), &path)?;
|
||||
let hash = fsx::sha256_file(&staged)?;
|
||||
if bundled.get(&path) != Some(&hash) { return Err(Error::Invalid(format!("Custom races file {path} failed verification."))); }
|
||||
manifest_body.push_str(&format!("SHA256:{hash}:{path}\n"));
|
||||
payload.push(PatchFile { path, sha256: hash });
|
||||
}
|
||||
if cancel.is_set() { return Err(Error::Invalid("Operation cancelled.".into())); }
|
||||
if payload.len() != bundled.len() { return Err(Error::Invalid("Custom races archives are missing required runtime files.".into())); }
|
||||
let previous = patch_files(client_path)?;
|
||||
let mut tx = PatchTransaction::new(client_path)?;
|
||||
for file in payload {
|
||||
let dest = fsx::safe_join(client_path, &file.path)?;
|
||||
if dest.is_file() && !previous.iter().any(|old| old.path == file.path && matches_patch(&dest, old)) && !matches_patch(&dest, &file) {
|
||||
preserve_original(&mut tx, &dest)?;
|
||||
}
|
||||
tx.copy(&staging.path().join(&file.path), &dest)?;
|
||||
let disabled = suffix(&dest, "disabled");
|
||||
if disabled.is_file() {
|
||||
if !previous.iter().any(|old| old.path == file.path && matches_patch(&disabled, old)) && !matches_patch(&disabled, &file) {
|
||||
tx.move_file(&disabled, &suffix(&disabled, &format!("replaced-{}", uuid::Uuid::new_v4().simple())))?;
|
||||
} else { tx.save(&disabled)?; }
|
||||
}
|
||||
}
|
||||
tx.save(&manifest_path)?;
|
||||
fsx::atomic_write(&manifest_path, manifest_body.as_bytes())?;
|
||||
tx.finish()?;
|
||||
report("Custom races client patches installed successfully!", 1.0);
|
||||
tracing::info!(
|
||||
mpqs = installed_mpqs.len(),
|
||||
roots = installed_roots.len(),
|
||||
"custom races client patch installation complete"
|
||||
);
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn record_files(root: &Path, names: &[&str]) {
|
||||
let mut manifest = format!("# CoA Custom {CLIENT_VERSION}\n");
|
||||
for name in names {
|
||||
let (kind, base) = name.strip_prefix("Data/").map_or(("ROOT", *name), |base| ("MPQ", base));
|
||||
manifest.push_str(&format!("{kind}:{base}\nSHA256:{}:{name}\n", fsx::sha256_file(&root.join(name)).unwrap()));
|
||||
}
|
||||
fs::write(root.join(MANIFEST_FILENAME), manifest).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "Requires the three downloaded release archives"]
|
||||
fn bundled_hashes_match_verified_release_archives() {
|
||||
use sha2::{Digest, Sha256};
|
||||
let folder = PathBuf::from(std::env::var_os("COA_RACES_ARCHIVE_DIR").expect("COA_RACES_ARCHIVE_DIR"));
|
||||
let expected: std::collections::BTreeMap<String, String> = serde_json::from_str(include_str!("custom_races_hashes.json")).unwrap();
|
||||
let mut actual = std::collections::BTreeMap::new();
|
||||
for (name, _) in ARCHIVES {
|
||||
let path = folder.join(name);
|
||||
verify_archive(&path, name).unwrap();
|
||||
let mut archive = zip::ZipArchive::new(File::open(path).unwrap()).unwrap();
|
||||
for index in 0..archive.len() {
|
||||
let mut entry = archive.by_index(index).unwrap();
|
||||
let name = entry.name().replace('\\', "/");
|
||||
if entry.is_dir() { continue; }
|
||||
let relative = if let Some(name) = name.split("files/client_root/").nth(1) { name.to_string() }
|
||||
else if let Some(name) = name.split("files/client/").nth(1) { if name == "dinput8.dll" { name.to_string() } else { format!("Data/{name}") } }
|
||||
else { continue };
|
||||
let mut hash = Sha256::new();
|
||||
let mut buffer = vec![0; 1024 * 1024];
|
||||
loop { let read = entry.read(&mut buffer).unwrap(); if read == 0 { break; } hash.update(&buffer[..read]); }
|
||||
actual.insert(relative, hex::encode(hash.finalize()));
|
||||
}
|
||||
}
|
||||
assert_eq!(actual, expected);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn another_patch_operation_cannot_enter_the_same_client() {
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
let first = patch_lock(temp.path()).unwrap();
|
||||
assert!(patch_lock(temp.path()).is_err());
|
||||
drop(first);
|
||||
patch_lock(temp.path()).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn switching_preserves_launcher_updates_for_every_owned_file() {
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
let root = temp.path();
|
||||
fs::create_dir_all(root.join("Data")).unwrap();
|
||||
let names = ["Data/patch-T.MPQ", "Data/patch-ZE1.MPQ", "Ascension.exe", "dinput8.dll", "EsteriaAppearance.dll"];
|
||||
for name in names { fs::write(root.join(name), b"custom").unwrap(); fs::write(suffix(&root.join(name), "original"), b"old official").unwrap(); }
|
||||
record_files(root, &names);
|
||||
set_client_patch_enabled(root, false).unwrap();
|
||||
for name in names { assert_eq!(fs::read(root.join(name)).unwrap(), b"old official"); fs::write(root.join(name), b"new official").unwrap(); }
|
||||
set_client_patch_enabled(root, true).unwrap();
|
||||
for name in names { assert_eq!(fs::read(root.join(name)).unwrap(), b"custom"); assert_eq!(fs::read(suffix(&root.join(name), "original")).unwrap(), b"new official"); }
|
||||
// An official launcher can also replace a currently enabled file.
|
||||
fs::write(root.join("Ascension.exe"), b"newest official").unwrap();
|
||||
assert_eq!(client_patch_status(root).state, ClientPatchState::PartiallyInstalled);
|
||||
set_client_patch_enabled(root, false).unwrap();
|
||||
assert_eq!(fs::read(root.join("Ascension.exe")).unwrap(), b"newest official");
|
||||
assert!(set_client_patch_enabled(root, true).unwrap_err().to_string().contains("Repair"));
|
||||
uninstall_client_patches(root).unwrap();
|
||||
assert_eq!(fs::read(root.join("Ascension.exe")).unwrap(), b"newest official");
|
||||
assert_eq!(client_patch_status(root).state, ClientPatchState::NotInstalled);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn failed_and_interrupted_transactions_restore_previous_bytes() {
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
let root = temp.path();
|
||||
let file = root.join("Ascension.exe");
|
||||
fs::write(&file, b"previous").unwrap();
|
||||
{
|
||||
let mut tx = PatchTransaction::new(root).unwrap();
|
||||
tx.save(&file).unwrap();
|
||||
fs::write(&file, b"replacement").unwrap();
|
||||
let staged = root.join("staged.dll");
|
||||
fs::write(&staged, b"new").unwrap();
|
||||
tx.copy(&staged, &root.join("Data/new.dll")).unwrap();
|
||||
assert_eq!(fs::read(root.join("Data/new.dll")).unwrap(), b"new");
|
||||
}
|
||||
assert_eq!(fs::read(&file).unwrap(), b"previous");
|
||||
assert!(!root.join("Data/new.dll").exists());
|
||||
let mut tx = PatchTransaction::new(root).unwrap();
|
||||
tx.save(&file).unwrap();
|
||||
fs::write(&file, b"interrupted").unwrap();
|
||||
std::mem::forget(tx);
|
||||
recover_patch_transaction(root).unwrap();
|
||||
assert_eq!(fs::read(&file).unwrap(), b"previous");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn existing_backups_and_foreign_disabled_files_are_retained() {
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
let root = temp.path();
|
||||
let file = root.join("dinput8.dll");
|
||||
fs::write(&file, b"custom").unwrap();
|
||||
record_files(root, &["dinput8.dll"]);
|
||||
fs::write(suffix(&file, "disabled"), b"third party").unwrap();
|
||||
fs::write(suffix(&file, "original"), b"original").unwrap();
|
||||
set_client_patch_enabled(root, false).unwrap();
|
||||
assert_eq!(fs::read(&file).unwrap(), b"original");
|
||||
assert!(fs::read_dir(root).unwrap().flatten().any(|entry| entry.file_name().to_string_lossy().contains("replaced-")));
|
||||
fs::write(&file, b"updated original").unwrap();
|
||||
set_client_patch_enabled(root, true).unwrap();
|
||||
assert!(fs::read_dir(root).unwrap().flatten().any(|entry| entry.file_name().to_string_lossy().contains("original.previous-")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn uninstall_moves_corrupted_custom_only_assets_out_of_the_active_client() {
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
let root = temp.path();
|
||||
fs::create_dir_all(root.join("Data")).unwrap();
|
||||
let file = root.join("Data/patch-ZE1.MPQ");
|
||||
fs::write(&file, b"custom").unwrap();
|
||||
record_files(root, &["Data/patch-ZE1.MPQ"]);
|
||||
fs::write(&file, b"corrupted custom").unwrap();
|
||||
uninstall_client_patches(root).unwrap();
|
||||
assert!(!file.exists());
|
||||
assert!(fs::read_dir(root.join("Data")).unwrap().flatten().any(|entry| entry.file_name().to_string_lossy().contains("replaced-")));
|
||||
assert_eq!(client_patch_status(root).state, ClientPatchState::NotInstalled);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unknown_or_corrupt_bytes_are_not_reported_as_enabled() {
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
let root = temp.path();
|
||||
fs::create_dir_all(root.join("Data")).unwrap();
|
||||
for name in RACE_MPQS { fs::write(root.join("Data").join(name), b"corrupt").unwrap(); }
|
||||
fs::write(root.join("dinput8.dll"), b"corrupt").unwrap();
|
||||
fs::write(root.join(MANIFEST_FILENAME), format!("# CoA Custom {CLIENT_VERSION}\n")).unwrap();
|
||||
assert_eq!(client_patch_status(root).state, ClientPatchState::PartiallyInstalled);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_old_complete_installation_requires_an_update() {
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
fs::create_dir_all(temp.path().join("Data")).unwrap();
|
||||
for name in RACE_MPQS { fs::write(temp.path().join("Data").join(name), b"old patch").unwrap(); }
|
||||
fs::write(temp.path().join("dinput8.dll"), b"old runtime").unwrap();
|
||||
fs::write(temp.path().join(MANIFEST_FILENAME), "# CoA Custom 1.4\n").unwrap();
|
||||
assert_eq!(client_patch_status(temp.path()).state, ClientPatchState::PartiallyInstalled);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_unpatched_client_is_left_untouched() {
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
fs::create_dir_all(temp.path().join("Data")).unwrap();
|
||||
fs::write(temp.path().join("Data/patch-T.MPQ"), b"original").unwrap();
|
||||
set_client_patch_enabled(temp.path(), false).unwrap();
|
||||
assert_eq!(fs::read(temp.path().join("Data/patch-T.MPQ")).unwrap(), b"original");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn corrupt_downloads_are_rejected() {
|
||||
let temp = tempfile::NamedTempFile::new().unwrap();
|
||||
fs::write(temp.path(), b"corrupt archive").unwrap();
|
||||
assert!(verify_archive(temp.path(), ARCHIVES[0].0).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_patch_status_and_toggle() {
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
let client_path = temp.path();
|
||||
let data_dir = client_path.join("Data");
|
||||
fs::create_dir_all(&data_dir).unwrap();
|
||||
|
||||
// 1. Initial state: Not installed
|
||||
let st = client_patch_status(client_path);
|
||||
assert_eq!(st.state, ClientPatchState::NotInstalled);
|
||||
|
||||
fs::write(client_path.join(MANIFEST_FILENAME), format!("# CoA Custom {CLIENT_VERSION}\n")).unwrap();
|
||||
// 2. Create MPQs and root files
|
||||
for mpq in RACE_MPQS {
|
||||
fs::write(data_dir.join(mpq), b"test mpq content").unwrap();
|
||||
}
|
||||
fs::write(client_path.join("dinput8.dll"), b"test dll").unwrap();
|
||||
fs::write(client_path.join("EsteriaAppearance.dll"), b"test dll").unwrap();
|
||||
|
||||
let names: Vec<String> = RACE_MPQS.iter().map(|name| format!("Data/{name}")).chain(["dinput8.dll".into(), "EsteriaAppearance.dll".into()]).collect();
|
||||
record_files(client_path, &names.iter().map(String::as_str).collect::<Vec<_>>());
|
||||
let st = client_patch_status(client_path);
|
||||
assert_eq!(st.state, ClientPatchState::Enabled);
|
||||
assert_eq!(st.installed_mpqs, RACE_MPQS.len());
|
||||
|
||||
// 3. Disable patches
|
||||
set_client_patch_enabled(client_path, false).unwrap();
|
||||
let st = client_patch_status(client_path);
|
||||
assert_eq!(st.state, ClientPatchState::Disabled);
|
||||
assert!(data_dir.join("patch-T.MPQ.disabled").is_file());
|
||||
assert!(!data_dir.join("patch-T.MPQ").is_file());
|
||||
assert!(client_path.join("dinput8.dll.disabled").is_file());
|
||||
assert!(!client_path.join("dinput8.dll").is_file());
|
||||
|
||||
// 4. Re-enable patches
|
||||
set_client_patch_enabled(client_path, true).unwrap();
|
||||
let st = client_patch_status(client_path);
|
||||
assert_eq!(st.state, ClientPatchState::Enabled);
|
||||
assert!(data_dir.join("patch-T.MPQ").is_file());
|
||||
assert!(!data_dir.join("patch-T.MPQ.disabled").is_file());
|
||||
assert!(client_path.join("dinput8.dll").is_file());
|
||||
assert!(!client_path.join("dinput8.dll.disabled").is_file());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,50 @@
|
||||
{
|
||||
"Data/patch-ZE1.MPQ": "69d79dbbea54ec0312c37770debc79c7bc9ce2e21eedef99c03cd8d911955283",
|
||||
"Data/patch-ZE2.MPQ": "1a41cae77ad730e9cf69e8d63fd12ae3a579418bb550d351fff469573a97ac3c",
|
||||
"Data/patch-ZE3.MPQ": "b587202c21b6f580682b601b7c2e905fbfa766276e74733db55c1bddbffb7f87",
|
||||
"Data/patch-ZEA.MPQ": "78fd10ec5262ae2417eba9700d2172553bbc1e5cfb0b597aada8f1753ca46d9d",
|
||||
"Data/patch-ZHA.MPQ": "0fc6ebeafe1d14192dc64bafc90bde3c49230df1297f98bf65900a3bcf953617",
|
||||
"Data/patch-ZZE.MPQ": "4b1e289e12c82644cb78f50170e6b5fd53918eb2de834f9e0cebddd81873a8bb",
|
||||
"Data/patch-ZZR.MPQ": "5a7575e592dc0c8a6913e0d946bbe06fa0ca2e4d817ef1f8548d3d13142bcbd3",
|
||||
"Ascension.exe": "e2c347019d554a59639e5978fd68e50e906973ab313c6573cc56ca82e8e3c547",
|
||||
"EsteriaAppearance.bin": "b3fb7c69b7600c39f888ea1925701be5667097dcb02bb6ddd830e5489306bb50",
|
||||
"EsteriaAppearance.dll": "392c5a2a25f9a69d705bdf841bb899aab768d4a3ee62734d576286c7198710d8",
|
||||
"EsteriaAppearanceGeometry.bin": "c95c53ca19c53c3434e12b99c1966f9c015ec3944c46dff7784d5e4ffc472d5d",
|
||||
"EsteriaAppearanceMaterials.bin": "f72f027f54a55c05aa0f76b457b97b484fe0e1aedc0e068cc0e0ca53e1878cba",
|
||||
"EsteriaCosmeticWings.bin": "57352c28459d073a29b3014d33b70f3b3756afa37fa9583ef6b30d503422ac3f",
|
||||
"EsteriaEarthen.bin": "8a0db93ba2d5c756b44ed84f2f7bc7c15eef13be6a7d87baf1383c6c0c624e02",
|
||||
"EsteriaGnoll.bin": "cfacc8e681bb8e54a4f01ee9c12a91bf0bd23a23527bb548d4dc21ec1b33eea2",
|
||||
"EsteriaGnollTextures.bin": "1ba9133a75dad291d98a068b2dcde01f31a897a1764cd7f3e2c316c288a8f605",
|
||||
"EsteriaHaranir.bin": "59f31d00e372fd2646e1cf0d9d3d5d671b31edd60ff7b862f8d1ce7e53ba1f2f",
|
||||
"EsteriaHaranirTextures.bin": "99948ca570be2d376f0c67e3b8088739b6fa9f9d2c73985e19f68df77689a229",
|
||||
"EsteriaHighmountain.bin": "e83349252ad2687ac23fcfc5623db7401cf32e5faf47a5a7be20c2f94b014938",
|
||||
"EsteriaNaga.bin": "e87547cff5d09500c294f8b06935d134cdd0bbb962e294a72de09404505bd8b3",
|
||||
"EsteriaNagaTextures.bin": "57ec560f99c1d48ac1e8f6a797c156513b99e7d349e3071afe405f812d159ae3",
|
||||
"EsteriaSaberon.bin": "7735c9325c807c5125760d87f323d6b7d4162fb542c1d8b5f435ea2d6b9a4daa",
|
||||
"EsteriaSaberonCoverage.bin": "9cdc227f08329e1245d2b864a996e7a772c96ecdbe5d81925f4d60cdbe4fa11e",
|
||||
"EsteriaSaberonTextures.bin": "1ba9133a75dad291d98a068b2dcde01f31a897a1764cd7f3e2c316c288a8f605",
|
||||
"EsteriaSethrak.bin": "bd14857a8c11fdf8027128763293701586b2102f9a6539d33a727014789fd606",
|
||||
"EsteriaSethrakTextures.bin": "d2b2cf58087a391f00198008fe871edd400ddf28d54a3a05674df74c5198528a",
|
||||
"EsteriaThinHuman.bin": "75794d192ea0c228b3da7bf7d0bdff1119f79d3f9bfef6650cd5e1a2b5d106eb",
|
||||
"EsteriaThinHumanTextures.bin": "02aeb4c05893d06125b8b58fdb7c2a56fe3d66a7d094706a44b43cb503d1731e",
|
||||
"EsteriaTuskarr.bin": "ecbe7ef490ba67eca029a57639192db61238522618491549766fe38529914387",
|
||||
"EsteriaTuskarrTextures.bin": "e2116c2c83adea079126fd5da765d20da24f044d4f161c4124e4368cb3d6bc71",
|
||||
"EsteriaVrykul.bin": "39e2b7b4c67997dbbd34bae840bd606a59290f7f2fc82565a0ba00090335415c",
|
||||
"EsteriaVrykulTextures.bin": "46098750a0e235724c6e9cc8d9d4e26550aa47bef95fd5f0f82efe5e945bf296",
|
||||
"EsteriaVulpera.bin": "c5434993b9af4a17d881965e4735cd2ac379e39c7142aac9844adff9528562d4",
|
||||
"EsteriaVulperaTextures.bin": "1ab844e74684aced2b069f1b91cd563aade45e05bd5e23f866a6c0c301cb098e",
|
||||
"dinput8.dll": "f8de78606c241fb3911dce22faf68f5b9f9885b142b183c1e2c09ddc8f7e380c",
|
||||
"Data/patch-T.MPQ": "9403e0680c74754eb0cb063718119aa6ace3616f7cecf488c8faf46f22505ae5",
|
||||
"Data/patch-ZE5.MPQ": "476b5a1fcf69f64fdb281e3b445362b936d016066ccd12f897acfcf200d6c0cf",
|
||||
"Data/patch-ZE6.MPQ": "762592c9ed950b4a7b6c7d85d45050b30fa3f35d53e348ee1e1516fdbb7e5484",
|
||||
"Data/patch-ZE7.MPQ": "de54b0189d242763d2872223419a259b6b8a4b380c24b50a2ef9c6fa44466248",
|
||||
"Data/patch-ZE8.MPQ": "1bc5691fb84a84f3e7a0a70baaa9192a97b4ec5906ee37c85838ffe08adef934",
|
||||
"Data/patch-ZE9.MPQ": "d49c94463e9548e76378ce2c0454d8f204f0745c8c0de32b6dce7f0b0fd67c4a",
|
||||
"Data/patch-ZES.MPQ": "a2d9348f917f745c7aa25b2eed96efa312f7b2d2f62cb86a4f2eaabc2dfa895f",
|
||||
"Data/patch-ZG.MPQ": "48979e1fda775f8deb47bffa48e0a468595d4c71286fee518f51dc5801c5ca39",
|
||||
"Data/patch-ZH.MPQ": "5e1d2fe287053abba703d7af381e10096c6525ba477ffed3971c2fc4f93e919c",
|
||||
"Data/patch-ZHM.MPQ": "317d3ae00f0bd674b358af07544976acb7804aa6d8b19d1788ad96030e8c9bf0",
|
||||
"Data/patch-ZJ.MPQ": "f821e99add86ef68d108c5ec466328c97677d3ed52f7944e200f3fe38c13b4de",
|
||||
"Data/patch-ZM.MPQ": "424ab1978986e854551633983a94bd15beba6328aabea8c02f98eaa32f6f0b61",
|
||||
"Data/patch-ZVU.MPQ": "c679b85a2e97344395756b54d2cf6abefe4e80e74944cb55b6e573ad17b7d020"
|
||||
}
|
||||
@@ -0,0 +1,382 @@
|
||||
//! SQUID's bot dashboard (<https://github.com/Zyth45/squidbots-dashboard>): a small web page, written in Python with
|
||||
//! no dependencies, that shows where the bots are and what they do. It is kept in `Extras/SquidDashboard` of the server
|
||||
//! folder and always comes from the release that matches the installed SQUID bots (same major and minor version), so the
|
||||
//! page and the bots agree on what the database and the logs contain.
|
||||
//!
|
||||
//! The dashboard finds the repack by itself (`Settings/database.json` and `Settings/repack.json` two folders up), so the
|
||||
//! Manager only has to download it and start it on a free port. Only the process the Manager started and recorded is ever
|
||||
//! stopped, identified by PID and creation time.
|
||||
|
||||
use std::io::Read;
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::error::{Error, Result};
|
||||
use crate::fsx;
|
||||
use crate::process::{self, ProcessIdentity};
|
||||
|
||||
const REPO: &str = "Zyth45/squidbots-dashboard";
|
||||
const DIR: &str = "Extras/SquidDashboard";
|
||||
const MARKER: &str = ".manager-dashboard.json";
|
||||
const PROCESS: &str = ".manager-dashboard-process.json";
|
||||
const FIRST_PORT: u16 = 8088;
|
||||
const MAX_ARCHIVE: u64 = 60 * 1024 * 1024;
|
||||
const MAX_UNPACKED: u64 = 150 * 1024 * 1024;
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
struct Marker {
|
||||
/// The dashboard release that is installed.
|
||||
tag: String,
|
||||
/// The SQUID release it was chosen for.
|
||||
squid_tag: String,
|
||||
port: u16,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize)]
|
||||
pub struct Status {
|
||||
pub installed: bool,
|
||||
/// Dashboard release installed.
|
||||
pub tag: Option<String>,
|
||||
/// SQUID bots release found in the server.
|
||||
pub squid_tag: Option<String>,
|
||||
/// The installed dashboard belongs to the installed bots' release series.
|
||||
pub matches: bool,
|
||||
pub running: bool,
|
||||
pub port: u16,
|
||||
pub url: String,
|
||||
}
|
||||
|
||||
fn dir(root: &Path) -> PathBuf {
|
||||
root.join(DIR)
|
||||
}
|
||||
|
||||
fn read_marker(root: &Path) -> Option<Marker> {
|
||||
fsx::read_json(&dir(root).join(MARKER)).ok()
|
||||
}
|
||||
|
||||
/// `v1.9.1` -> `[1, 9, 1]`.
|
||||
fn parse_tag(tag: &str) -> Option<Vec<u32>> {
|
||||
let parts: Vec<u32> = tag.trim().trim_start_matches('v').split('.').map(|p| p.parse().ok()).collect::<Option<_>>()?;
|
||||
(parts.len() >= 2).then_some(parts)
|
||||
}
|
||||
|
||||
/// Same major and minor version.
|
||||
fn same_series(a: &str, b: &str) -> bool {
|
||||
matches!((parse_tag(a), parse_tag(b)), (Some(a), Some(b)) if a[..2] == b[..2])
|
||||
}
|
||||
|
||||
/// The newest dashboard release of the bots' series (`v1.9` serves bots `v1.9` and `v1.9.1`).
|
||||
fn pick_tag(squid_tag: &str, available: &[String]) -> Option<String> {
|
||||
available.iter()
|
||||
.filter(|tag| same_series(tag, squid_tag))
|
||||
.max_by_key(|tag| parse_tag(tag).unwrap_or_default())
|
||||
.cloned()
|
||||
}
|
||||
|
||||
fn safe_tag(tag: &str) -> bool {
|
||||
!tag.is_empty() && tag.len() <= 40 && tag.chars().all(|c| c.is_ascii_alphanumeric() || matches!(c, '.' | '_' | '-'))
|
||||
}
|
||||
|
||||
fn squid_tag(root: &Path) -> Option<String> {
|
||||
crate::squid::release(root).and_then(|r| r.tag).filter(|t| safe_tag(t))
|
||||
}
|
||||
|
||||
fn record_alive(root: &Path) -> Option<ProcessIdentity> {
|
||||
let record: ProcessIdentity = fsx::read_json(&dir(root).join(PROCESS)).ok()?;
|
||||
let inside = Path::new(&record.exe).starts_with(root);
|
||||
(inside && process::is_alive(&record)).then_some(record)
|
||||
}
|
||||
|
||||
pub fn status(root: &Path) -> Status {
|
||||
let marker = read_marker(root);
|
||||
let installed = dir(root).join("squidbots.py").is_file() && marker.is_some();
|
||||
let squid = squid_tag(root);
|
||||
let port = marker.as_ref().map(|m| m.port).unwrap_or(FIRST_PORT);
|
||||
let running = installed && record_alive(root).is_some_and(|r| process::listeners().iter().any(|(p, pid)| *p == port && *pid == r.pid));
|
||||
Status {
|
||||
installed,
|
||||
matches: matches!((&marker, &squid), (Some(m), Some(s)) if same_series(&m.tag, s)),
|
||||
tag: marker.map(|m| m.tag),
|
||||
squid_tag: squid,
|
||||
running,
|
||||
port,
|
||||
url: format!("http://127.0.0.1:{port}"),
|
||||
}
|
||||
}
|
||||
|
||||
fn http() -> Result<reqwest::blocking::Client> {
|
||||
reqwest::blocking::Client::builder()
|
||||
.user_agent(concat!("CoA-Server-Manager/", env!("CARGO_PKG_VERSION")))
|
||||
.timeout(std::time::Duration::from_secs(120))
|
||||
.build()
|
||||
.map_err(|e| Error::Invalid(format!("Cannot prepare the download: {e}")))
|
||||
}
|
||||
|
||||
fn download_error(e: impl std::fmt::Display) -> Error {
|
||||
Error::NetworkUnreachable(e.to_string())
|
||||
}
|
||||
|
||||
fn available_tags(client: &reqwest::blocking::Client) -> Result<Vec<String>> {
|
||||
#[derive(Deserialize)]
|
||||
struct Tag { name: String }
|
||||
let response = client.get(format!("https://api.github.com/repos/{REPO}/tags?per_page=100")).send().map_err(download_error)?;
|
||||
if !response.status().is_success() { return Err(download_error(format!("GitHub answered {}", response.status()))); }
|
||||
let tags: Vec<Tag> = serde_json::from_str(&response.text().map_err(download_error)?).map_err(download_error)?;
|
||||
Ok(tags.into_iter().map(|t| t.name).filter(|t| safe_tag(t)).collect())
|
||||
}
|
||||
|
||||
/// Download the dashboard release that matches the installed bots and unpack it. A running dashboard is stopped first;
|
||||
/// maps the owner extracted and other files of theirs are left alone.
|
||||
pub fn install(root: &Path, report: &dyn Fn(&str)) -> Result<Status> {
|
||||
let squid = squid_tag(root).ok_or_else(|| Error::Invalid("The version of the SQUID bots could not be read, so the matching dashboard cannot be chosen.".into()))?;
|
||||
report("Looking for the matching dashboard");
|
||||
let client = http()?;
|
||||
let tag = pick_tag(&squid, &available_tags(&client)?)
|
||||
.ok_or_else(|| Error::Invalid(format!("There is no dashboard release for SQUID bots {squid} yet.")))?;
|
||||
report("Downloading the dashboard");
|
||||
let response = client.get(format!("https://codeload.github.com/{REPO}/zip/refs/tags/{tag}")).send().map_err(download_error)?;
|
||||
if !response.status().is_success() { return Err(download_error(format!("GitHub answered {}", response.status()))); }
|
||||
let mut bytes = Vec::new();
|
||||
response.take(MAX_ARCHIVE + 1).read_to_end(&mut bytes).map_err(download_error)?;
|
||||
if bytes.len() as u64 > MAX_ARCHIVE { return Err(Error::Invalid("The dashboard download is larger than expected and was rejected.".into())); }
|
||||
|
||||
stop(root)?;
|
||||
report("Unpacking the dashboard");
|
||||
let target = dir(root);
|
||||
std::fs::create_dir_all(&target)?;
|
||||
let mut archive = zip::ZipArchive::new(std::io::Cursor::new(bytes)).map_err(|e| Error::Invalid(format!("The dashboard download is damaged: {e}")))?;
|
||||
let mut total = 0u64;
|
||||
let mut wrote_main = false;
|
||||
for index in 0..archive.len() {
|
||||
let mut file = archive.by_index(index).map_err(|e| Error::Invalid(format!("The dashboard download is damaged: {e}")))?;
|
||||
if file.is_dir() { continue; }
|
||||
// GitHub wraps everything in one folder named after the repository and release.
|
||||
let Some(relative) = file.name().split_once('/').map(|(_, rest)| rest.to_string()) else { continue; };
|
||||
if relative.is_empty() || relative.starts_with(".github/") || relative.starts_with("docs/") { continue; }
|
||||
total += file.size();
|
||||
if total > MAX_UNPACKED { return Err(Error::Invalid("The dashboard download unpacks to more than expected and was rejected.".into())); }
|
||||
let destination = fsx::safe_join(&target, &relative)?;
|
||||
let mut content = Vec::with_capacity(file.size() as usize);
|
||||
file.read_to_end(&mut content)?;
|
||||
fsx::atomic_write(&destination, &content)?;
|
||||
wrote_main |= relative == "squidbots.py";
|
||||
}
|
||||
if !wrote_main { return Err(Error::Invalid("The dashboard download did not contain the dashboard.".into())); }
|
||||
let port = read_marker(root).map(|m| m.port).unwrap_or(FIRST_PORT);
|
||||
fsx::atomic_write_json(&target.join(MARKER), &Marker { tag, squid_tag: squid, port })?;
|
||||
Ok(status(root))
|
||||
}
|
||||
|
||||
fn free_port(preferred: u16) -> Result<u16> {
|
||||
let used: Vec<u16> = process::listeners().into_iter().map(|(port, _)| port).collect();
|
||||
std::iter::once(preferred).chain(FIRST_PORT..FIRST_PORT + 40).find(|p| !used.contains(p))
|
||||
.ok_or_else(|| Error::Invalid("No free port was found for the dashboard.".into()))
|
||||
}
|
||||
|
||||
/// A crash or power loss while the dashboard saves its history can leave a file of the right length that holds only
|
||||
/// zero bytes, and the dashboard then fails to start on it. Those files carry nothing, and the dashboard recreates them,
|
||||
/// so they are removed. The files that come with the release are never touched here (reinstalling restores them).
|
||||
fn discard_damaged_data(folder: &Path) -> Vec<String> {
|
||||
const SHIPPED: &[&str] = &["worldmap.json", "dashboard.example.json"];
|
||||
let mut removed = Vec::new();
|
||||
let Ok(entries) = std::fs::read_dir(folder) else { return removed; };
|
||||
for entry in entries.flatten() {
|
||||
let name = entry.file_name().to_string_lossy().into_owned();
|
||||
let path = entry.path();
|
||||
if !name.ends_with(".json") || name.starts_with('.') || SHIPPED.contains(&name.as_str()) || !path.is_file() { continue; }
|
||||
let Ok(bytes) = std::fs::read(&path) else { continue; };
|
||||
if !bytes.is_empty() && bytes.iter().all(|b| *b == 0) && std::fs::remove_file(&path).is_ok() {
|
||||
tracing::warn!(file = %path.display(), "dashboard: removed a data file damaged by an interrupted write");
|
||||
removed.push(name);
|
||||
}
|
||||
}
|
||||
removed
|
||||
}
|
||||
|
||||
/// The dashboard reads `coa-level-builds.json` (class and specialization names) from its own folder; the CoA Bots repack
|
||||
/// ships it, the GitHub release does not. The server's own reference file has the same content and shape.
|
||||
fn ensure_builds_file(root: &Path) {
|
||||
let target = dir(root).join("coa-level-builds.json");
|
||||
if target.is_file() { return; }
|
||||
let reference = root.join("Core/reference/ascensionsidekick-level-builds.json");
|
||||
let content = std::fs::read(&reference).ok().filter(|bytes| serde_json::from_slice::<serde_json::Value>(bytes).is_ok_and(|v| v.is_object()));
|
||||
let _ = fsx::atomic_write(&target, content.as_deref().unwrap_or(b"{}"));
|
||||
}
|
||||
|
||||
/// Python's HTTP server closes each connection with `shutdown(SHUT_WR)` straight after the answer. On Windows that can
|
||||
/// throw away what is still queued: any answer above about 64 KB (the dashboard's statistics are 400 KB) arrives cut
|
||||
/// off, and the page fails to load. This small launcher waits for the client to finish reading and close instead, queues
|
||||
/// more waiting connections than Python's five, and then runs the dashboard unchanged.
|
||||
const LAUNCHER: &str = r#"import runpy, socketserver, sys, http.server
|
||||
|
||||
http.server.ThreadingHTTPServer.request_queue_size = 256
|
||||
|
||||
|
||||
def shutdown_request(self, request):
|
||||
try:
|
||||
request.settimeout(5)
|
||||
while request.recv(4096):
|
||||
pass
|
||||
except OSError:
|
||||
pass
|
||||
self.close_request(request)
|
||||
|
||||
|
||||
socketserver.TCPServer.shutdown_request = shutdown_request
|
||||
script = sys.argv[1]
|
||||
sys.argv = [script]
|
||||
runpy.run_path(script, run_name="__main__")
|
||||
"#;
|
||||
|
||||
/// Start the dashboard with the repack's own Python. Returns when it answers on its port.
|
||||
pub fn start(root: &Path) -> Result<Status> {
|
||||
let current = status(root);
|
||||
if !current.installed { return Err(Error::Invalid("The dashboard is not installed.".into())); }
|
||||
if current.running { return Ok(current); }
|
||||
let python = root.join("Runtime/python/python.exe");
|
||||
if !python.is_file() { return Err(Error::Invalid("This server has no bundled Python, so the dashboard cannot run.".into())); }
|
||||
let folder = dir(root);
|
||||
let mut marker = read_marker(root).ok_or_else(|| Error::Invalid("The dashboard installation is incomplete.".into()))?;
|
||||
marker.port = free_port(marker.port)?;
|
||||
fsx::atomic_write_json(&folder.join(MARKER), &marker)?;
|
||||
|
||||
let log_path = folder.join("dashboard.log");
|
||||
let log = std::fs::File::create(&log_path)?;
|
||||
let mut command = std::process::Command::new(&python);
|
||||
ensure_builds_file(root);
|
||||
discard_damaged_data(&folder);
|
||||
let script = folder.join("squidbots.py");
|
||||
let launcher = folder.join("manager_launch.py");
|
||||
fsx::atomic_write(&launcher, LAUNCHER.as_bytes())?;
|
||||
command.arg("-B").arg(&launcher).arg(&script).current_dir(&folder).env("COA_DASHBOARD_PORT", marker.port.to_string())
|
||||
.stdin(std::process::Stdio::null()).stdout(log.try_clone()?).stderr(log);
|
||||
#[cfg(windows)]
|
||||
{
|
||||
use std::os::windows::process::CommandExt;
|
||||
command.creation_flags(0x0800_0000); // CREATE_NO_WINDOW
|
||||
}
|
||||
let mut child = command.spawn()?;
|
||||
let identity = process::identity(child.id()).ok_or_else(|| Error::Invalid("The dashboard exited at once.".into()))?;
|
||||
fsx::atomic_write_json(&folder.join(PROCESS), &identity)?;
|
||||
|
||||
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(20);
|
||||
loop {
|
||||
if process::listeners().iter().any(|(port, pid)| *port == marker.port && *pid == identity.pid) { return Ok(status(root)); }
|
||||
if let Ok(Some(_)) = child.try_wait() {
|
||||
let _ = std::fs::remove_file(folder.join(PROCESS));
|
||||
let tail = std::fs::read_to_string(&log_path).unwrap_or_default();
|
||||
let lines: Vec<&str> = tail.lines().rev().take(8).collect();
|
||||
return Err(Error::Invalid(format!("The dashboard stopped right after starting. {}", lines.into_iter().rev().collect::<Vec<_>>().join("\n"))));
|
||||
}
|
||||
if std::time::Instant::now() > deadline {
|
||||
let _ = stop(root);
|
||||
return Err(Error::Invalid("The dashboard did not start in time. See Extras/SquidDashboard/dashboard.log.".into()));
|
||||
}
|
||||
std::thread::sleep(std::time::Duration::from_millis(300));
|
||||
}
|
||||
}
|
||||
|
||||
/// Stop the dashboard this Manager started (by recorded PID and creation time, never by name).
|
||||
pub fn stop(root: &Path) -> Result<()> {
|
||||
let record_file = dir(root).join(PROCESS);
|
||||
if let Some(record) = record_alive(root) {
|
||||
let mut command = std::process::Command::new("taskkill");
|
||||
command.args(["/PID", &record.pid.to_string(), "/T", "/F"]).stdout(std::process::Stdio::null()).stderr(std::process::Stdio::null());
|
||||
#[cfg(windows)]
|
||||
{
|
||||
use std::os::windows::process::CommandExt;
|
||||
command.creation_flags(0x0800_0000);
|
||||
}
|
||||
let _ = command.status();
|
||||
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(10);
|
||||
while process::is_alive(&record) && std::time::Instant::now() < deadline {
|
||||
std::thread::sleep(std::time::Duration::from_millis(200));
|
||||
}
|
||||
if process::is_alive(&record) { return Err(Error::Invalid("The dashboard could not be stopped.".into())); }
|
||||
}
|
||||
let _ = std::fs::remove_file(record_file);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn tags(list: &[&str]) -> Vec<String> { list.iter().map(|s| s.to_string()).collect() }
|
||||
|
||||
#[test]
|
||||
fn the_dashboard_follows_the_bots_release_series() {
|
||||
let available = tags(&["v1.8", "v1.9", "v1.9.2", "v2.0"]);
|
||||
assert_eq!(pick_tag("v1.9", &available).as_deref(), Some("v1.9.2"), "the newest of the same series");
|
||||
assert_eq!(pick_tag("v1.9.1", &tags(&["v1.8", "v1.9"])).as_deref(), Some("v1.9"), "bots 1.9.1 use dashboard 1.9");
|
||||
assert_eq!(pick_tag("v1.8.1", &available).as_deref(), Some("v1.8"));
|
||||
assert_eq!(pick_tag("v1.10", &available), None, "a later series has none yet");
|
||||
assert_eq!(pick_tag("main", &available), None);
|
||||
assert!(same_series("v1.9", "v1.9.1") && !same_series("v1.9", "v1.8.9"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn zero_filled_history_files_are_removed_but_shipped_and_valid_files_stay() {
|
||||
let folder = tempfile::tempdir().unwrap();
|
||||
std::fs::write(folder.path().join("history.json"), vec![0u8; 358]).unwrap();
|
||||
std::fs::write(folder.path().join("levels.json"), vec![0u8; 100]).unwrap();
|
||||
std::fs::write(folder.path().join("xp-history.json"), "[1, 2]").unwrap();
|
||||
std::fs::write(folder.path().join("worldmap.json"), vec![0u8; 50]).unwrap();
|
||||
std::fs::write(folder.path().join("empty.json"), "").unwrap();
|
||||
let mut removed = discard_damaged_data(folder.path());
|
||||
removed.sort();
|
||||
assert_eq!(removed, ["history.json", "levels.json"]);
|
||||
assert!(folder.path().join("xp-history.json").exists() && folder.path().join("worldmap.json").exists() && folder.path().join("empty.json").exists());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tags_are_checked_before_they_reach_a_url() {
|
||||
assert!(safe_tag("v1.9.1") && !safe_tag("v1.9/../x") && !safe_tag("") && !safe_tag("a b"));
|
||||
}
|
||||
|
||||
/// Needs the network: `cargo test -p coa-core dashboard -- --ignored`.
|
||||
#[test]
|
||||
#[ignore]
|
||||
fn the_matching_release_is_downloaded_and_unpacked() {
|
||||
let root = tempfile::tempdir().unwrap();
|
||||
let settings = root.path().join("Core/configs/modules/playerbots.conf.settings.json");
|
||||
fsx::atomic_write(&settings, br#"{"format":1,"tag":"v1.9.1","settings":[]}"#).unwrap();
|
||||
let installed = install(root.path(), &|step| println!("{step}")).unwrap();
|
||||
assert!(installed.installed && installed.matches);
|
||||
assert_eq!(installed.tag.as_deref(), Some("v1.9"));
|
||||
assert!(root.path().join("Extras/SquidDashboard/squidbots.py").is_file());
|
||||
assert!(!installed.running);
|
||||
}
|
||||
|
||||
/// Needs a real server folder (`COA_TEST_ROOT`) whose bots are installed and whose database runs:
|
||||
/// `COA_TEST_ROOT=... cargo test -p coa-core dashboard -- --ignored --nocapture`.
|
||||
#[test]
|
||||
#[ignore]
|
||||
fn the_started_dashboard_delivers_its_large_statistics() {
|
||||
let root = PathBuf::from(std::env::var("COA_TEST_ROOT").expect("COA_TEST_ROOT"));
|
||||
let started = start(&root).unwrap();
|
||||
assert!(started.running, "{started:?}");
|
||||
let client = reqwest::blocking::Client::builder().timeout(std::time::Duration::from_secs(90)).build().unwrap();
|
||||
let body = client.get(format!("{}/api/stats", started.url)).send().unwrap().bytes().unwrap();
|
||||
println!("stats: {} bytes: {}", body.len(), String::from_utf8_lossy(&body[..body.len().min(300)]));
|
||||
let live = client.get(format!("{}/api/live", started.url)).send().unwrap().bytes().unwrap();
|
||||
stop(&root).unwrap();
|
||||
assert!(!status(&root).running);
|
||||
if String::from_utf8_lossy(&body).starts_with("{\"error\"") {
|
||||
println!("the database of this server is not running, so the large answer could not be checked");
|
||||
} else {
|
||||
assert!(body.len() > 100_000, "the statistics must arrive whole, got {} bytes", body.len());
|
||||
}
|
||||
assert!(!live.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_folder_without_the_dashboard_is_not_installed_or_running() {
|
||||
let root = tempfile::tempdir().unwrap();
|
||||
let s = status(root.path());
|
||||
assert!(!s.installed && !s.running && !s.matches);
|
||||
assert!(start(root.path()).is_err());
|
||||
assert!(stop(root.path()).is_ok());
|
||||
}
|
||||
}
|
||||
+153
-5
@@ -1,4 +1,5 @@
|
||||
//! Database access through the MySQL client tools bundled with the repack (`mysql`, `mysqldump`, `mysqladmin`).
|
||||
//! Database access through the MySQL client tools bundled with the repack (`mysql`, `mysqldump`, `mysqladmin`), or,
|
||||
//! for a Docker installation, the same tools run inside the database container with `docker exec`.
|
||||
//!
|
||||
//! Passwords travel only in the child's environment (`MYSQL_PWD`), never on a command line or in a log.
|
||||
|
||||
@@ -45,6 +46,8 @@ pub struct Db {
|
||||
user: &'static str,
|
||||
password: Secret,
|
||||
realm: crate::realms::Mode,
|
||||
/// Name of the database container of a Docker installation; the client tools then run inside it.
|
||||
container: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
@@ -68,6 +71,7 @@ fn no_window(cmd: &mut Command) {
|
||||
pub const SCHEMAS: [(&str, &str); 3] = [("characters", "acore_characters"), ("auth", "acore_auth"), ("world", "acore_world")];
|
||||
|
||||
pub fn schema_of(kind: &str) -> Result<&'static str> {
|
||||
if kind == "playerbots" { return Ok("acore_playerbots"); }
|
||||
if let Some(kind) = kind.strip_prefix("wildcard-") { return crate::realms::Mode::Wildcard.schema(kind); }
|
||||
if let Some(kind) = kind.strip_prefix("coa-") { return crate::realms::Mode::Coa.schema(kind); }
|
||||
SCHEMAS.iter().find(|(k, _)| *k == kind).map(|(_, s)| *s).ok_or_else(|| Error::Invalid(format!("unknown database {kind}")))
|
||||
@@ -89,6 +93,9 @@ impl Db {
|
||||
let creds: Credentials = fsx::read_json(&root.join("Settings/database.json"))
|
||||
.map_err(|_| Error::Invalid("The database settings of this server could not be read.".into()))?;
|
||||
let ports: Ports = read_ports(root);
|
||||
if crate::docker::is_docker(root) {
|
||||
return Db::in_container(root, creds, account);
|
||||
}
|
||||
let bin = root.join("mysql/bin");
|
||||
if !bin.join("mysqldump.exe").is_file() || !bin.join("mysql.exe").is_file() {
|
||||
return Err(Error::Invalid("The bundled database tools are missing.".into()));
|
||||
@@ -97,10 +104,24 @@ impl Db {
|
||||
Account::Admin => ("root", creds.root_password),
|
||||
Account::App => ("acore", creds.app_password),
|
||||
};
|
||||
Ok(Db { bin, port: ports.mysql, user, password: Secret(password), realm: crate::realms::state(root)?.active })
|
||||
Ok(Db { bin, port: ports.mysql, user, password: Secret(password), realm: crate::realms::state(root)?.active, container: None })
|
||||
}
|
||||
|
||||
/// The database of a Docker installation: the client tools of the database image, run with `docker exec`. The
|
||||
/// database is not published on the host, so nothing about this depends on a port or on tools installed here.
|
||||
fn in_container(root: &Path, creds: Credentials, account: Account) -> Result<Db> {
|
||||
let container = crate::docker::Config::load(root)?.database_container();
|
||||
let (user, password) = match account {
|
||||
Account::Admin => ("root", creds.root_password),
|
||||
Account::App => ("acore", creds.app_password),
|
||||
};
|
||||
// Inside the container the server listens on its standard port; the commands below connect to it over TCP on
|
||||
// the container's own loopback, exactly like the commands of a repack do on the host.
|
||||
Ok(Db { bin: PathBuf::new(), port: 3306, user, password: Secret(password), realm: crate::realms::state(root)?.active, container: Some(container) })
|
||||
}
|
||||
|
||||
pub fn for_realm(mut self, realm: crate::realms::Mode) -> Self { self.realm = realm; self }
|
||||
pub fn realm(&self) -> crate::realms::Mode { self.realm }
|
||||
|
||||
pub fn realm_schema<'a>(&self, name: &'a str) -> &'a str {
|
||||
if self.realm == crate::realms::Mode::Wildcard {
|
||||
@@ -132,7 +153,15 @@ impl Db {
|
||||
}
|
||||
|
||||
fn command(&self, tool: &str) -> Command {
|
||||
let mut c = Command::new(self.bin.join(tool));
|
||||
let mut c = match &self.container {
|
||||
None => Command::new(self.bin.join(tool)),
|
||||
Some(name) => {
|
||||
// `-e MYSQL_PWD` without a value takes it from this process's environment: never on a command line.
|
||||
let mut c = Command::new("docker");
|
||||
c.args(["exec", "-i", "-e", "MYSQL_PWD", name, tool.trim_end_matches(".exe")]);
|
||||
c
|
||||
}
|
||||
};
|
||||
c.env("MYSQL_PWD", self.password.expose())
|
||||
.arg("--protocol=tcp")
|
||||
.arg("--host=127.0.0.1")
|
||||
@@ -147,9 +176,13 @@ impl Db {
|
||||
|
||||
fn fail(&self, stderr: &[u8]) -> Error {
|
||||
let text = String::from_utf8_lossy(stderr);
|
||||
let code = if text.contains("2003") || text.contains("Can't connect") { ErrorCode::DatabaseNotRunning } else { ErrorCode::Unknown };
|
||||
// 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(""))),
|
||||
}
|
||||
}
|
||||
@@ -214,6 +247,13 @@ impl Db {
|
||||
self.query(&sql)?.trim().parse().map_err(|_| Error::Invalid("unexpected reply".into()))
|
||||
}
|
||||
|
||||
pub fn recovery_objects(&self, schema: &str) -> Result<Vec<serde_json::Value>> {
|
||||
let schema = self.realm_schema(schema);
|
||||
if !ident_ok(schema) { return Err(Error::Invalid("bad schema name".into())); }
|
||||
let sql = format!("SELECT routine_type,HEX(routine_name) FROM information_schema.routines WHERE routine_schema='{schema}' UNION ALL SELECT 'TRIGGER',HEX(trigger_name) FROM information_schema.triggers WHERE trigger_schema='{schema}' UNION ALL SELECT 'VIEW',HEX(table_name) FROM information_schema.views WHERE table_schema='{schema}' ORDER BY 1,2;");
|
||||
parse_recovery_objects(&schema, &self.query(&sql)?)
|
||||
}
|
||||
|
||||
/// Consistent dump of one schema, zstd-compressed to `out`. Returns (compressed bytes, sha256 of the file).
|
||||
pub fn dump_to(&self, schema: &str, out: &Path) -> Result<(u64, String)> {
|
||||
let schema = self.realm_schema(schema);
|
||||
@@ -301,6 +341,18 @@ impl Db {
|
||||
}
|
||||
}
|
||||
|
||||
fn parse_recovery_objects(schema: &str, text: &str) -> Result<Vec<serde_json::Value>> {
|
||||
text.lines().filter(|line| !line.is_empty()).map(|line| {
|
||||
let (kind, name) = line.split_once('\t').ok_or_else(|| Error::Invalid("unexpected database object reply".into()))?;
|
||||
if !matches!(kind, "PROCEDURE" | "FUNCTION" | "TRIGGER" | "VIEW") {
|
||||
return Err(Error::Invalid("unexpected database object type".into()));
|
||||
}
|
||||
let name = hex::decode(name).ok().and_then(|bytes| String::from_utf8(bytes).ok())
|
||||
.filter(|name| !name.is_empty()).ok_or_else(|| Error::Invalid("unexpected database object name".into()))?;
|
||||
Ok(serde_json::json!({ "database": schema, "kind": kind, "name": name }))
|
||||
}).collect()
|
||||
}
|
||||
|
||||
/// Name of the service account the Manager uses for the server console (RA). Accounts are stored upper-case.
|
||||
pub const SERVICE_ACCOUNT: &str = "COAMANAGER";
|
||||
|
||||
@@ -379,3 +431,99 @@ mod realm_tests {
|
||||
assert_eq!(route_sql(sql, crate::realms::Mode::Wildcard), "SELECT * FROM `acore_characters_wildcard`.characters WHERE name='acore_world' AND x=\"acore_characters\"; -- acore_world\nSELECT * FROM acore_world_wildcard.items;");
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use std::ffi::OsStr;
|
||||
|
||||
const ROOT_PW: &str = "rootpw-ZZ1";
|
||||
const APP_PW: &str = "apppw-QQ2";
|
||||
|
||||
#[test]
|
||||
fn recovery_object_names_preserve_unicode_and_delimiters() {
|
||||
let name = "view\tперсонажи\n";
|
||||
let text = format!("VIEW\t{}\nTRIGGER\t74726967676572\n", hex::encode(name));
|
||||
let objects = parse_recovery_objects("acore_characters", &text).unwrap();
|
||||
assert_eq!(objects.len(), 2);
|
||||
assert_eq!(objects[0]["name"], name);
|
||||
assert_eq!(objects[1]["kind"], "TRIGGER");
|
||||
assert!(parse_recovery_objects("test", "VIEW\tzz").is_err());
|
||||
assert!(parse_recovery_objects("test", "UNKNOWN\t61").is_err());
|
||||
assert!(parse_recovery_objects("test", "VIEW").is_err());
|
||||
}
|
||||
|
||||
fn folder(docker: bool) -> (tempfile::TempDir, PathBuf) {
|
||||
let d = tempfile::tempdir().unwrap();
|
||||
let root = d.path().join("srv");
|
||||
std::fs::create_dir_all(root.join("Settings")).unwrap();
|
||||
std::fs::write(root.join("Settings/database.json"), format!(r#"{{"rootPassword":"{ROOT_PW}","appPassword":"{APP_PW}"}}"#)).unwrap();
|
||||
if docker {
|
||||
std::fs::write(root.join("Settings/docker.json"), r#"{"project":"t1"}"#).unwrap();
|
||||
}
|
||||
(d, root)
|
||||
}
|
||||
|
||||
fn args(c: &Command) -> Vec<String> {
|
||||
c.get_args().map(|a| a.to_string_lossy().into_owned()).collect()
|
||||
}
|
||||
|
||||
fn env_of(c: &Command, key: &str) -> Option<String> {
|
||||
c.get_envs().find(|(k, _)| *k == OsStr::new(key)).and_then(|(_, v)| v.map(|v| v.to_string_lossy().into_owned()))
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_docker_installation_runs_the_client_tools_inside_the_database_container() {
|
||||
let (_d, root) = folder(true);
|
||||
let db = Db::from_repack(&root, Account::Admin).unwrap();
|
||||
for (tool, program) in [("mysql.exe", "mysql"), ("mysqldump.exe", "mysqldump"), ("mysqladmin.exe", "mysqladmin")] {
|
||||
let c = db.command(tool);
|
||||
assert_eq!(c.get_program(), "docker");
|
||||
let a = args(&c);
|
||||
assert_eq!(&a[..6], ["exec", "-i", "-e", "MYSQL_PWD", "coa-t1-db", program]);
|
||||
assert!(a.contains(&"--protocol=tcp".to_string()) && a.contains(&"--host=127.0.0.1".to_string()) && a.contains(&"--port=3306".to_string()));
|
||||
assert!(a.contains(&"--user=root".to_string()));
|
||||
assert!(a.iter().all(|x| !x.contains(ROOT_PW)), "the password must not be on the command line");
|
||||
assert_eq!(env_of(&c, "MYSQL_PWD").as_deref(), Some(ROOT_PW));
|
||||
}
|
||||
let app = Db::from_repack(&root, Account::App).unwrap().command("mysql.exe");
|
||||
assert!(args(&app).contains(&"--user=acore".to_string()));
|
||||
assert_eq!(env_of(&app, "MYSQL_PWD").as_deref(), Some(APP_PW));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_repack_still_uses_its_bundled_tools_on_the_host() {
|
||||
let (_d, root) = folder(false);
|
||||
std::fs::create_dir_all(root.join("mysql/bin")).unwrap();
|
||||
for f in ["mysql.exe", "mysqldump.exe"] {
|
||||
std::fs::write(root.join("mysql/bin").join(f), b"x").unwrap();
|
||||
}
|
||||
std::fs::write(root.join("Settings/repack.json"), r#"{"mysqlPort":3999}"#).unwrap();
|
||||
let c = Db::from_repack(&root, Account::Admin).unwrap().command("mysql.exe");
|
||||
assert_eq!(c.get_program(), root.join("mysql/bin").join("mysql.exe").as_os_str());
|
||||
let a = args(&c);
|
||||
assert!(!a.contains(&"exec".to_string()));
|
||||
assert!(a.contains(&"--port=3999".to_string()) && a.contains(&"--host=127.0.0.1".to_string()));
|
||||
assert_eq!(env_of(&c, "MYSQL_PWD").as_deref(), Some(ROOT_PW));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_docker_installation_does_not_need_tools_in_the_server_folder() {
|
||||
let (_d, root) = folder(true);
|
||||
assert!(!root.join("mysql").exists());
|
||||
assert!(Db::from_repack(&root, Account::Admin).is_ok());
|
||||
// ...but a broken Docker settings file is reported, not ignored.
|
||||
std::fs::write(root.join("Settings/docker.json"), r#"{"project":"Bad Name"}"#).unwrap();
|
||||
assert!(Db::from_repack(&root, Account::Admin).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_stopped_database_container_is_reported_as_a_database_that_is_not_running() {
|
||||
let (_d, root) = folder(true);
|
||||
let db = Db::from_repack(&root, Account::Admin).unwrap();
|
||||
for text in ["Error response from daemon: container abc is not running", "Error response from daemon: No such container: coa-t1-db", "ERROR 2003 (HY000): Can't connect to MySQL server"] {
|
||||
assert!(db.fail(text.as_bytes()).to_string().contains("not running"), "{text}");
|
||||
}
|
||||
assert!(db.fail(b"ERROR 1045 (28000): Access denied for user 'root'").to_string().contains("Access denied"));
|
||||
}
|
||||
}
|
||||
+293
-6
@@ -64,7 +64,9 @@ pub fn run(root: &Path, meta: &InstallMeta) -> Report {
|
||||
|
||||
let ports = layout::read_ports(root);
|
||||
let o = process::observe(root, &ports);
|
||||
for (title, s) in [("Database", &o.mysql), ("Login server", &o.auth), ("World server", &o.world)] {
|
||||
let mut services = vec![("Database", &o.mysql), ("Login server", &o.auth), ("World server", &o.world)];
|
||||
if let Some(second) = &o.secondary_world { services.push(("Second world", second)); }
|
||||
for (title, s) in services {
|
||||
let (lvl, text) = match (s.state, &s.conflict) {
|
||||
(ServiceState::Running, _) => (Level::Ok, "Running".to_string()),
|
||||
(_, Some(conf)) => (Level::Fail, format!("Port {} is used by another program (process {}).", conf.port, conf.pid)),
|
||||
@@ -124,6 +126,8 @@ pub struct FileProblem {
|
||||
pub fn verify_managed(root: &Path, meta: &InstallMeta) -> Vec<FileProblem> {
|
||||
let mut out = Vec::new();
|
||||
for (rel, want) in &meta.original_hashes {
|
||||
let lower = rel.replace('\\', "/").to_lowercase();
|
||||
if lower.starts_with("mysql/data/") || lower.starts_with("settings/") || lower.starts_with("core/configs/") && !lower.ends_with(".dist") { continue; }
|
||||
let Ok(p) = fsx::safe_join(root, rel) else { continue };
|
||||
match fsx::sha256_file(&p) {
|
||||
Err(_) => out.push(FileProblem { path: rel.clone(), kind: "missing" }),
|
||||
@@ -168,19 +172,158 @@ pub fn squash_repeated_config_warnings(text: &str) -> String {
|
||||
s
|
||||
}
|
||||
|
||||
const SENSITIVE: [&str; 7] = ["password", "passwd", "secret", "token", "apikey", "api_key", "databaseinfo"];
|
||||
|
||||
/// Remove things that must never leave the machine from log text.
|
||||
pub fn redact(text: &str) -> String {
|
||||
let mut out = Vec::new();
|
||||
for line in text.lines() {
|
||||
let l = line.to_lowercase();
|
||||
let sensitive = ["password", "passwd", "secret", "token", "apikey", "api_key", "databaseinfo"].iter().any(|k| l.contains(k));
|
||||
let sensitive = SENSITIVE.iter().any(|k| l.contains(k));
|
||||
out.push(if sensitive { "[line removed: may contain a secret]".to_string() } else { line.to_string() });
|
||||
}
|
||||
out.join("\n")
|
||||
}
|
||||
|
||||
/// The same for JSON: values under a sensitive key and strings that look like `password=...` are replaced, and the
|
||||
/// result stays valid JSON (removing a whole line would break the file for whoever reads it). Text that is not JSON
|
||||
/// falls back to the line rule.
|
||||
pub fn redact_json(text: &str) -> String {
|
||||
fn scrub(v: &mut serde_json::Value) {
|
||||
use serde_json::Value;
|
||||
match v {
|
||||
Value::Object(map) => {
|
||||
for (key, value) in map.iter_mut() {
|
||||
let k = key.to_lowercase();
|
||||
if SENSITIVE.iter().any(|s| k.contains(s)) && !value.is_object() && !value.is_array() {
|
||||
*value = Value::String("[redacted]".into());
|
||||
} else {
|
||||
scrub(value);
|
||||
}
|
||||
}
|
||||
}
|
||||
Value::Array(items) => items.iter_mut().for_each(scrub),
|
||||
Value::String(s) => {
|
||||
let l = s.to_lowercase();
|
||||
if ["password=", "passwd=", "secret=", "token=", "apikey=", "api_key=", "password:"].iter().any(|k| l.contains(k)) {
|
||||
*s = "[redacted]".into();
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
match serde_json::from_str::<serde_json::Value>(text) {
|
||||
Ok(mut v) => {
|
||||
scrub(&mut v);
|
||||
serde_json::to_string_pretty(&v).unwrap_or_else(|_| redact(text))
|
||||
}
|
||||
Err(_) => redact(text),
|
||||
}
|
||||
}
|
||||
|
||||
/// Keep the events of a `wevtutil ... /f:text` listing that mention one of `needles` (compared without case), in the
|
||||
/// order listed, at most `max` of them.
|
||||
pub fn filter_event_blocks(listing: &str, needles: &[&str], max: usize) -> String {
|
||||
let mut blocks: Vec<Vec<&str>> = Vec::new();
|
||||
for line in listing.lines() {
|
||||
if line.starts_with("Event[") || blocks.is_empty() {
|
||||
blocks.push(Vec::new());
|
||||
}
|
||||
if let Some(b) = blocks.last_mut() { b.push(line); }
|
||||
}
|
||||
blocks
|
||||
.into_iter()
|
||||
.map(|b| b.join("\n"))
|
||||
.filter(|b| { let l = b.to_lowercase(); needles.iter().any(|n| l.contains(n)) })
|
||||
.take(max)
|
||||
.collect::<Vec<_>>()
|
||||
.join("\n\n")
|
||||
}
|
||||
|
||||
/// Drop the lines of an event listing that name the person or the computer.
|
||||
pub fn drop_identity_lines(listing: &str) -> String {
|
||||
listing
|
||||
.lines()
|
||||
.filter(|l| { let t = l.trim_start(); !(t.starts_with("User:") || t.starts_with("User Name:") || t.starts_with("Computer:")) })
|
||||
.collect::<Vec<_>>()
|
||||
.join("\n")
|
||||
}
|
||||
|
||||
/// `wevtutil /uni:true` writes UTF-16 with a byte order mark; anything else is read as UTF-8 (lossy).
|
||||
fn decode_console_output(bytes: &[u8]) -> String {
|
||||
if bytes.starts_with(&[0xFF, 0xFE]) {
|
||||
let units: Vec<u16> = bytes[2..].chunks_exact(2).map(|c| u16::from_le_bytes([c[0], c[1]])).collect();
|
||||
String::from_utf16_lossy(&units)
|
||||
} else {
|
||||
String::from_utf8_lossy(bytes).into_owned()
|
||||
}
|
||||
}
|
||||
|
||||
/// Crashes and hangs Windows recorded for the server programs in the last two weeks. This is the only trace of a crash
|
||||
/// that ends the process without the server's own crash report (a stack buffer overrun, for example). The lines that
|
||||
/// name the user and the computer are left out.
|
||||
#[cfg(windows)]
|
||||
fn windows_events() -> String {
|
||||
use std::os::windows::process::CommandExt;
|
||||
let query = "*[System[(Provider[@Name='Application Error' or @Name='Windows Error Reporting' or @Name='Application Hang']) and TimeCreated[timediff(@SystemTime) <= 1209600000]]]";
|
||||
let out = std::process::Command::new("wevtutil")
|
||||
.args(["qe", "Application", &format!("/q:{query}"), "/c:300", "/rd:true", "/f:text", "/uni:true"])
|
||||
.creation_flags(0x0800_0000)
|
||||
.output();
|
||||
match out {
|
||||
Ok(o) if o.status.success() => {
|
||||
let text = filter_event_blocks(&decode_console_output(&o.stdout), &["worldserver", "authserver", "mysqld", "coa server manager", "coa-server-manager"], 40);
|
||||
if text.is_empty() { "No crash or hang of the server programs was recorded by Windows in the last 14 days.".into() } else { drop_identity_lines(&text) }
|
||||
}
|
||||
Ok(o) => format!("Windows event log could not be read: {}", decode_console_output(&o.stderr).trim()),
|
||||
Err(e) => format!("Windows event log could not be read: {e}"),
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(not(windows))]
|
||||
fn windows_events() -> String {
|
||||
String::new()
|
||||
}
|
||||
|
||||
/// Newest files of a folder with the given extension (compared without case): path, size, modified time.
|
||||
fn newest_files(dir: &Path, ext: &str, limit: usize) -> Vec<(PathBuf, u64, std::time::SystemTime)> {
|
||||
let Ok(rd) = fs::read_dir(dir) else { return Vec::new() };
|
||||
let mut v: Vec<_> = rd
|
||||
.flatten()
|
||||
.filter(|e| e.path().extension().is_some_and(|x| x.eq_ignore_ascii_case(ext)))
|
||||
.filter_map(|e| { let m = e.metadata().ok()?; m.is_file().then(|| (e.path(), m.len(), m.modified().unwrap_or(std::time::UNIX_EPOCH))) })
|
||||
.collect();
|
||||
v.sort_by(|a, b| b.2.cmp(&a.2));
|
||||
v.truncate(limit);
|
||||
v
|
||||
}
|
||||
|
||||
/// Which server programs run right now and from where, next to what the Manager made of it. A program started from a
|
||||
/// folder or a copy the Manager does not know shows up here even when the Manager reports "port in use".
|
||||
fn processes_report(root: &Path, ports: &layout::Ports) -> String {
|
||||
let here = root.to_string_lossy().to_lowercase().replace('/', "\\");
|
||||
let listen = process::listeners_detailed();
|
||||
let mut out = String::from("Server programs running now (any folder):\n");
|
||||
let found = process::find_by_file_names(&["worldserver.exe", "authserver.exe", "mysqld.exe"]);
|
||||
if found.is_empty() { out.push_str(" none\n"); }
|
||||
for p in found {
|
||||
let ports_of: Vec<String> = listen.iter().filter(|l| l.pid == p.pid).map(|l| l.port.to_string()).collect();
|
||||
let inside = p.exe.to_lowercase().replace('/', "\\").starts_with(&here);
|
||||
out.push_str(&format!(" pid {} {} | listening on: {} | {}\n", p.pid, p.exe, if ports_of.is_empty() { "-".into() } else { ports_of.join(", ") }, if inside { "inside this server folder" } else { "OUTSIDE this server folder" }));
|
||||
}
|
||||
let o = process::observe(root, ports);
|
||||
out.push_str("\nThe Manager's view:\n");
|
||||
for s in [Some(&o.mysql), Some(&o.auth), Some(&o.world), o.secondary_world.as_ref()].into_iter().flatten() {
|
||||
out.push_str(&format!(" {:<16} {:?} port {} {}{}\n", s.name, s.state, s.port, s.pid.map(|p| format!("pid {p}")).unwrap_or_default(), s.conflict.as_ref().map(|c| format!(" | port held by pid {} {}", c.pid, c.exe.clone().unwrap_or_default())).unwrap_or_default()));
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Zip with what a maintainer needs to debug a problem, with secrets removed. Returns the number of files inside.
|
||||
/// One call collects everything: the Manager's and the server's logs, crash reports and small crash dumps, Windows'
|
||||
/// own record of crashes, the update journals, the running server programs and the settings the client depends on.
|
||||
pub fn export_package(root: &Path, meta_dir: &Path, manager_log: &Path, meta: &InstallMeta, report: &Report, out_zip: &Path) -> Result<usize> {
|
||||
const DUMP_FILE_MAX: u64 = 30 * 1024 * 1024;
|
||||
let file = fs::File::create(out_zip)?;
|
||||
let mut zip = zip::ZipWriter::new(file);
|
||||
let opts = zip::write::SimpleFileOptions::default().compression_method(zip::CompressionMethod::Deflated);
|
||||
@@ -191,17 +334,38 @@ pub fn export_package(root: &Path, meta_dir: &Path, manager_log: &Path, meta: &I
|
||||
n += 1;
|
||||
Ok(())
|
||||
};
|
||||
let ports = layout::read_ports(root);
|
||||
let summary = serde_json::json!({
|
||||
"manager": crate::MANAGER_VERSION,
|
||||
"exported_utc": chrono::Utc::now().to_rfc3339(),
|
||||
"core": meta.core,
|
||||
"bots": meta.bots,
|
||||
"squid_bots": crate::squid::release(root),
|
||||
"kind": meta.kind,
|
||||
"layout": meta.layout,
|
||||
"checks": report.checks,
|
||||
"wow_client_set": meta.client_path.is_some(),
|
||||
});
|
||||
add("summary.json", serde_json::to_string_pretty(&summary)?.as_bytes())?;
|
||||
for (name, path) in [("manager.log", manager_log.to_path_buf()), ("manager-install.log", meta_dir.join("logs/manager.log")), ("Server.log.tail", root.join("Core/Logs/Server.log")), ("Errors.log.tail", root.join("Core/Logs/Errors.log")), ("Auth.log.tail", root.join("Core/Logs/Auth.log")), ("world-console.log.tail", root.join("Core/Logs/world-console.log")), ("mysql-error.log.tail", root.join("mysql/logs/mysql-error.log"))] {
|
||||
|
||||
// Logs. The newest update logs of the repack's own updater are added under their own names.
|
||||
let mut logs: Vec<(String, PathBuf)> = vec![
|
||||
("manager.log".into(), manager_log.to_path_buf()),
|
||||
("manager-install.log".into(), meta_dir.join("logs/manager.log")),
|
||||
("Server.log.tail".into(), root.join("Core/Logs/Server.log")),
|
||||
("Errors.log.tail".into(), root.join("Core/Logs/Errors.log")),
|
||||
("Auth.log.tail".into(), root.join("Core/Logs/Auth.log")),
|
||||
("world-console.log.tail".into(), root.join("Core/Logs/world-console.log")),
|
||||
("CoaBots.log.tail".into(), root.join("Core/Logs/CoaBots.log")),
|
||||
("Playerbots.log.tail".into(), root.join("Core/Logs/Playerbots.log")),
|
||||
("supervisor.log.tail".into(), root.join("Core/Logs/supervisor.log")),
|
||||
("mysql-error.log.tail".into(), root.join("mysql/logs/mysql-error.log")),
|
||||
];
|
||||
let updater_logs = newest_files(&root.join("Core/Logs"), "log", usize::MAX).into_iter().filter(|(p, _, _)| p.file_name().is_some_and(|f| f.to_string_lossy().to_lowercase().starts_with("update-")));
|
||||
for (p, _, _) in updater_logs.take(2) {
|
||||
logs.push((format!("{}.tail", p.file_name().unwrap_or_default().to_string_lossy()), p));
|
||||
}
|
||||
for (name, path) in logs {
|
||||
// A module that reads a missing setting on every tick fills a log with one warning, thousands of times; read far
|
||||
// enough back to see past that, fold the repeats, then keep the last part.
|
||||
let bytes = tail(&path, 8 * 1024 * 1024);
|
||||
@@ -209,9 +373,57 @@ pub fn export_package(root: &Path, meta_dir: &Path, manager_log: &Path, meta: &I
|
||||
let text = squash_repeated_config_warnings(&String::from_utf8_lossy(&bytes));
|
||||
let keep = text.len().saturating_sub(512 * 1024);
|
||||
let start = (keep..text.len()).find(|i| text.is_char_boundary(*i)).unwrap_or(text.len());
|
||||
add(name, redact(&text[start..]).as_bytes())?;
|
||||
add(&name, redact(&text[start..]).as_bytes())?;
|
||||
}
|
||||
}
|
||||
|
||||
// Crash reports of the server (text, and the small dumps next to them), and what Windows recorded for the programs.
|
||||
let crashes = root.join("Core/Crashes");
|
||||
let mut listing = String::new();
|
||||
for (p, len, _) in newest_files(&crashes, "txt", 10) {
|
||||
let name = p.file_name().unwrap_or_default().to_string_lossy().into_owned();
|
||||
listing.push_str(&format!("{name} ({len} bytes)\n"));
|
||||
let text = String::from_utf8_lossy(&tail(&p, 1024 * 1024)).into_owned();
|
||||
add(&format!("crashes/{name}"), redact(&text).as_bytes())?;
|
||||
}
|
||||
for (p, len, _) in newest_files(&crashes, "dmp", 3) {
|
||||
let name = p.file_name().unwrap_or_default().to_string_lossy().into_owned();
|
||||
if len > DUMP_FILE_MAX {
|
||||
listing.push_str(&format!("{name} ({len} bytes) not included: larger than {} MB\n", DUMP_FILE_MAX >> 20));
|
||||
} else if let Ok(bytes) = fs::read(&p) {
|
||||
listing.push_str(&format!("{name} ({len} bytes) included\n"));
|
||||
add(&format!("crashes/{name}"), &bytes)?;
|
||||
}
|
||||
}
|
||||
add("crashes.txt", if listing.is_empty() { "No crash reports in Core/Crashes.".to_string() } else { listing }.as_bytes())?;
|
||||
let events = windows_events();
|
||||
if !events.is_empty() { add("windows-events.txt", events.as_bytes())?; }
|
||||
add("processes.txt", processes_report(root, &ports).as_bytes())?;
|
||||
|
||||
// The newest update journals: the state of each update and the reason it failed.
|
||||
for (path, size, _) in newest_files(&meta_dir.join("diagnostics"), "json", usize::MAX)
|
||||
.into_iter().filter(|(path, _, _)| path.file_name().is_some_and(|name| {
|
||||
let name = name.to_string_lossy();
|
||||
name.starts_with("schema-validation-") || name.starts_with("database-recovery-")
|
||||
|| name.starts_with("database-rehearsal-") || name.starts_with("database-restore-")
|
||||
|| name.starts_with("database-repair-")
|
||||
})).take(10) {
|
||||
if size <= 4 * 1024 * 1024 {
|
||||
if let Ok(text) = fs::read_to_string(&path) {
|
||||
add(&format!("schema/{}", path.file_name().unwrap().to_string_lossy()), redact_json(&text).as_bytes())?;
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut journals: Vec<_> = fs::read_dir(meta_dir.join("updates")).into_iter().flatten().flatten()
|
||||
.filter(|e| e.file_type().is_ok_and(|t| t.is_dir()) && e.file_name().to_string_lossy().chars().all(|c| c.is_ascii_alphanumeric() || matches!(c, '-' | '_')))
|
||||
.collect();
|
||||
journals.sort_by_key(|e| std::cmp::Reverse(e.file_name()));
|
||||
for e in journals.into_iter().take(5) {
|
||||
if let Ok(text) = fs::read_to_string(e.path().join("txn.json")) {
|
||||
add(&format!("updates/{}-txn.json", e.file_name().to_string_lossy()), redact_json(&text).as_bytes())?;
|
||||
}
|
||||
}
|
||||
|
||||
// Which files the server's own configuration folders hold, and the two CoA switches that decide whether the game
|
||||
// client can talk to the world server at all.
|
||||
let mut present = String::new();
|
||||
@@ -239,7 +451,10 @@ pub fn export_package(root: &Path, meta_dir: &Path, manager_log: &Path, meta: &I
|
||||
}
|
||||
}
|
||||
if let Ok(b) = fs::read(root.join("RELEASE.json")) {
|
||||
add("RELEASE.json", redact(&String::from_utf8_lossy(&b)).as_bytes())?;
|
||||
add("RELEASE.json", redact_json(&String::from_utf8_lossy(&b)).as_bytes())?;
|
||||
}
|
||||
if let Ok(b) = fs::read(meta_dir.join("logs/database-checks.json")) {
|
||||
add("database-checks.json", redact_json(&String::from_utf8_lossy(&b)).as_bytes())?;
|
||||
}
|
||||
zip.finish().map_err(|e| Error::Invalid(e.to_string()))?;
|
||||
Ok(n)
|
||||
@@ -281,6 +496,68 @@ real error
|
||||
assert!(!t.contains("PASS") && !t.contains("abc"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn json_redaction_keeps_the_file_valid_and_hides_the_secrets() {
|
||||
let t = redact_json(r#"{"id":"rev_20261006_token_cache","password":"hunter2","nested":{"apiKey":"k","note":"login with password=abc"},"list":[{"secret":1},"ok"]}"#);
|
||||
let v: serde_json::Value = serde_json::from_str(&t).expect("still JSON");
|
||||
assert_eq!(v["id"], "rev_20261006_token_cache", "an id that merely contains a word is kept");
|
||||
assert_eq!(v["password"], "[redacted]");
|
||||
assert_eq!(v["nested"]["apiKey"], "[redacted]");
|
||||
assert_eq!(v["nested"]["note"], "[redacted]");
|
||||
assert_eq!(v["list"][0]["secret"], "[redacted]");
|
||||
assert_eq!(v["list"][1], "ok");
|
||||
assert!(!t.contains("hunter2") && !t.contains("abc"));
|
||||
assert!(redact_json("not json\nPassword=1").contains("[line removed"), "text falls back to the line rule");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn windows_events_are_filtered_to_the_server_programs() {
|
||||
let listing = "Event[0]:\n Provider Name: Application Error\n Description: Faulting application name: worldserver.exe, version: 0.0.0.0\n\nEvent[1]:\n Provider Name: Application Error\n Description: Faulting application name: notepad.exe\n\nEvent[2]:\n Description: Faulting application name: MYSQLD.EXE\n";
|
||||
let out = filter_event_blocks(listing, &["worldserver", "mysqld"], 10);
|
||||
assert!(out.contains("worldserver.exe") && out.contains("MYSQLD.EXE") && !out.contains("notepad"));
|
||||
assert_eq!(filter_event_blocks(listing, &["worldserver", "mysqld"], 1).matches("Event[").count(), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn event_text_loses_the_user_and_computer_lines_and_reads_utf16() {
|
||||
let out = drop_identity_lines("Event[0]\n Source: Application Error\n User: S-1-5-21-1\n User Name: PC\\Dion\n Computer: PC\n Description: worldserver.exe");
|
||||
assert!(out.contains("Source") && out.contains("worldserver.exe"));
|
||||
assert!(!out.contains("S-1-5") && !out.contains("Dion") && !out.contains("Computer"));
|
||||
let mut bytes = vec![0xFF, 0xFE];
|
||||
for u in "Сбой worldserver".encode_utf16() { bytes.extend_from_slice(&u.to_le_bytes()); }
|
||||
assert_eq!(decode_console_output(&bytes), "Сбой worldserver");
|
||||
assert_eq!(decode_console_output(b"plain"), "plain");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_package_carries_crash_reports_update_journals_and_the_process_view() {
|
||||
let d = tempfile::tempdir().unwrap();
|
||||
let root = d.path().join("srv");
|
||||
layout::testkit::fake_repack(&root);
|
||||
fs::create_dir_all(root.join("Core/Crashes")).unwrap();
|
||||
fs::write(root.join("Core/Crashes/567e_worldserver.exe_[4-10_21-25-31].txt"), "Exception code: C0000005\nRCX:0\n").unwrap();
|
||||
fs::write(root.join("Core/Crashes/567e_worldserver.exe_[4-10_21-25-31].dmp"), b"MDMP-small").unwrap();
|
||||
fs::write(root.join("Core/Logs/CoaBots.log"), "bot line\n").unwrap();
|
||||
fs::write(root.join("Core/Logs/update-1.8-20261005.log"), "updater line\n").unwrap();
|
||||
let meta_dir = d.path().join("srv.manager");
|
||||
fs::create_dir_all(meta_dir.join("updates/20261006-082021-0_261006_1-abc")).unwrap();
|
||||
fs::write(meta_dir.join("updates/20261006-082021-0_261006_1-abc/txn.json"), r#"{"state":"rolled-back","message":"Database update 2026_02_24_00 failed: duplicate column"}"#).unwrap();
|
||||
fs::create_dir_all(meta_dir.join("updates/not a journal!")).unwrap();
|
||||
let meta = InstallMeta::new(InstallKind::Imported, &root);
|
||||
let report = run(&root, &meta);
|
||||
let zip_path = d.path().join("diag.zip");
|
||||
export_package(&root, &meta_dir, &d.path().join("none.log"), &meta, &report, &zip_path).unwrap();
|
||||
let mut z = zip::ZipArchive::new(fs::File::open(&zip_path).unwrap()).unwrap();
|
||||
let names: Vec<String> = (0..z.len()).map(|i| z.by_index(i).unwrap().name().to_string()).collect();
|
||||
for want in ["crashes.txt", "processes.txt", "CoaBots.log.tail", "update-1.8-20261005.log.tail", "updates/20261006-082021-0_261006_1-abc-txn.json", "crashes/567e_worldserver.exe_[4-10_21-25-31].txt", "crashes/567e_worldserver.exe_[4-10_21-25-31].dmp"] {
|
||||
assert!(names.iter().any(|n| n == want), "{want} is in the package: {names:?}");
|
||||
}
|
||||
assert!(!names.iter().any(|n| n.contains("not a journal")));
|
||||
let mut listing = String::new();
|
||||
z.by_name("crashes.txt").unwrap().read_to_string(&mut listing).unwrap();
|
||||
assert!(listing.contains("included"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn verify_reports_missing_and_changed_managed_files_only() {
|
||||
let d = tempfile::tempdir().unwrap();
|
||||
@@ -316,10 +593,15 @@ real error
|
||||
let d = tempfile::tempdir().unwrap();
|
||||
let root = d.path().join("srv");
|
||||
layout::testkit::fake_repack(&root);
|
||||
fs::create_dir_all(root.join("Extras/SquidPlayerbots")).unwrap();
|
||||
fs::write(root.join("Extras/SquidPlayerbots/release.json"), r#"{"tag":"v1.8","commit":"48c4786a","password":"upstream-secret"}"#).unwrap();
|
||||
fs::write(root.join("Core/Logs/Errors.log"), "boom\nDatabase password=hunter2 rejected\n").unwrap();
|
||||
fs::write(root.join("Core/configs/worldserver.conf"), "LoginDatabaseInfo = \"127.0.0.1;3307;acore;SECRETPW;auth\"\nRate.XP.Kill = 1\n").unwrap();
|
||||
let meta_dir = d.path().join("srv.manager");
|
||||
fs::create_dir_all(&meta_dir).unwrap();
|
||||
fs::create_dir_all(meta_dir.join("diagnostics")).unwrap();
|
||||
fs::write(meta_dir.join("diagnostics/schema-validation-CoA-test.json"), r#"{"problems":[{"table":"creature_display_preset","column":"display_id","detail":"default mismatch"}],"password":"schema-secret"}"#).unwrap();
|
||||
fs::write(meta_dir.join("diagnostics/database-recovery-test.json"), r#"{"objects":[{"database":"acore_characters","kind":"TRIGGER","name":"user_character_trigger"}],"password":"recovery-secret"}"#).unwrap();
|
||||
let meta = InstallMeta::new(InstallKind::Imported, &root);
|
||||
let report = run(&root, &meta);
|
||||
let zip_path = d.path().join("diag.zip");
|
||||
@@ -333,6 +615,11 @@ real error
|
||||
all.push_str(&s);
|
||||
}
|
||||
assert!(all.contains("boom") && all.contains("Rate.XP.Kill"), "keys and ordinary log lines are included");
|
||||
assert!(!all.contains("hunter2") && !all.contains("SECRETPW"));
|
||||
assert!(all.contains("v1.8") && all.contains("48c4786a"));
|
||||
assert!(all.contains("creature_display_preset") && all.contains("default mismatch"));
|
||||
assert!(!all.contains("schema-secret"));
|
||||
assert!(all.contains("user_character_trigger") && all.contains("acore_characters"));
|
||||
assert!(!all.contains("recovery-secret"));
|
||||
assert!(!all.contains("hunter2") && !all.contains("SECRETPW") && !all.contains("upstream-secret"));
|
||||
}
|
||||
}
|
||||
@@ -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());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,574 @@
|
||||
//! Installing a new server as a Docker installation, from a Linux package.
|
||||
//!
|
||||
//! The order of events is the one of `install::install_base`: nothing appears at the destination until the package is
|
||||
//! signed-off, downloaded, verified, extracted and its database built, all of it in a sibling `<dest>.installing`
|
||||
//! folder. But this is code of its own: the Windows installer is not touched and nothing here is specific to the
|
||||
//! Windows layout. What both installers use is platform-neutral: the signed manifest, the download, the extraction,
|
||||
//! the migration ledger and the registry.
|
||||
//!
|
||||
//! The databases start from the package's own dumps (`Database/baseline/<kind>.sql.zst`, the format of the Manager's
|
||||
//! backups), as a Windows package starts from its prepared database: they hold the state in which every migration of the
|
||||
//! package is already applied, and the installer records them as such. They cannot be rebuilt from the repository's
|
||||
//! SQL files: some migrations are guards that only apply to the maintainers' own database. The game data is not part
|
||||
//! of the package: the person points at a folder they already have.
|
||||
|
||||
use std::fs;
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
use super::cli::{Docker, SystemDocker};
|
||||
use super::{Config, MARKER};
|
||||
use crate::db::{self, Account, Db};
|
||||
use crate::download::Cancel;
|
||||
use crate::driver::Verb;
|
||||
use crate::error::{Error, Result};
|
||||
use crate::fsx;
|
||||
use crate::install::{free_port, problem, random_hex, Installed, Preflight, Step};
|
||||
use crate::manifest::{self, Migration};
|
||||
use crate::migrations;
|
||||
use crate::package::BASELINE_DIR;
|
||||
use crate::pkgsource::{fetch_manifest, fetch_parts, Source};
|
||||
use crate::registry::{metadata_dir_for, InstallKind, InstallMeta, MetaDir, Registry, LAYOUT_DOCKER_V1};
|
||||
|
||||
/// Created in the staging folder so a leftover of an earlier attempt can be told from somebody else's folder.
|
||||
const STAGING_MARKER: &str = ".coa-installing";
|
||||
/// The three game databases: kind (the name of the dump), schema.
|
||||
const DATABASES: [(&str, &str); 3] = [("auth", "acore_auth"), ("characters", "acore_characters"), ("world", "acore_world")];
|
||||
/// Ports the game uses by default on this computer.
|
||||
const DEFAULT_PORTS: (u16, u16, u16) = (3724, 8085, 3443);
|
||||
|
||||
pub struct Params<'a> {
|
||||
pub source: Source,
|
||||
pub dest: PathBuf,
|
||||
/// A folder with the game data (dbc, maps, vmaps, mmaps) that the person already has. Used in place, read-only.
|
||||
pub data_dir: PathBuf,
|
||||
/// Public key to verify the manifest with (production: `signing::EMBEDDED_PUBLIC_KEY`).
|
||||
pub trusted_key: &'a str,
|
||||
pub registry: &'a Registry,
|
||||
pub cancel: Cancel,
|
||||
}
|
||||
|
||||
/// Checks whether `dest` and the game data folder are sensible for a new server on Linux.
|
||||
pub fn preflight(dest: &Path, data_dir: &Path, needed_bytes: u64, registry: &Registry) -> Preflight {
|
||||
let mut problems = Vec::new();
|
||||
let s = dest.to_string_lossy();
|
||||
|
||||
if !dest.is_absolute() {
|
||||
problems.push(problem("relative", "Choose a full folder path, such as /home/you/CoaServer."));
|
||||
}
|
||||
if s.contains(':') {
|
||||
problems.push(problem("colon", "Choose a folder whose path has no colon in it."));
|
||||
}
|
||||
let trimmed = s.trim_end_matches('/');
|
||||
const SYSTEM: [&str; 13] = ["", "/bin", "/boot", "/dev", "/etc", "/lib", "/lib64", "/proc", "/run", "/sbin", "/sys", "/usr", "/var"];
|
||||
if SYSTEM.iter().any(|p| trimmed == *p || (!p.is_empty() && trimmed.starts_with(&format!("{p}/")))) {
|
||||
problems.push(problem("system_folder", "Please choose a normal folder for your games, not a system location."));
|
||||
}
|
||||
if let Some(home) = std::env::var_os("HOME") {
|
||||
let home = home.to_string_lossy().trim_end_matches('/').to_string();
|
||||
let special = ["", "/Documents", "/Desktop", "/Downloads", "/Pictures", "/Music", "/Videos", "/.config", "/.local", "/.local/share"];
|
||||
if !home.is_empty() && special.iter().any(|sfx| trimmed == format!("{home}{sfx}")) {
|
||||
problems.push(problem("personal_folder", "This folder contains unrelated files. Choose another folder or create a new CoA Server folder."));
|
||||
}
|
||||
}
|
||||
|
||||
if dest.exists() {
|
||||
match fs::read_dir(dest) {
|
||||
Ok(mut rd) => {
|
||||
if rd.next().is_some() {
|
||||
match crate::layout::scan(dest).map(|r| r.classification) {
|
||||
Ok(crate::layout::Classification::Incompatible) | Err(_) => {
|
||||
if dest.join("Wow.exe").is_file() || dest.join("Ascension.exe").is_file() {
|
||||
problems.push(problem("client_folder", "This is a game client folder, not a place for a server."));
|
||||
} else {
|
||||
problems.push(problem("not_empty", "This folder contains unrelated files. Choose another folder or create a new CoA Server folder."));
|
||||
}
|
||||
}
|
||||
Ok(_) => problems.push(problem("already_server", "A server is already in this folder. Use \"I already have a server\" to add it instead.")),
|
||||
}
|
||||
}
|
||||
}
|
||||
Err(_) => problems.push(problem("unreadable", "This folder cannot be read. Choose another one.")),
|
||||
}
|
||||
}
|
||||
|
||||
if let Ok(list) = registry.list() {
|
||||
for (_, existing) in list {
|
||||
if let (Ok(a), Ok(b)) = (fsx::canonicalize_lenient(dest), fsx::canonicalize_lenient(&existing)) {
|
||||
if fsx::starts_with_ci(&a, &b) || fsx::starts_with_ci(&b, &a) {
|
||||
problems.push(problem("registered", "A server is already registered at or around this location."));
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
problems.extend(data_problems(data_dir));
|
||||
|
||||
let free_bytes = fsx::free_space(dest).unwrap_or(0);
|
||||
let need = needed_bytes.saturating_add(needed_bytes / 5).saturating_add(512 * 1024 * 1024);
|
||||
if free_bytes < need {
|
||||
problems.push(problem("space", &format!("Not enough free space: about {} GB needed, {} GB available.", need / (1 << 30) + 1, free_bytes / (1 << 30))));
|
||||
}
|
||||
Preflight { ok: problems.is_empty(), problems, free_bytes }
|
||||
}
|
||||
|
||||
fn data_problems(data_dir: &Path) -> Vec<crate::install::Problem> {
|
||||
let s = data_dir.to_string_lossy();
|
||||
if !data_dir.is_absolute() || s.contains(':') {
|
||||
return vec![problem("data_path", "Choose the game data folder with its full path, without a colon in it.")];
|
||||
}
|
||||
let missing: Vec<&str> = ["dbc", "maps"].into_iter().filter(|d| !data_dir.join(d).is_dir()).collect();
|
||||
if missing.is_empty() {
|
||||
Vec::new()
|
||||
} else {
|
||||
vec![problem("data_missing", &format!("This folder does not look like the game data: {} not found in it. It should hold dbc, maps, vmaps and mmaps.", missing.join(" and ")))]
|
||||
}
|
||||
}
|
||||
|
||||
/// Port the game should use: the usual one when it is free on this computer, else any free one.
|
||||
fn pick_port(preferred: u16) -> Result<u16> {
|
||||
if std::net::TcpListener::bind(("127.0.0.1", preferred)).is_ok() {
|
||||
Ok(preferred)
|
||||
} else {
|
||||
free_port()
|
||||
}
|
||||
}
|
||||
|
||||
/// Settings of a new installation: which containers belong to it, where the game data is, the ports, the passwords.
|
||||
/// Written before anything runs, so the database can be started from the staging folder.
|
||||
struct Settings {
|
||||
app_password: String,
|
||||
world_port: u16,
|
||||
}
|
||||
|
||||
fn write_settings(root: &Path, data_dir: &Path) -> Result<Settings> {
|
||||
let project = random_hex(10);
|
||||
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()), 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.
|
||||
fsx::atomic_write_json(
|
||||
&root.join("Settings/repack.json"),
|
||||
&serde_json::json!({ "mysqlPort": 3307, "authPort": auth, "worldPort": world, "raPort": ra, "raUsername": db::SERVICE_ACCOUNT, "raPassword": "" }),
|
||||
)?;
|
||||
let secrets = root.join("Settings/database.json");
|
||||
fsx::atomic_write_json(&secrets, &serde_json::json!({ "rootPassword": root_password, "appPassword": app_password }))?;
|
||||
#[cfg(unix)]
|
||||
{
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
fs::set_permissions(&secrets, fs::Permissions::from_mode(0o600))?;
|
||||
}
|
||||
Ok(Settings { app_password, world_port: world })
|
||||
}
|
||||
|
||||
/// The package must hold what a Docker installation is made of; say what is missing instead of failing later.
|
||||
fn check_extracted(root: &Path) -> Result<()> {
|
||||
let mut missing = Vec::new();
|
||||
for rel in ["Core/worldserver", "Core/authserver", "Core/configs/worldserver.conf.dist", "Core/configs/authserver.conf.dist"] {
|
||||
if !root.join(rel).is_file() {
|
||||
missing.push(rel.to_string());
|
||||
}
|
||||
}
|
||||
for (kind, _) in DATABASES {
|
||||
if !root.join(BASELINE_DIR).join(format!("{kind}.sql.zst")).is_file() {
|
||||
missing.push(format!("{BASELINE_DIR}/{kind}.sql.zst"));
|
||||
}
|
||||
}
|
||||
if missing.is_empty() {
|
||||
Ok(())
|
||||
} else {
|
||||
Err(Error::Invalid(format!("This package is not a complete Linux server package; missing: {}.", missing.join(", "))))
|
||||
}
|
||||
}
|
||||
|
||||
/// Record every migration of the package as applied without running it, in a few statements (one `docker exec` for each
|
||||
/// of more than a thousand would take minutes). Same ledger rows as `migrations::baseline`.
|
||||
fn baseline_statements(list: &[Migration]) -> Result<Vec<String>> {
|
||||
let ok = |t: &str| !t.is_empty() && t.len() <= 190 && t.chars().all(|c| c.is_ascii_alphanumeric() || matches!(c, '_' | '.' | '-'));
|
||||
let mut rows = Vec::with_capacity(list.len());
|
||||
for m in list {
|
||||
if !matches!(m.db.as_str(), "auth" | "characters" | "world") || !ok(&m.id) || m.sha256.len() != 64 || !m.sha256.chars().all(|c| c.is_ascii_hexdigit()) {
|
||||
return Err(Error::InvalidManifest(format!("migration {:?} is not valid", m.id)));
|
||||
}
|
||||
rows.push(format!("('{}','{}','{}','applied',NOW(),NULL,1)", m.db, m.id, m.sha256));
|
||||
}
|
||||
Ok(rows
|
||||
.chunks(400)
|
||||
.map(|c| format!("REPLACE INTO `acore_world`.`coa_manager_migrations` (`db`,`id`,`sha256`,`status`,`applied_at`,`error`,`baseline`) VALUES {};", c.join(",")))
|
||||
.collect())
|
||||
}
|
||||
|
||||
/// Create the three schemas and the game servers' account, load the starting databases and record the package's migrations
|
||||
/// as applied. The database container is started from `root` and stopped again by the caller.
|
||||
fn build_database(d: &dyn Docker, root: &Path, list: &[Migration], s: &Settings, say: &dyn Fn(u8, String)) -> Result<()> {
|
||||
let started = super::run_with(d, 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())));
|
||||
}
|
||||
let db = Db::from_repack(root, Account::Admin)?;
|
||||
let mut sql = String::new();
|
||||
for (_, schema) in DATABASES {
|
||||
sql.push_str(&format!("CREATE DATABASE `{schema}` CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;\n"));
|
||||
}
|
||||
// The pattern also covers the schemas of other realms (acore_world_wildcard, ...).
|
||||
sql.push_str(&format!("CREATE USER 'acore'@'%' IDENTIFIED BY '{}';\nGRANT ALL PRIVILEGES ON `acore\\_%`.* TO 'acore'@'%';\nFLUSH PRIVILEGES;\n", s.app_password));
|
||||
db.query(&sql)?;
|
||||
|
||||
for (i, (kind, schema)) in DATABASES.iter().enumerate() {
|
||||
say(83 + (i * 4) as u8, format!("Loading the {kind} database"));
|
||||
db.import_from(schema, &root.join(BASELINE_DIR).join(format!("{kind}.sql.zst")))?;
|
||||
}
|
||||
|
||||
say(95 - 3, format!("Recording {} database updates as applied", list.len()));
|
||||
// The ledger table is created by the first read of it.
|
||||
migrations::Store::load(&db)?;
|
||||
for statement in baseline_statements(list)? {
|
||||
db.query(&statement)?;
|
||||
}
|
||||
|
||||
// The realm advertises the port the game server really uses on this computer.
|
||||
db.query(&format!("UPDATE acore_auth.realmlist SET port={} WHERE id=1;", s.world_port))?;
|
||||
// The server console gets its own account with a random password.
|
||||
let console_pw = db.provision_service_account()?;
|
||||
db::write_console_credentials(root, &console_pw)?;
|
||||
if !Db::from_repack(root, Account::Admin)?.ping() {
|
||||
return Err(Error::Invalid("The database did not answer after it was set up.".into()));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn install(p: &Params, report: &dyn Fn(Step)) -> Result<Installed> {
|
||||
install_with(&SystemDocker, p, report)
|
||||
}
|
||||
|
||||
pub fn install_with(d: &dyn Docker, p: &Params, report: &dyn Fn(Step)) -> Result<Installed> {
|
||||
let say = |step: &'static str, percent: u8, detail: Option<String>| report(Step { step, percent, detail });
|
||||
let dest = p.dest.clone();
|
||||
let staging_root = {
|
||||
let mut n = dest.file_name().ok_or_else(|| Error::Invalid("bad destination".into()))?.to_os_string();
|
||||
n.push(".installing");
|
||||
dest.with_file_name(n)
|
||||
};
|
||||
let meta_dir = metadata_dir_for(&dest)?;
|
||||
|
||||
say("Checking your computer", 2, None);
|
||||
super::check_docker(d)?;
|
||||
// The manifest first: it is signed, and tells us how much space we need.
|
||||
let (m, manifest_bytes) = fetch_manifest(&p.source, p.trusted_key)?;
|
||||
if !matches!(m.kind, manifest::Kind::Base | manifest::Kind::Update) || !m.compatible_with_manager(crate::MANAGER_VERSION) {
|
||||
return Err(Error::Invalid("This package needs a newer version of CoA Server Manager.".into()));
|
||||
}
|
||||
let archive = m.archive.clone().ok_or_else(|| Error::InvalidManifest("no archive".into()))?;
|
||||
let download_size: u64 = archive.parts.iter().map(|x| x.size).sum();
|
||||
|
||||
let pre = preflight(&dest, &p.data_dir, archive.unpacked_size + download_size, p.registry);
|
||||
if !pre.ok {
|
||||
return Err(Error::Invalid(pre.problems.iter().map(|x| x.message.clone()).collect::<Vec<_>>().join(" ")));
|
||||
}
|
||||
|
||||
let parts_dir = fetch_parts(&p.source, &m, &meta_dir.join("staging").join("download"), &p.cancel, &|frac, detail| say("Downloading server", 5 + (frac * 45.0) as u8, detail))?;
|
||||
|
||||
if staging_root.exists() {
|
||||
if staging_root.join(STAGING_MARKER).is_file() {
|
||||
fs::remove_dir_all(&staging_root)?; // leftover of an earlier failed attempt that we created
|
||||
} else {
|
||||
return Err(Error::Invalid(format!("{} already exists and was not created by the Manager.", staging_root.display())));
|
||||
}
|
||||
}
|
||||
fs::create_dir_all(&staging_root)?;
|
||||
fs::write(staging_root.join(STAGING_MARKER), b"")?;
|
||||
|
||||
let mut project: Option<Config> = None;
|
||||
let result = (|| -> Result<Installed> {
|
||||
say("Unpacking", 50, None);
|
||||
crate::package::extract(&parts_dir, &m, &staging_root, &|done, total| say("Unpacking", 50 + (done * 30 / total.max(1)) as u8, None))?;
|
||||
check_extracted(&staging_root)?;
|
||||
|
||||
say("Preparing database", 82, None);
|
||||
let settings = write_settings(&staging_root, &p.data_dir)?;
|
||||
project = Some(Config::load(&staging_root)?);
|
||||
let progress = |percent: u8, detail: String| say("Preparing database", percent, Some(detail));
|
||||
let built = build_database(d, &staging_root, &m.migrations, &settings, &progress);
|
||||
let _ = super::run_with(d, &staging_root, Verb::StopAll);
|
||||
built?;
|
||||
fs::remove_file(staging_root.join(STAGING_MARKER))?;
|
||||
|
||||
// Commit: the only moment the destination changes. The database lives in a docker volume, so it does not care
|
||||
// that the folder moves.
|
||||
say("Finishing", 95, None);
|
||||
if dest.exists() {
|
||||
fs::remove_dir(&dest)?; // only succeeds for an empty folder (preflight verified)
|
||||
}
|
||||
fs::rename(&staging_root, &dest)?;
|
||||
super::ensure_main_configs(&dest)?;
|
||||
crate::config::materialize_module_configs(&dest)?;
|
||||
|
||||
let mut meta = InstallMeta::new(InstallKind::New, &dest);
|
||||
meta.layout = LAYOUT_DOCKER_V1.into();
|
||||
meta.core.commit = m.core.commit.clone();
|
||||
meta.core.version = Some(m.version.clone());
|
||||
meta.database.schemas = DATABASES.iter().map(|(_, s)| s.to_string()).collect();
|
||||
meta.managed_files = m.files.iter().map(|f| f.path.clone()).collect();
|
||||
for f in &m.files {
|
||||
meta.original_hashes.insert(f.path.clone(), f.sha256.clone());
|
||||
}
|
||||
let md = MetaDir::create(&dest, &meta)?;
|
||||
fsx::atomic_write(&md.root.join("manifests").join("base.json"), &manifest_bytes)?;
|
||||
p.registry.register(&meta.id, &dest)?;
|
||||
say("Ready", 100, None);
|
||||
Ok(Installed { id: meta.id, path: dest.to_string_lossy().into_owned(), version: m.version.clone() })
|
||||
})();
|
||||
|
||||
if result.is_err() && staging_root.join(STAGING_MARKER).exists() {
|
||||
// Unfinished work of ours; the destination was never touched. Give back what docker holds for it.
|
||||
if let Some(cfg) = &project {
|
||||
super::destroy(d, cfg);
|
||||
}
|
||||
let _ = fs::remove_dir_all(&staging_root);
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::docker::cli::{Call, Output};
|
||||
use crate::package::{self, BuildOptions};
|
||||
use base64::Engine;
|
||||
use ed25519_dalek::{Signer, SigningKey};
|
||||
use std::cell::RefCell;
|
||||
|
||||
struct Fake {
|
||||
calls: RefCell<Vec<Vec<String>>>,
|
||||
unavailable: bool,
|
||||
}
|
||||
|
||||
impl Fake {
|
||||
fn new(unavailable: bool) -> Fake {
|
||||
Fake { calls: Default::default(), unavailable }
|
||||
}
|
||||
}
|
||||
|
||||
impl Docker for Fake {
|
||||
fn run(&self, call: &Call) -> Result<Output> {
|
||||
self.calls.borrow_mut().push(call.args.clone());
|
||||
if self.unavailable {
|
||||
return Err(Error::Invalid("docker could not be started: not found".into()));
|
||||
}
|
||||
Ok(Output { code: Some(0), stdout: "27.3.1".into(), stderr: String::new() })
|
||||
}
|
||||
|
||||
fn pause(&self, _d: std::time::Duration) {}
|
||||
}
|
||||
|
||||
fn reg(d: &Path) -> Registry {
|
||||
Registry::at(d.join("reg/installs.json"))
|
||||
}
|
||||
|
||||
fn codes(p: &Preflight) -> Vec<&'static str> {
|
||||
p.problems.iter().map(|x| x.code).collect()
|
||||
}
|
||||
|
||||
fn data_folder(d: &Path) -> PathBuf {
|
||||
let data = d.join("data");
|
||||
fs::create_dir_all(data.join("dbc")).unwrap();
|
||||
fs::create_dir_all(data.join("maps")).unwrap();
|
||||
data
|
||||
}
|
||||
|
||||
/// A signed package folder holding `files`, and the key that verifies it.
|
||||
fn signed_package(d: &Path, files: &[(&str, &str)]) -> (PathBuf, String) {
|
||||
let src = d.join("src");
|
||||
for (rel, content) in files {
|
||||
let p = src.join(rel);
|
||||
fs::create_dir_all(p.parent().unwrap()).unwrap();
|
||||
fs::write(p, content).unwrap();
|
||||
}
|
||||
let pkg = d.join("pkg");
|
||||
let opts = BuildOptions { kind: manifest::Kind::Update, version: "0.1.0".into(), core_commit: None, built_at: "x".into(), part_size: 1 << 20, bots_commit: None, migrations: vec![] };
|
||||
package::build(&src, &pkg, &opts, &|_| {}).unwrap();
|
||||
let key = SigningKey::generate(&mut rand_core::OsRng);
|
||||
let engine = base64::engine::general_purpose::STANDARD;
|
||||
let sig = engine.encode(key.sign(&fs::read(pkg.join("manifest.json")).unwrap()).to_bytes());
|
||||
fs::write(pkg.join("manifest.json.sig"), sig).unwrap();
|
||||
(pkg, engine.encode(key.verifying_key().to_bytes()))
|
||||
}
|
||||
|
||||
const FULL: [(&str, &str); 7] = [
|
||||
("Core/worldserver", "w"),
|
||||
("Core/authserver", "a"),
|
||||
("Core/configs/worldserver.conf.dist", "x"),
|
||||
("Core/configs/authserver.conf.dist", "x"),
|
||||
("Database/baseline/auth.sql.zst", "dump"),
|
||||
("Database/baseline/characters.sql.zst", "dump"),
|
||||
("Database/baseline/world.sql.zst", "dump"),
|
||||
];
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn the_destination_rules_fit_a_linux_computer() {
|
||||
let d = tempfile::tempdir().unwrap();
|
||||
let data = data_folder(d.path());
|
||||
let ok = |dest: &Path| codes(&preflight(dest, &data, 1000, ®(d.path())));
|
||||
assert!(!ok(&d.path().join("CoaServer")).iter().any(|c| *c != "space"), "a new folder is fine");
|
||||
for bad in ["/usr/local/coa", "/etc", "/", "/proc/x"] {
|
||||
assert!(ok(Path::new(bad)).contains(&"system_folder"), "{bad}");
|
||||
}
|
||||
assert!(ok(Path::new("relative/dir")).contains(&"relative"));
|
||||
assert!(ok(Path::new("/srv/with:colon")).contains(&"colon"));
|
||||
let existing = d.path().join("existing");
|
||||
fs::create_dir_all(&existing).unwrap();
|
||||
fs::write(existing.join("notes.txt"), b"x").unwrap();
|
||||
assert!(ok(&existing).contains(&"not_empty"));
|
||||
let r = reg(d.path());
|
||||
r.register("1", &existing).unwrap();
|
||||
assert!(codes(&preflight(&existing.join("inner"), &data, 1000, &r)).contains(&"registered"));
|
||||
// The same name in another case is another folder on Linux.
|
||||
assert!(!codes(&preflight(&d.path().join("EXISTING"), &data, 1000, &r)).contains(&"registered"));
|
||||
}
|
||||
|
||||
// The tests marked for unix use absolute folders of the temporary directory, which on Windows start with a drive letter and a
|
||||
// colon; the Docker backend refuses a colon in a folder it mounts (it would be read as a separator of `--volume`) and only runs
|
||||
// on Linux, so Windows has nothing to check here.
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn the_game_data_folder_must_look_like_game_data() {
|
||||
let d = tempfile::tempdir().unwrap();
|
||||
let reg = reg(d.path());
|
||||
let dest = d.path().join("srv");
|
||||
let empty = d.path().join("empty");
|
||||
fs::create_dir_all(&empty).unwrap();
|
||||
assert!(codes(&preflight(&dest, &empty, 1, ®)).contains(&"data_missing"));
|
||||
assert!(codes(&preflight(&dest, Path::new("relative/data"), 1, ®)).contains(&"data_path"));
|
||||
assert!(!codes(&preflight(&dest, &data_folder(d.path()), 1, ®)).iter().any(|c| c.starts_with("data")));
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn new_settings_name_the_containers_and_keep_the_secrets_private() {
|
||||
let d = tempfile::tempdir().unwrap();
|
||||
let root = d.path().join("srv");
|
||||
let data = data_folder(d.path());
|
||||
let s = write_settings(&root, &data).unwrap();
|
||||
|
||||
let cfg = Config::load(&root).unwrap();
|
||||
assert_eq!(cfg.bind_address, "127.0.0.1", "this computer only until the person opens it");
|
||||
assert_eq!(cfg.project.len(), 10);
|
||||
assert_eq!(cfg.data_path(&root), data);
|
||||
|
||||
let ports = crate::layout::read_ports(&root);
|
||||
assert_eq!(ports.world, s.world_port);
|
||||
assert!(ports.auth > 0 && ports.ra > 0);
|
||||
let repack: serde_json::Value = fsx::read_json(&root.join("Settings/repack.json")).unwrap();
|
||||
assert_eq!(repack["raUsername"], db::SERVICE_ACCOUNT);
|
||||
|
||||
let (root_pw, app_pw) = db::credentials(&root).unwrap();
|
||||
assert!(root_pw.len() == 48 && app_pw.len() == 48 && root_pw != app_pw);
|
||||
assert_eq!(app_pw, s.app_password);
|
||||
#[cfg(unix)]
|
||||
{
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
let mode = fs::metadata(root.join("Settings/database.json")).unwrap().permissions().mode() & 0o777;
|
||||
assert_eq!(mode, 0o600, "the passwords are for their owner only");
|
||||
}
|
||||
// Two installations never share a project name.
|
||||
let other = write_settings(&d.path().join("srv2"), &data).unwrap();
|
||||
assert_ne!(Config::load(&d.path().join("srv2")).unwrap().project, cfg.project);
|
||||
let _ = other;
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_busy_default_port_is_replaced_by_a_free_one() {
|
||||
let held = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
|
||||
let busy = held.local_addr().unwrap().port();
|
||||
let got = pick_port(busy).unwrap();
|
||||
assert_ne!(got, busy);
|
||||
drop(held);
|
||||
assert_eq!(pick_port(busy).unwrap(), busy, "free again: the usual port is used");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_package_is_checked_for_everything_an_installation_needs() {
|
||||
let d = tempfile::tempdir().unwrap();
|
||||
let root = d.path();
|
||||
assert!(check_extracted(root).unwrap_err().to_string().contains("Core/worldserver"));
|
||||
for (rel, c) in FULL {
|
||||
let p = root.join(rel);
|
||||
fs::create_dir_all(p.parent().unwrap()).unwrap();
|
||||
fs::write(p, c).unwrap();
|
||||
}
|
||||
check_extracted(root).unwrap();
|
||||
fs::remove_file(root.join("Database/baseline/world.sql.zst")).unwrap();
|
||||
assert!(check_extracted(root).unwrap_err().to_string().contains("Database/baseline/world.sql.zst"));
|
||||
}
|
||||
|
||||
fn migration(db: &str, id: &str) -> Migration {
|
||||
Migration { db: db.into(), id: id.into(), sha256: "ab".repeat(32), destructive: false, compatible_sha256: vec![] }
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_package_migrations_are_recorded_as_applied_in_a_few_statements() {
|
||||
let list: Vec<Migration> = (0..1000).map(|i| migration(["auth", "characters", "world"][i % 3], &format!("rev_{i}"))).collect();
|
||||
let statements = baseline_statements(&list).unwrap();
|
||||
assert_eq!(statements.len(), 3, "400 rows at most in a statement");
|
||||
assert!(statements[0].starts_with("REPLACE INTO `acore_world`.`coa_manager_migrations`"));
|
||||
assert_eq!(statements.iter().map(|s| s.matches("'applied'").count()).sum::<usize>(), 1000);
|
||||
assert!(statements[0].contains("('auth','rev_0',") && statements[0].contains(",NOW(),NULL,1)"), "marked as a baseline");
|
||||
assert!(baseline_statements(&[]).unwrap().is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_migration_that_could_carry_sql_is_refused_before_anything_is_written() {
|
||||
for bad in [migration("world", "x'); DROP TABLE y;--"), migration("mysql", "ok"), migration("world", ""), Migration { sha256: "zz".into(), ..migration("world", "ok") }] {
|
||||
assert!(baseline_statements(&[migration("auth", "fine"), bad]).is_err());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn without_docker_nothing_is_downloaded_or_created() {
|
||||
let d = tempfile::tempdir().unwrap();
|
||||
let (pkg, key) = signed_package(d.path(), &FULL);
|
||||
let dest = d.path().join("dest");
|
||||
let r = reg(d.path());
|
||||
let fake = Fake::new(true);
|
||||
let err = install_with(&fake, &Params { source: Source::Dir(pkg), dest: dest.clone(), data_dir: data_folder(d.path()), trusted_key: &key, registry: &r, cancel: Cancel::default() }, &|_| {}).unwrap_err();
|
||||
assert!(err.to_string().to_lowercase().contains("docker"), "{err}");
|
||||
assert!(!dest.exists() && !dest.with_file_name("dest.installing").exists());
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn a_package_without_the_server_is_refused_and_leaves_nothing() {
|
||||
let d = tempfile::tempdir().unwrap();
|
||||
let (pkg, key) = signed_package(d.path(), &[("Core/configs/worldserver.conf.dist", "x"), ("README.txt", "hello")]);
|
||||
let dest = d.path().join("dest");
|
||||
let r = reg(d.path());
|
||||
let fake = Fake::new(false);
|
||||
let err = install_with(&fake, &Params { source: Source::Dir(pkg), dest: dest.clone(), data_dir: data_folder(d.path()), trusted_key: &key, registry: &r, cancel: Cancel::default() }, &|_| {}).unwrap_err();
|
||||
assert!(err.to_string().contains("not a complete Linux server package"), "{err}");
|
||||
assert!(!dest.exists() && !dest.with_file_name("dest.installing").exists());
|
||||
assert!(r.list().unwrap().is_empty());
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn a_failed_database_setup_gives_back_what_docker_holds_and_leaves_no_server() {
|
||||
let d = tempfile::tempdir().unwrap();
|
||||
let (pkg, key) = signed_package(d.path(), &FULL);
|
||||
let dest = d.path().join("dest");
|
||||
let r = reg(d.path());
|
||||
// This fake docker answers every command with success and no container, so the database never becomes ready.
|
||||
let fake = Fake::new(false);
|
||||
let err = install_with(&fake, &Params { source: Source::Dir(pkg), dest: dest.clone(), data_dir: data_folder(d.path()), trusted_key: &key, registry: &r, cancel: Cancel::default() }, &|_| {}).unwrap_err();
|
||||
assert!(err.to_string().to_lowercase().contains("database"), "{err}");
|
||||
assert!(!dest.exists() && !dest.with_file_name("dest.installing").exists(), "no half-installed server");
|
||||
assert!(r.list().unwrap().is_empty());
|
||||
let calls = fake.calls.borrow();
|
||||
let removed = |suffix: &str| calls.iter().any(|c| c[0] == "rm" && c.last().is_some_and(|n| n.starts_with("coa-") && n.ends_with(suffix)));
|
||||
assert!(removed("-db") && removed("-world") && removed("-auth"), "containers removed: {calls:?}");
|
||||
assert!(calls.iter().any(|c| c[..2] == ["volume", "rm"]) && calls.iter().any(|c| c[..2] == ["network", "rm"]));
|
||||
}
|
||||
}
|
||||
Loaded 100 of 195 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user