Compare commits

..
Author SHA1 Message Date
Дмитрий 247159e56c Normalize all upgrade qualification paths before update transactions 2026-10-11 22:03:09 +05:00
Corfirean cdd5be2365 Merge pull request #74 from Corfirean/fix/startup-fixture-paths
Fix relative startup fixture paths selecting old server binaries
2026-10-11 21:50:13 +05:00
Дмитрий 7e170744bf Exercise an explicitly relative fixture path in regression 2026-10-11 21:50:09 +05:00
Дмитрий 10daa9b74d Resolve startup fixture roots before copying candidate files 2026-10-11 21:49:44 +05:00
Corfirean ed7bf7262b Merge pull request #71 from Corfirean/fix/player-race-patches
Add custom race patch installation for remote players
2026-10-11 15:37:54 +05:00
Дмитрий 7c866b116d feat(client): install custom race patches in player mode 2026-10-11 15:37:44 +05:00
Corfirean cfea54e203 Merge pull request #68 from Corfirean/release/0.6.13
Keep the next Manager release at 0.6.13
2026-10-11 01:39:57 +05:00
Дмитрий 57aa97da8a Revert "Prepare Manager version 0.7.0"
This reverts commit 6fd2130fc4.
2026-10-11 01:39:35 +05:00
Corfirean b9f89a4ae4 Merge pull request #67 from Corfirean/release/0.7.0
Prepare Manager 0.7.0
2026-10-11 01:38:56 +05:00
Дмитрий 6fd2130fc4 Prepare Manager version 0.7.0 2026-10-11 01:38:45 +05:00
Corfirean 346d97ee89 Merge pull request #62 from Corfirean/automation/immutable-channels
Prepare safe immutable updates and automatic recovery for Manager 0.6.13
2026-10-11 01:35:27 +05:00
Дмитрий 10a6744192 Normalize MySQL inventory roots consistently on Windows 2026-10-11 01:31:22 +05:00
Дмитрий 7557b347c5 Merge remote-tracking branch 'origin/master' into automation/immutable-channels 2026-10-11 01:31:22 +05:00
Corfirean 2abd64dfe2 Merge pull request #66 from Corfirean/feat/custom-races-bot-exclusions
feat(races): synchronize custom races bot setting with playerbots excluded races
2026-10-11 01:31:20 +05:00
Дмитрий 9ae5fb471b Rehearse Windows updates and preserve complete MySQL recovery 2026-10-10 23:34:29 +05:00
Дмитрий 59036867d7 Report all database objects blocking update recovery 2026-10-10 22:33:54 +05:00
Дмитрий 949614f11a fix(races): update excluded bot race IDs as requested by llusixn 2026-10-10 22:06:19 +05:00
Дмитрий 9ee0e9f6af Revert "Keep the RA test peer open until clients finish under parallel load"
This reverts commit 3405c89fe8.
2026-10-10 20:56:15 +05:00
Дмитрий 3405c89fe8 Keep the RA test peer open until clients finish under parallel load 2026-10-10 20:55:38 +05:00
Дмитрий 4c4d39f1de feat(races): synchronize custom races bot setting with playerbots excluded races 2026-10-10 20:55:27 +05:00
Дмитрий b101c79e96 Qualify upgrades through the real Manager transaction in isolated fixtures 2026-10-10 20:51:02 +05:00
Дмитрий 3b7f77d92e Check packaged MySQL Unicode regex support on fresh data 2026-10-10 19:52:07 +05:00
Дмитрий 0589722e71 Include persisted schema failures in diagnostic exports 2026-10-10 19:38:36 +05:00
Дмитрий a3717c08bb Retain each schema failure report during recovery validation 2026-10-10 19:37:13 +05:00
Дмитрий dc2bffc57e Keep complete schema diagnostics across update rollback 2026-10-10 19:34:52 +05:00
Дмитрий e34ab45443 Add full isolated server startup qualification for disposable Windows fixtures 2026-10-10 13:02:33 +05:00
Дмитрий 40f9feab84 Bind upgrade compatibility to signed database source contracts 2026-10-10 12:57:11 +05:00
Дмитрий 5b16842720 Isolate update startup checks and recover validation configurations 2026-10-10 12:34:48 +05:00
Дмитрий 02843bb6d1 Check release compatibility and recover unhealthy updates automatically 2026-10-10 12:22:14 +05:00
Дмитрий a9ab7ced7e Merge branch 'fix/module-base-update-replay' into automation/immutable-channels 2026-10-10 12:15:43 +05:00
Дмитрий 77318895ae Reproduce raid base SQL replay on disposable MySQL 2026-10-10 12:15:43 +05:00
Дмитрий 115c57f54e Separate module installation SQL from incremental update packages 2026-10-10 12:11:19 +05:00
Дмитрий 94fd5fb5b9 Resolve signed immutable server update channels 2026-10-10 12:05:14 +05:00
Дмитрий 94d4ade1c7 Fix headless world startup for issue #46 and release Manager 0.6.12 2026-10-10 07:59:03 +05:00
Дмитрий 376f1dbb46 Fix conditional settings hooks and release Manager 0.6.11 2026-10-10 07:49:41 +05:00
Дмитрий b0951dbee7 feat(races): update verified client assets to CoA Custom 1.5 2026-10-10 06:56:44 +05:00
Дмитрий 374a3f9c23 feat(races): ship client integration in Manager 0.6.9 2026-10-10 06:35:01 +05:00
Дмитрий d20d5a6410 Merge remote-tracking branch 'origin/master' into feat/custom-races
# Conflicts:
#	src/screens/ModulesPage.tsx
2026-10-10 06:29:49 +05:00
Дмитрий 1228807eaf feat(races): integrate client patch installation and controls 2026-10-10 06:29:32 +05:00
Дмитрий ee59708fbf Prepare Manager 0.6.8 release 2026-10-10 05:51:09 +05:00
Corfirean 3ed9c5dacd Merge pull request #48 from Corfirean/feat/unsaved-guard-and-auto-restart
feat: unsaved changes navigation guard and server auto-restart with crash analyzer
2026-10-10 05:50:58 +05:00
Дмитрий 9099168927 Merge master and preserve Linux installation and crash history mocks 2026-10-10 05:47:39 +05:00
Corfirean a27e0eb6ab Merge pull request #44 from Corfirean/fix/db-error-details
Do not report an SQL error as "the database is not running"
2026-10-10 05:46:39 +05:00
Corfirean c46edd2feb Merge pull request #38 from lostmind84/feat/linux-b3b-install-screen
feat: install screen, Wine/Proton client and realm profiles for a Docker server (Linux)
2026-10-10 05:46:36 +05:00
Fabien F. f934bef303 fix: find a running Wine client under both names of a linked home folder
On SteamOS and Bazzite /home is a link to /var/home; Wine keeps the path it was
given, so the resolved one alone can miss the command line. The start order is
unchanged (database up and healthy before the realm list is updated): a comment
says so.
2026-10-08 17:30:08 +02:00
Fabien F. c882a21334 docs: changelog entry for the Linux install screen 2026-10-08 17:28:59 +02:00
Fabien F. a625b065cf feat: start the game client under umu-launcher / Wine on Linux
client::launch started Ascension.exe directly, which cannot work on Linux, and
client::is_running found nothing (it reads the Windows process list). wine.rs is
the Linux counterpart, and both hand over to it on a Linux host.

It runs the command of the project's own launcher script: umu-run with a Proton
build (GAMEID=0, PROTONPATH, WINEPREFIX, started from the client folder), else
plain Wine, with WINEDLLOVERRIDES=divxtac=d (DivxTac.dll deadlocks the world
loading screen under wine-mono). The newest GE-Proton found for Steam is used, or
umu's own choice; COA_PROTONPATH, COA_WINEPREFIX and client-launch.json override
the detection; the prefix defaults to ~/Games/umu/coa-client. The game runs in its
own process group, so closing the Manager does not close it, and prints to
client.log. Whether it runs is read from /proc, where the command line holds the
Windows form of the client path. A clear message says what to install when neither
umu nor Wine is found.

Tests: detection (newest build, no build, Wine only, nothing, overrides), the
command, the /proc match, and a real spawn with a stand-in umu-run that records its
environment. Not run: the real client.
2026-10-08 17:28:59 +02:00
Fabien F. 5c3a9def0c feat: realm profiles (CoA / Wildcard) work on a Docker server
The Realm card showed "io: No such file or directory (os error 2)" on a Docker
server: the Wildcard check read Core/worldserver.exe. The card lets the owner
switch realm, so it is made to work rather than hidden.

What the repack's patched launcher did at each start is done by the Docker
backend: finish an interrupted switch (realms::before_start), name the realms in
the realm list, and give the containers the databases of the selected realm
(acore_world_wildcard, acore_characters_wildcard). The switch itself is the shared
code. prepare_launcher has nothing to patch on a Docker server, and Wildcard
support is read from Core/worldserver as it is from Core/worldserver.exe (the .exe
wins when both exist, so a repack is read as before).

Tests: the support check on both binary names, no launcher to adapt, and the
databases passed to the containers for each realm. Creating the Wildcard realm
itself needs a build and a database with the Wildcard migrations and was not run.
2026-10-08 17:28:59 +02:00
Fabien F. 25098b5a63 fix: a Docker server is never offered or given the repack's updates
Found by installing a server through the new screen: the update check of a Docker
server read the Windows "stable" channel and offered "0.261003.17 (you have
0.261003.1)". Applying it would have put the repack's executables, MySQL and
launcher into a Linux server folder.

Refused in the core (update::preview, apply and rollback), so no caller can do it.
The Settings tab says that updates are not available for Docker servers yet; the
background check stays quiet, as for any failed check.

A test applies the same update package to the same folder with and without
Settings/docker.json: refused and untouched with it, committed without it.
2026-10-08 17:28:59 +02:00
Fabien F. 45a699d2ca feat: install a new Docker server from the install screen (Linux)
The install commands ask coa_core::platform::flavor() once and hand a Docker
install to src-tauri/src/docker_install.rs; the repack arm of each command is
untouched (an early return and an extra optional parameter are all that changed
in lib.rs). New command install_environment tells the screen the kind of server,
the suggested folder (~/CoaServer) and why Docker cannot be used, if it cannot.

On Linux the install screen shows the game data folder (used in place, read-only)
and the server package (a folder or an address; there is no default address until
a signed Linux package is published), and disables Install until both are given
and Docker works. It shows Docker's own message with a "Check again" button when
Docker is missing, stopped or not allowed for the user. The Windows screen is
unchanged (checked side by side in the browser mock).

A debug build (tauri dev) accepts another package key named in
COA_DEV_TRUSTED_KEY, to try the installer on a package signed with a throwaway
key; a release build always uses the embedded key.

New text is English only for now (other languages fall back to it).
2026-10-08 17:28:52 +02:00
Дмитрий be68eb4341 Add unsaved changes navigation guard and server auto-restart with crash analyzer
- Add UnsavedChangesGuard modal (Save/Discard/Cancel) when navigating between tabs
- Wire guard into ModulesPage and SettingsPage with floating action bar
- Implement crash parser and explanation engine in coa-core
- Expose list_crashes Tauri command and CrashItem API
- Add auto-restart on unexpected server crash with crash loop protection
- Add crash counter badge and CrashHistoryModal with human-readable explanations and full crashlogs
- Support all 6 locales (en, ru, de, fr, es, zh)
2026-10-08 18:58:41 +05:00
Дмитрий 06ca748e80 feat(modules): add custom races module to catalog and UI 2026-10-08 14:13:43 +05:00
Corfirean 58c1e1aee0 Merge pull request #41 from lostmind84/feat/linux-release-fixture
feat: validate a release and export its baseline on Linux
2026-10-08 14:04:02 +05:00
ДмитрийandClaude Sonnet 5.5 ad69fb0401 Do not report an SQL error as "the database is not running"
Only the client's own connection errors (ERROR 2003 and 2002, "Can't connect") count as a stopped
database. The SQLSTATE 22003 of an out-of-range value contains "2003" and hid the real error of a
failing release migration. The message now also carries the client's last line.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-08 11:29:08 +05:00
Corfirean 7540527d30 Merge pull request #43 from Corfirean/release/0.6.7
Release Manager 0.6.7
2026-10-08 09:49:45 +05:00
ДмитрийandClaude Sonnet 5.5 5328709826 Release Manager 0.6.7
Version bump only. Collects: the update check no longer fails after a crash and no longer
starts MySQL in the background, the Wildcard table repair checksum error, same-version files
edited by hand are not an update, a stopped server stays stopped after an update, the layout
fixes, one card per realm, remove-server and backup-folder settings, the Accounts tab
(bot accounts hidden), a world server started from the coa-bots folder, and the new
SQUID bot Dashboard tab.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-08 09:41:37 +05:00
Corfirean 478ea8a960 Merge pull request #42 from Corfirean/fix/update-check-resilience
Fix the update check, add the dashboard tab and a batch of Manager fixes
2026-10-08 09:40:59 +05:00
ДмитрийandClaude Sonnet 5.5 c8a0f6872f Hide the SQUID bot accounts from the Accounts list
Accounts named with AiPlayerbot.RandomBotAccountPrefix (default rndbot) belong to the bot
system like the companions' accounts: they are not listed and cannot be renamed or deleted.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-08 09:33:46 +05:00
ДмитрийandClaude Sonnet 5.5 c3791f80f1 Shorten two changelog titles to the 90 character limit
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-08 08:58:25 +05:00
ДмитрийandClaude Sonnet 5.5 1acbcc2bb5 Fix the dashboard tab: large answers, damaged history files, browser link and realm drop-down
The dashboard now runs through a small launcher that avoids the immediate socket shutdown that
cut answers above 64 KB on Windows, supplies the missing level-builds file, removes history
files zeroed by a crash, is addressed as 127.0.0.1 and opens in the browser through its own
command. The realm drop-down is hidden while both worlds start together.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-08 08:33:36 +05:00
ДмитрийandClaude Sonnet 5.5 838cc07e73 Add the SQUID dashboard tab and make a stopped server stay stopped after updating
The Dashboard tab (shown with SQUID Playerbots) downloads the dashboard release of the
bots' release series, starts it on a free local port and shows it in the window. After an
update, a server that was stopped stays stopped unless the owner asked for it to start.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-08 07:33:07 +05:00
ДмитрийandClaude Sonnet 5.5 4c4f8bbb3e Accept both published versions of the Wildcard table repair
The migration manager_repair__20261005_missing_wildcard_tables was published with two
different checksums; a server that applied one refused the update carrying the other.
Both versions have the same effect, so the Manager treats them as interchangeable.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-08 07:12:51 +05:00
ДмитрийandClaude Sonnet 5.5 d85d86a3dc Recognise the coa-bots world server and explain the undo step
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-08 07:12:01 +05:00
ДмитрийandClaude Sonnet 5.5 0a050a40a2 Add start-after-update options and clarify the always-max-skills setting
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-08 07:11:08 +05:00
ДмитрийandClaude Sonnet 5.5 017b977bfa Same version is never an update; Repair lists the files that differ
An update is decided by version: files the owner edited at the same version no longer
open a keep/replace decision. Repair shows which files differ or are missing.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-08 07:09:33 +05:00
ДмитрийandClaude Sonnet 5.5 337418afe0 Add a configurable backup folder and drop-down bot settings
Backups can be stored in a chosen folder (new backups go there, older ones stay listed),
and a backups folder that is a link to another drive no longer fails the update's safety
backup check. SQUID settings that declare a fixed list of choices are edited as a drop-down
and validated against it.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-08 07:08:09 +05:00
ДмитрийandClaude Sonnet 5.5 f920ff8a59 Fix the stray window scrollbar, the Overview button overflow and show one card per realm
- The main area and the console log are now positioning contexts, so screen-reader-only
  text inside them can no longer extend the whole window (the second scrollbar in the update
  dialog and the window scroll on the Console database tab).
- The client button group on the server card wraps instead of leaving the card.
- With both worlds starting together, each realm gets its own card.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-08 07:04:29 +05:00
ДмитрийandClaude Sonnet 5.5 072a657649 Remove-server card, Accounts tab, quiet background update check, safer install cleanup
- Settings: a card removes a stopped server from the Manager (no files deleted).
- The Players tab is now Accounts in all languages.
- The five-minute background check no longer starts and stops MySQL on a stopped
  server; only an explicit check may start it.
- A failed install keeps its marker until the folder is complete, cleans up after a
  failure that happens after the move, and reports the launcher's output; install and
  update errors have a Copy button.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-08 07:01:20 +05:00
ДмитрийandClaude Sonnet 5.5 c6e8a34509 Make the update check survive damaged launcher state and an unavailable database
A crash during a launcher write can leave .state/*.json zero-filled, which made
every launcher start (and so the update check) fail with "Something went wrong".
Zero-filled state files are now discarded before each launcher verb, the check
degrades to a warning when the database cannot be inspected, and database start
failures carry the launcher's own output.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-08 06:56:03 +05:00
Fabien F. 3f98ba3add test: the release fixture database arguments are a Linux case 2026-10-07 21:01:43 +02:00
Fabien F. 7a3fefaafd feat: validate a release and export its baseline on Linux
The signed base package holds the MySQL data directory of a Windows repack. On a
Linux computer extract-schema-base now turns it into a Docker server folder whose
database container opens that directory (mysqlData in docker.json), so the release
SQL, the schema contract and export-baseline run with the Docker installation code.
Windows is unchanged: it still bootstraps the repack's own database program.
2026-10-07 13:56:00 +02:00
Corfirean fac6ce469a Merge pull request #35 from Corfirean/release/0.6.6
Release Manager 0.6.6 (version bump)
2026-10-07 10:35:07 +05:00
ДмитрийandClaude Sonnet 5.5 f22cedd963 Release Manager 0.6.6
Version bump only. Collects: one-click diagnostics and report routing, LAN
address selector, Auction House Bot card without a GUID, experimental Linux
Docker installer, and the fixes already on master since 0.6.5.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-07 10:20:40 +05:00
Corfirean 0b5f12941c Merge pull request #29 from Corfirean/feat/ahbot-auto-character
AH bot card: no character GUID needed
2026-10-07 06:53:31 +05:00
Corfirean f3fc14b55a Merge pull request #34 from Corfirean/fix/lan-address-selector
Choose and remember the LAN address friends connect to
2026-10-07 06:53:22 +05:00
Corfirean beaec7d27e Merge pull request #33 from Corfirean/feat/diagnostics-routing
One-click diagnostics and report routing to Manager, Companions and SQUID
2026-10-07 06:48:04 +05:00
ДмитрийandClaude Sonnet 5.5 8490dc9983 Let the person choose and keep the LAN address friends connect to
Sharing on the local network used to take whatever address the Manager found
first, which is often a virtual adapter. The Friends page now lists the usable
IPv4 addresses of the computer (the automatic one marked) and accepts a custom
one. The choice is kept independently of the sharing mode, so it survives
restarts and switching to other modes. A chosen address that is not available
is reported instead of silently switching to another adapter.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-07 06:44:34 +05:00
ДмитрийandClaude Sonnet 5.5 3f8abcbbe8 Merge pull request #20 from lostmind84/feat/linux-b3a-installer
feat: install a new server as a Docker installation (Linux)

Also give the installer's test helper the compatible_sha256 field that master
added to manifest::Migration after the pull request was branched.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-07 06:37:13 +05:00
ДмитрийandClaude Sonnet 5.5 b3c50a7b39 Collect all diagnostics in one click and route reports to the right project
- The diagnostic package now also holds crash reports and small crash dumps from
  Core/Crashes, Windows' own crash records for the server programs (needed for
  crashes that bypass the server's crash handler), the newest update journals,
  the bot, supervisor and updater logs, and a view of which server programs run
  and from where. The folder with the file opens after export.
- JSON files in the package keep valid JSON after secrets are removed.
- The problem report asks what the problem is about and opens the new-issue page
  of the Manager, CoA Companions or SQUID Playerbots, preselecting the bot system
  that is switched on. One button collects diagnostics and opens the report.
- Targets come from the module catalog; only their new-issue pages may be opened.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-07 06:21:11 +05:00
ДмитрийandClaude Sonnet 5.5 bbdad37e40 NPC Enchanter card: hint how to place and remove the NPC
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-06 15:40:23 +05:00
ДмитрийandClaude Sonnet 5.5 0ed4d5e268 AH bot card: shorter buyer hint
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-06 13:49:20 +05:00
ДмитрийandClaude Sonnet 5.5 b13ee55bb9 AH bot card: the buyer does not spend gold
The module never deducts money from the auction character when it bids or buys, so the hint no longer says the character needs gold.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-06 13:41:42 +05:00
ДмитрийandClaude Sonnet 5.5 51a45db8cb AH bot card: no GUID needed, the server creates its own auction character
The GUID setting moves to the advanced list and the card text and the seller hint no longer ask for a character.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-06 13:35:32 +05:00
Corfirean 3f700ee8f4 Merge pull request #28 from Corfirean/codex/release-065-coordinated
Release 0.6.5: reliable update guards and coordinated SQUID integration
2026-10-06 11:19:07 +05:00
Дмитрий 277ebba847 Restore the original realm before disposable SQUID recovery 2026-10-06 10:46:04 +05:00
Дмитрий 9a0b815937 Cover initial SQUID import and bot creation in startup budget 2026-10-06 10:42:08 +05:00
Дмитрий 78b84e11c2 Add disposable SQUID provisioning and repeated-start acceptance 2026-10-06 10:20:18 +05:00
Дмитрий 6aea9011f9 Allow first SQUID startup to complete large database imports 2026-10-06 10:12:13 +05:00
Дмитрий 171d9a2bf8 Add coordinated release packaging and disposable update acceptance 2026-10-06 10:08:54 +05:00
Дмитрий 0d6d8a0db8 Harden server update history, recovery guards and repeated checks 2026-10-06 07:01:13 +05:00
Дмитрий 3940506987 fix: update legacy Manager-patched realm launchers 2026-10-06 07:01:13 +05:00
Дмитрий 654b7cddd3 Keep SQUID settings usable with unknown metadata and preserve translations 2026-10-05 18:09:36 +05:00
Дмитрий f8301d7394 Read SQUID release settings and protect imported repack binaries 2026-10-05 16:56:46 +05:00
Corfirean cd3a963f70 Merge pull request #21 from Corfirean/codex/fix-update-startup
Release Manager 0.6.4: fix server startup and resume failed validation
2026-10-05 14:07:36 +05:00
Fabien F. f25a1d425d docs: changelog entry for the Linux installer 2026-10-05 10:10:53 +02:00
Fabien F. b5e4a38d7d feat: install a new server as a Docker installation (Linux)
docker::install is the Linux counterpart of install::install_base and shares none
of its code (the Windows installer and its folder checks are untouched). Same
order of events: signed manifest, folder / space / game data checks, verified
download, extraction into <dest>.installing, database, one rename. Docker must be
usable; a failure removes the containers, the volume and the staging folder.

The databases start from the package's own dumps, Database/baseline/<kind>.sql.zst,
in the format of the Manager's backups, taken in a state where every migration of
the package is applied. The installer imports them, records the migrations as
applied (baseline) in a few bulk statements, and creates the acore account, the
realm port and the console account. Rebuilding from the repository's SQL does not
work: pending migrations such as rev_20260903_01_live_class_baseline are guards
generated from the maintainers' live database and refuse to run on a database
built from the base scripts, whatever the order.

- coa-release export-baseline --server DIR --out DIR produces the dumps from a
  prepared server (repack or Docker).
- The game data stays where the person has it (dataDir in docker.json, mounted
  read-only), checked at install time.
- ensure_main_configs creates worldserver.conf / authserver.conf from their
  .dist templates when missing, at install and at every start, never overwriting.
- Fix (affects the backend merged in 0.6.0): the database container's health check
  is now a ping over TCP. On a new volume the image first runs a temporary server
  that answers on its socket but takes no network connection, so the container was
  healthy about four seconds (10 s against 14 s measured) before TCP worked.
- docs/ARCHITECTURE.md: D13 (installation, package contract) and D14 (how Windows
  and Linux code are kept apart).

Tested: 12 new tests (folder rules, settings, package checks, bulk ledger SQL,
failure cleanup with an in-memory docker), and real runs of the whole chain
through examples/docker_install: baseline dumps exported from a prepared
server, package signed with a throwaway key, installed in 171 s, started by the
Manager (database healthy, world ready in 8 s, auth up), console reached with the
account the installer created, 1630 migrations recorded as applied.
2026-10-05 10:03:09 +02:00
157 changed files with 9715 additions and 483 deletions

No files matched your search

+2
View File
@@ -4,3 +4,5 @@ dist
*.log
.env
src-tauri/gen
# Disposable database fixtures and private recovery data
.cache/
Generated
+14 -3
View File
@@ -491,7 +491,7 @@ dependencies = [
[[package]]
name = "coa-core"
version = "0.6.4"
version = "0.6.13"
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.4"
version = "0.6.13"
dependencies = [
"chrono",
"coa-core",
@@ -528,7 +529,7 @@ dependencies = [
[[package]]
name = "coa-server-manager"
version = "0.6.4"
version = "0.6.13"
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
View File
@@ -3,7 +3,7 @@ resolver = "2"
members = ["crates/coa-core", "crates/coa-release", "src-tauri"]
[workspace.package]
version = "0.6.4"
version = "0.6.13"
edition = "2021"
license = "AGPL-3.0-only"
+104
View File
@@ -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.
+29
View File
@@ -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: 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: 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: 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,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.
+7
View File
@@ -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.
+7
View File
@@ -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.
+2 -1
View File
@@ -25,13 +25,14 @@ 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]
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: &registry, 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(())
}
+1 -1
View File
@@ -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 {
+1 -1
View File
@@ -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());
+1 -1
View File
@@ -20,7 +20,7 @@ fn main() -> Result<()> {
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 { id: id.into(), db: "world".into(), sha256: fsx::sha256_bytes(sql.as_bytes()), destructive: false }]), &|_| {})?;
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());
+1 -1
View File
@@ -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();
@@ -27,6 +27,7 @@ fn exercise(root: &Path) -> Result<()> {
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");
@@ -37,7 +38,7 @@ fn exercise(root: &Path) -> Result<()> {
("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 { db: db.into(), id: id.into(), sha256: fsx::sha256_bytes(sql.as_bytes()), destructive: false });
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 {
@@ -54,13 +55,15 @@ fn exercise(root: &Path) -> Result<()> {
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("were restored"), "{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(())
})?;
@@ -68,6 +71,6 @@ fn exercise(root: &Path) -> Result<()> {
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: failed SQL restored world, characters, ledger, files and version; repeated recovery succeeded");
println!("PASS: private rehearsal caught failed SQL before changing the installed world, characters, ledger, objects, files or version; complete recovery succeeded");
Ok(())
}
@@ -22,7 +22,7 @@ fn main() -> Result<()> {
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 { db: "characters".into(), id: name.into(), sha256: hash, destructive: 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}`;"))?; }
@@ -33,7 +33,7 @@ fn main() -> Result<()> {
let files = release_schema::collect(empty_core.path(), None, Some(&repairs))?;
assert_eq!(files.len(), 1);
let repair = &files[0];
migrations.push(Migration { db: repair.db.clone(), id: repair.id.clone(), sha256: repair.sha256.clone(), destructive: false });
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()))?;
+31 -5
View File
@@ -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]
+2 -1
View File
@@ -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"] {
+207 -12
View File
@@ -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,7 +250,8 @@ 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);
@@ -169,6 +264,14 @@ pub fn with_database<T>(root: &Path, f: impl FnOnce(&Db) -> Result<T>) -> Result
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"],
@@ -215,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);
}
@@ -233,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,
@@ -243,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)?;
@@ -255,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) {
@@ -273,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) => {}
@@ -283,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 })
@@ -296,6 +431,8 @@ 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()));
}
@@ -405,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();
@@ -433,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();
+86
View File
@@ -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());
}
}
+4 -4
View File
@@ -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 {
@@ -294,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"] {
+6
View File
@@ -17,6 +17,9 @@ pub const ADDON_NAME: &str = "CoABotUI";
const EXECUTABLES: [&str; 3] = ["Ascension.exe", "Wow.exe", "WoW.exe"];
pub fn is_running(client: &Path) -> bool {
if crate::platform::flavor() == crate::platform::Flavor::Docker {
return crate::wine::is_running(client, &EXECUTABLES);
}
EXECUTABLES.iter().any(|exe| {
let path = client.join(exe);
let path = dunce::canonicalize(&path).unwrap_or(path);
@@ -307,6 +310,9 @@ pub fn install_addon(client: &Path, meta: &Path, source: &Path) -> Result<()> {
/// Start the game client. The caller is responsible for making sure the server is ready first.
pub fn launch(client: &Path) -> Result<u32> {
let exe = find_exe(client).ok_or_else(|| Error::Invalid("The game client was not found.".into()))?;
if crate::platform::flavor() == crate::platform::Flavor::Docker {
return crate::wine::launch(client, exe);
}
let child = Command::new(client.join(exe)).current_dir(client).spawn()?;
Ok(child.id())
}
+249
View File
@@ -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"));
}
}
+620
View File
@@ -0,0 +1,620 @@
//! 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>,
}
/// Inspect the client folder and determine the state of custom races patches.
pub fn client_patch_status(client_path: &Path) -> ClientPatchStatus {
let data_dir = client_path.join("Data");
let mut enabled_count = 0;
let mut disabled_count = 0;
for mpq in RACE_MPQS {
if data_dir.join(format!("{mpq}.disabled")).is_file() {
disabled_count += 1;
} else if data_dir.join(mpq).is_file() {
enabled_count += 1;
}
}
let has_root = client_path.join("EsteriaAppearance.dll").is_file()
|| client_path.join("dinput8.dll").is_file()
|| client_path.join("dinput8.dll.disabled").is_file();
let total = RACE_MPQS.len();
let current_version = fs::read_to_string(client_path.join(MANIFEST_FILENAME)).ok()
.is_some_and(|manifest| manifest.lines().any(|line| line == format!("# CoA Custom {CLIENT_VERSION}")));
let state = if enabled_count == total && current_version && client_path.join("dinput8.dll").is_file() {
ClientPatchState::Enabled
} else if disabled_count == total && current_version && client_path.join("dinput8.dll.disabled").is_file() {
ClientPatchState::Disabled
} else if (enabled_count + disabled_count) > 0 {
ClientPatchState::PartiallyInstalled
} else {
ClientPatchState::NotInstalled
};
ClientPatchStatus {
state,
installed_mpqs: enabled_count + disabled_count,
total_mpqs: total,
has_root_files: has_root,
client_path: Some(client_path.to_string_lossy().into_owned()),
}
}
/// Enable or disable client patches by renaming MPQs and `dinput8.dll` with `.disabled`.
pub fn set_client_patch_enabled(client_path: &Path, enabled: bool) -> Result<()> {
if !client_path.is_dir() {
return Err(Error::Invalid("Game client directory not found.".into()));
}
if crate::client::is_running(client_path) {
return Err(Error::Invalid("Close the game before changing custom races patches.".into()));
}
if !client_path.join(MANIFEST_FILENAME).is_file()
&& !RACE_MPQS.iter().skip(1).any(|name| client_path.join("Data").join(name).is_file()
|| client_path.join("Data").join(format!("{name}.disabled")).is_file()) {
return Ok(());
}
let mut paths: Vec<PathBuf> = RACE_MPQS.iter().map(|name| client_path.join("Data").join(name)).collect();
if let Ok(manifest) = fs::read_to_string(client_path.join(MANIFEST_FILENAME)) {
for line in manifest.lines() {
if let Some(name) = line.strip_prefix("MPQ:") {
if name.contains(['/', '\\']) || !name.to_ascii_lowercase().ends_with(".mpq") {
return Err(Error::Invalid("Invalid custom races patch manifest.".into()));
}
paths.push(fsx::safe_join(&client_path.join("Data"), name)?);
}
}
}
paths.sort();
paths.dedup();
paths.push(client_path.join("dinput8.dll"));
paths.push(client_path.join("Ascension.exe"));
for active in paths {
let disabled = active.with_extension(format!("{}.disabled", active.extension().unwrap_or_default().to_string_lossy()));
let original = active.with_extension(format!("{}.original", active.extension().unwrap_or_default().to_string_lossy()));
if enabled && disabled.is_file() {
if active.is_file() {
if !original.is_file() {
return Err(Error::Invalid(format!("Cannot replace existing {} without an original backup.", active.display())));
}
fs::remove_file(&active)?;
}
fs::rename(&disabled, &active)?;
} else if !enabled && active.is_file() && !disabled.is_file() {
if active.file_name().is_some_and(|name| name == "Ascension.exe") && !original.is_file() {
continue;
}
fs::rename(&active, &disabled)?;
if original.is_file() {
fs::copy(&original, &active)?;
}
}
}
tracing::info!(enabled, "custom races client patches toggled");
Ok(())
}
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 data_dir = client_path.join("Data");
fs::create_dir_all(&data_dir)?;
// 1. Back up original Ascension.exe and patch-T.MPQ if they exist and haven't been backed up yet
let exe = client_path.join("Ascension.exe");
let exe_bak = client_path.join("Ascension.exe.original");
if exe.is_file() && !exe_bak.is_file() {
report("Backing up original Ascension.exe...", 0.02);
fs::copy(&exe, &exe_bak)?;
}
let t_mpq = data_dir.join("patch-T.MPQ");
let t_mpq_bak = data_dir.join("patch-T.MPQ.original");
if t_mpq.is_file() && !t_mpq_bak.is_file() {
report("Backing up original patch-T.MPQ...", 0.04);
fs::copy(&t_mpq, &t_mpq_bak)?;
}
let dll = client_path.join("dinput8.dll");
let dll_backup = client_path.join("dinput8.dll.original");
if dll.is_file() && !dll_backup.is_file() {
fs::copy(&dll, &dll_backup)?;
}
// 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 = client_path.join(&base);
let mut out = File::create(&dest)?;
io::copy(&mut zfile, &mut out)?;
let disabled = client_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 = client_path.join(&base);
let mut out = File::create(&dest)?;
io::copy(&mut zfile, &mut out)?;
let disabled = client_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"));
}
fsx::atomic_write(&manifest_path, manifest_body.as_bytes())?;
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::*;
#[test]
fn disabling_restores_original_client_files_and_enabling_restores_custom_files() {
let temp = tempfile::tempdir().unwrap();
let data = temp.path().join("Data");
fs::create_dir_all(&data).unwrap();
for path in [data.join("patch-T.MPQ"), temp.path().join("Ascension.exe"), temp.path().join("dinput8.dll")] {
fs::write(&path, b"custom").unwrap();
let backup = path.with_extension(format!("{}.original", path.extension().unwrap().to_string_lossy()));
fs::write(&backup, b"original").unwrap();
}
fs::write(temp.path().join(MANIFEST_FILENAME), "MPQ:patch-T.MPQ\n").unwrap();
set_client_patch_enabled(temp.path(), false).unwrap();
assert_eq!(fs::read(data.join("patch-T.MPQ")).unwrap(), b"original");
assert_eq!(fs::read(temp.path().join("Ascension.exe")).unwrap(), b"original");
set_client_patch_enabled(temp.path(), true).unwrap();
assert_eq!(fs::read(data.join("patch-T.MPQ")).unwrap(), b"custom");
assert_eq!(fs::read(temp.path().join("Ascension.exe")).unwrap(), b"custom");
}
#[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 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());
}
}
+382
View File
@@ -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());
}
}
+37 -2
View File
@@ -176,10 +176,13 @@ impl Db {
fn fail(&self, stderr: &[u8]) -> Error {
let text = String::from_utf8_lossy(stderr);
let down = text.contains("2003") || text.contains("Can't connect") || text.contains("is not running") || text.contains("No such container");
// Only the client's own connection errors mean "not running": the number 2003 or the words can also appear inside
// the message of an ordinary SQL error (a duplicate entry, a row number) and must not hide it.
let down = text.contains("ERROR 2003") || text.contains("ERROR 2002") || text.contains("Can't connect to MySQL server")
|| text.contains("No such container") || text.contains("is not running");
let code = if down { ErrorCode::DatabaseNotRunning } else { ErrorCode::Unknown };
match code {
ErrorCode::DatabaseNotRunning => Error::Invalid("The database is not running. Start the server first.".into()),
ErrorCode::DatabaseNotRunning => Error::Invalid(format!("The database is not running. Start the server first. ({})", text.trim().lines().last().unwrap_or("").chars().take(300).collect::<String>())),
_ => Error::Invalid(format!("database command failed: {}", text.trim().lines().last().unwrap_or(""))),
}
}
@@ -244,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);
@@ -331,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";
@@ -418,6 +440,19 @@ mod tests {
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");
+286 -6
View File
@@ -172,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);
@@ -195,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);
@@ -213,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();
@@ -243,10 +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(&String::from_utf8_lossy(&b)).as_bytes())?;
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)
@@ -288,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();
@@ -323,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");
@@ -340,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"));
}
}
+69
View File
@@ -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());
}
}
+574
View File
@@ -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, &reg(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, &reg)).contains(&"data_missing"));
assert!(codes(&preflight(&dest, Path::new("relative/data"), 1, &reg)).contains(&"data_path"));
assert!(!codes(&preflight(&dest, &data_folder(d.path()), 1, &reg)).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"]));
}
}
+126 -16
View File
@@ -80,6 +80,26 @@ fn docker(d: &dyn Docker, args: &[&str], timeout: Duration) -> Step<super::cli::
d.run(&Call::new(args, timeout)).or_else(|e| fail(ErrorCode::DockerUnavailable, e.to_string()))
}
/// Is docker usable by this user? Returns its version, or the reason in docker's own words.
pub fn check_docker(d: &dyn Docker) -> Result<String> {
let mut log = Log::default();
match preflight(d, &mut log) {
Ok(()) => Ok(log.0.join(" ")),
Err(f) => Err(crate::error::Error::Invalid(format!("{} {}", f.code.human().message, f.output.trim()).trim().to_string())),
}
}
/// Remove everything docker holds for an installation: containers, network and the database volume. Used when an
/// installation fails before it is finished, and later to uninstall. Missing pieces are not an error.
pub(crate) fn destroy(d: &dyn Docker, cfg: &Config) {
let n = cfg.names();
for name in [&n.auth, &n.world, &n.db] {
let _ = d.run(&Call::new(&["rm", "--force", name], QUICK));
}
let _ = d.run(&Call::new(&["network", "rm", &n.network], QUICK));
let _ = d.run(&Call::new(&["volume", "rm", &n.volume], QUICK));
}
fn preflight(d: &dyn Docker, log: &mut Log) -> Step<()> {
let o = docker(d, &["version", "--format", "{{.Server.Version}}"], QUICK)?;
if !o.ok() {
@@ -190,7 +210,7 @@ fn start(d: &dyn Docker, root: &Path, cfg: &Config, with_game: bool, log: &mut L
if !state.get(&n.db).is_some_and(Container::running) {
remove(d, &n.db);
let mut call = Call::new(&[], Duration::from_secs(120));
call.args = db_args(cfg, &n);
call.args = db_args(cfg, &n, owner_of(root).as_deref());
call.env = vec![("MYSQL_ROOT_PASSWORD".into(), secrets.root.clone())];
let o = d.run(&call).or_else(|e| fail(ErrorCode::DockerUnavailable, e.to_string()))?;
if !o.ok() {
@@ -203,7 +223,12 @@ fn start(d: &dyn Docker, root: &Path, cfg: &Config, with_game: bool, log: &mut L
return Ok(());
}
// Realm profiles (CoA / Wildcard): the database is running and healthy here (started and waited for above), which the
// realm list update below needs. Finish an interrupted switch, then make the realm list say what is selected. The repack's
// launcher did this when it started; here nothing else would.
let realm = prepare_realm(root, log)?;
ensure_image(d, log)?;
super::ensure_main_configs(root).map_err(|e| Failure { code: ErrorCode::ServerFilesIncomplete, output: e.to_string() })?;
std::fs::create_dir_all(root.join("Core/Logs")).map_err(|e| Failure { code: ErrorCode::ServerFilesIncomplete, output: e.to_string() })?;
let owner = owner_of(root);
let host = std::fs::canonicalize(root).unwrap_or_else(|_| root.to_path_buf());
@@ -212,8 +237,8 @@ fn start(d: &dyn Docker, root: &Path, cfg: &Config, with_game: bool, log: &mut L
if !state.get(&n.world).is_some_and(Container::running) {
remove(d, &n.world);
let mut call = Call::new(&[], Duration::from_secs(60));
call.args = game_args(cfg, &n, GameKind::World, &host, ports.world, ports.ra, owner.as_deref());
call.env = database_env(&secrets, true);
call.args = game_args(cfg, &n, GameKind::World, &host, &cfg.data_path(&host), ports.world, ports.ra, owner.as_deref());
call.env = database_env(&secrets, true, realm);
run_container(d, &call, &n.world, log)?;
}
wait_listening(d, cfg, &n.world, ports.world, WORLD_WAIT, log)?;
@@ -221,8 +246,8 @@ fn start(d: &dyn Docker, root: &Path, cfg: &Config, with_game: bool, log: &mut L
if !state.get(&n.auth).is_some_and(Container::running) {
remove(d, &n.auth);
let mut call = Call::new(&[], Duration::from_secs(60));
call.args = game_args(cfg, &n, GameKind::Auth, &host, ports.auth, 0, owner.as_deref());
call.env = database_env(&secrets, false);
call.args = game_args(cfg, &n, GameKind::Auth, &host, &cfg.data_path(&host), ports.auth, 0, owner.as_deref());
call.env = database_env(&secrets, false, realm);
run_container(d, &call, &n.auth, log)?;
}
wait_listening(d, cfg, &n.auth, ports.auth, AUTH_WAIT, log)?;
@@ -312,19 +337,35 @@ fn connect_ip(cfg: &Config) -> IpAddr {
// ------------------------------------------------------------------------------------------------- argument lists
fn db_args(cfg: &Config, n: &Names) -> Vec<String> {
fn db_args(cfg: &Config, n: &Names, owner: Option<&str>) -> Vec<String> {
let mut a: Vec<String> = ["run", "--detach", "--name"].iter().map(|s| s.to_string()).collect();
a.push(n.db.clone());
a.extend(["--network".into(), n.network.clone(), "--network-alias".into(), "db".into()]);
a.extend(["--label".into(), format!("coa.project={}", cfg.project)]);
a.extend(["--volume".into(), format!("{}:/var/lib/mysql", n.volume)]);
match &cfg.mysql_data {
Some(dir) => {
// A data directory from a Windows repack: it is written by the person who owns the folder, and its table names
// were folded to lower case (the repack's setting), which the server must be told because a Linux one does not.
a.extend(["--volume".into(), format!("{dir}:/var/lib/mysql")]);
if let Some(o) = owner {
a.extend(["--user".into(), o.into()]);
}
}
None => a.extend(["--volume".into(), format!("{}:/var/lib/mysql", n.volume)]),
}
// The password comes from the environment of the docker client, not from this command line.
a.extend(["--env".into(), "MYSQL_ROOT_PASSWORD".into()]);
// "mysqladmin ping" succeeds as soon as the server answers, with or without a login.
a.extend(["--health-cmd".into(), "mysqladmin ping --silent".into()]);
// "mysqladmin ping" succeeds as soon as the server answers, with or without a login. It must go over TCP, like
// everything the Manager sends: while a new database initialises, the image first runs a temporary server that
// answers on its socket but takes no network connection, and a socket ping would call the container healthy for a few
// seconds in which every TCP connection is still refused.
a.extend(["--health-cmd".into(), "mysqladmin ping --protocol=tcp --host=127.0.0.1 --silent".into()]);
a.extend(["--health-interval".into(), "5s".into(), "--health-timeout".into(), "5s".into(), "--health-retries".into(), "40".into()]);
a.extend(["--stop-timeout".into(), "60".into()]);
a.push(cfg.mysql_image.clone());
if cfg.mysql_data.is_some() {
a.push("--lower-case-table-names=1".into());
}
a
}
@@ -335,17 +376,33 @@ enum GameKind {
}
/// Connection strings: host;port;user;password;database. They hold the password, so they travel by environment.
fn database_env(s: &Secrets, world: bool) -> Vec<(String, String)> {
fn database_env(s: &Secrets, world: bool, realm: crate::realms::Mode) -> Vec<(String, String)> {
let info = |db: &str| format!("db;3306;acore;{};{db}", s.app);
let mut env = vec![("AC_LOGIN_DATABASE_INFO".to_string(), info("acore_auth"))];
if world {
env.push(("AC_WORLD_DATABASE_INFO".into(), info("acore_world")));
env.push(("AC_CHARACTER_DATABASE_INFO".into(), info("acore_characters")));
// The databases of the selected realm (the Wildcard realm has its own world and characters databases).
let schema = |kind: &str| realm.schema(kind).unwrap_or("acore_world");
env.push(("AC_WORLD_DATABASE_INFO".into(), info(schema("world"))));
env.push(("AC_CHARACTER_DATABASE_INFO".into(), info(schema("characters"))));
}
env
}
fn game_args(cfg: &Config, n: &Names, kind: GameKind, host: &Path, port: u16, ra_port: u16, owner: Option<&str>) -> Vec<String> {
/// Realm profiles are only in play once a profile has been chosen on this server (`Settings/realm-profile.json`).
fn prepare_realm(root: &Path, log: &mut Log) -> Step<crate::realms::Mode> {
let fail_with = |e: crate::error::Error| Failure { code: ErrorCode::StartupFailed, output: e.to_string() };
crate::realms::before_start(root).map_err(fail_with)?;
let active = crate::realms::state(root).map_err(fail_with)?.active;
if root.join("Settings/realm-profile.json").exists() {
crate::realms::setup_realmlist(root).map_err(fail_with)?;
let db = crate::db::Db::from_repack(root, crate::db::Account::Admin).map_err(fail_with)?;
db.query("UPDATE acore_auth.realmlist SET name='Conquest of Azeroth' WHERE id=1; UPDATE acore_auth.realmlist SET name='Wildcard' WHERE id=2;").map_err(fail_with)?;
log.say(format!("realm {}", active.name()));
}
Ok(active)
}
fn game_args(cfg: &Config, n: &Names, kind: GameKind, host: &Path, data: &Path, port: u16, ra_port: u16, owner: Option<&str>) -> Vec<String> {
let (name, alias, binary, conf, inner_port) = match kind {
GameKind::World => (&n.world, "world", "./worldserver", "configs/worldserver.conf", WORLD_PORT),
GameKind::Auth => (&n.auth, "auth", "./authserver", "configs/authserver.conf", AUTH_PORT),
@@ -370,7 +427,11 @@ fn game_args(cfg: &Config, n: &Names, kind: GameKind, host: &Path, port: u16, ra
// the container and stops the server when it cannot find one.
a.extend(env("AC_UPDATES_ENABLE_DATABASES", "0"));
if kind == GameKind::World {
a.extend(["--volume".into(), format!("{}:{DATA}:ro", host.join("Data").display())]);
a.extend(["--volume".into(), format!("{}:{DATA}:ro", data.display())]);
let races = host.join("Data/dbc_races");
if races.is_dir() && races != data.join("dbc_races") {
a.extend(["--volume".into(), format!("{}:{DATA}/dbc_races:ro", races.display())]);
}
a.extend(env("AC_DATA_DIR", DATA));
// The remote console is only ever reachable from this computer.
a.extend(["--publish".into(), format!("127.0.0.1:{ra_port}:{RA_PORT}")]);
@@ -674,6 +735,55 @@ mod tests {
assert!(runs[1].args.windows(2).any(|w| w == ["--env", "AC_WORLD_DATABASE_INFO"]), "name only, the value is in the environment");
}
// Unix only: the folder is a Linux path (a Windows path has a colon, which a Docker folder may not).
#[cfg(unix)]
#[test]
fn a_release_fixture_runs_its_database_on_the_package_data_directory_not_on_a_volume() {
let (_d, root) = server("t1");
fs::write(root.join("Settings/docker.json"), r#"{"project":"t1","mysqlData":"/work/fixture/mysql/data"}"#).unwrap();
let sim = Sim::new();
assert!(run_with(&sim, &root, Verb::StartMysql).unwrap().ok);
let db = &sim.calls_of("run")[0].args;
assert!(db.windows(2).any(|w| w == ["--volume", "/work/fixture/mysql/data:/var/lib/mysql"]), "{db:?}");
assert!(!db.iter().any(|a| a.starts_with("coa-t1-db:")), "no named volume: {db:?}");
assert!(db.iter().any(|a| a == "--user"), "the folder is written by its owner");
assert_eq!(db.last().map(String::as_str), Some("--lower-case-table-names=1"), "a server option, so after the image name");
// An installation never gets any of it.
let (_d2, root2) = server("t2");
let sim2 = Sim::new();
assert!(run_with(&sim2, &root2, Verb::StartMysql).unwrap().ok);
let plain = &sim2.calls_of("run")[0].args;
assert!(plain.windows(2).any(|w| w == ["--volume", "coa-t2-db:/var/lib/mysql"]), "{plain:?}");
assert!(!plain.iter().any(|a| a == "--lower-case-table-names=1" || a == "--user"));
}
#[test]
fn the_containers_use_the_databases_of_the_selected_realm() {
let s = Secrets { root: "r".into(), app: "apppw".into() };
let get = |env: &[(String, String)], k: &str| env.iter().find(|(n, _)| n == k).map(|(_, v)| v.clone());
let coa = database_env(&s, true, crate::realms::Mode::Coa);
assert_eq!(get(&coa, "AC_WORLD_DATABASE_INFO").unwrap(), "db;3306;acore;apppw;acore_world");
assert_eq!(get(&coa, "AC_CHARACTER_DATABASE_INFO").unwrap(), "db;3306;acore;apppw;acore_characters");
let wild = database_env(&s, true, crate::realms::Mode::Wildcard);
assert_eq!(get(&wild, "AC_WORLD_DATABASE_INFO").unwrap(), "db;3306;acore;apppw;acore_world_wildcard");
assert_eq!(get(&wild, "AC_CHARACTER_DATABASE_INFO").unwrap(), "db;3306;acore;apppw;acore_characters_wildcard");
// Accounts are shared by both realms; the auth server never sees the others.
assert_eq!(get(&wild, "AC_LOGIN_DATABASE_INFO").unwrap(), "db;3306;acore;apppw;acore_auth");
let auth = database_env(&s, false, crate::realms::Mode::Wildcard);
assert_eq!(auth.len(), 1);
}
#[test]
fn the_database_is_only_healthy_once_it_takes_tcp_connections() {
let (_d, root) = server("t1");
let sim = Sim::new();
assert!(start_all(&sim, &root).ok);
let db = &sim.calls_of("run")[0].args;
let i = db.iter().position(|a| a == "--health-cmd").expect("the database has a health check");
// Found on a new volume: a socket-only ping reported healthy about four seconds before TCP worked.
assert!(db[i + 1].contains("--protocol=tcp") && db[i + 1].contains("--host=127.0.0.1"), "{}", db[i + 1]);
}
#[test]
fn the_world_container_is_wired_like_the_repack_layout() {
let (_d, root) = server("t1");
@@ -714,8 +824,8 @@ mod tests {
let (_d, root) = server("ports");
let cfg = Config::load(&root).unwrap();
let n = cfg.names();
let world = game_args(&cfg, &n, GameKind::World, &root, 18085, 13443, None);
let auth = game_args(&cfg, &n, GameKind::Auth, &root, 13724, 0, None);
let world = game_args(&cfg, &n, GameKind::World, &root, &root.join("Data"), 18085, 13443, None);
let auth = game_args(&cfg, &n, GameKind::Auth, &root, &root.join("Data"), 13724, 0, None);
assert!(world.iter().any(|a| a == "127.0.0.1:18085:8085"));
assert!(world.iter().any(|a| a == "127.0.0.1:13443:3443"));
assert!(world.iter().any(|a| a == "AC_WORLD_SERVER_PORT=8085"));
+68 -3
View File
@@ -15,10 +15,13 @@
//! ```
mod cli;
pub mod fixture;
pub mod install;
mod lifecycle;
pub use cli::{Call, Docker, Output, SystemDocker};
pub use lifecycle::{observe, observe_with, run, run_with};
pub use lifecycle::{check_docker, observe, observe_with, run, run_with};
pub(crate) use lifecycle::destroy;
use std::net::IpAddr;
use std::path::Path;
@@ -31,7 +34,7 @@ use crate::layout::{self, Classification, ScanReport};
/// Present in a Docker installation, absent from a repack.
pub const MARKER: &str = "Settings/docker.json";
const MYSQL_IMAGE: &str = "mysql:8.4";
pub(crate) const MYSQL_IMAGE: &str = "mysql:8.4";
const RUNTIME_DOCKERFILE: &str = include_str!("Dockerfile.runtime");
pub fn is_docker(root: &Path) -> bool {
@@ -57,6 +60,14 @@ pub struct Config {
pub bind_address: String,
#[serde(default = "mysql_image")]
pub mysql_image: String,
/// Where the game data (dbc, maps, vmaps, mmaps) is, when it is not the `Data` folder of the server. Used in place and
/// mounted read-only, so one copy can serve several servers.
#[serde(default, skip_serializing_if = "Option::is_none")]
pub data_dir: Option<String>,
/// A MySQL data directory the database container uses in place of its volume. Only for the disposable fixture that
/// validates a release (the data directory of the signed base package); an installation never sets it.
#[serde(default, skip_serializing_if = "Option::is_none")]
pub mysql_data: Option<String>,
}
pub(crate) struct Names {
@@ -74,6 +85,11 @@ impl Config {
Ok(cfg)
}
/// The folder mounted as the game data.
pub fn data_path(&self, root: &Path) -> std::path::PathBuf {
self.data_dir.as_deref().map(std::path::PathBuf::from).unwrap_or_else(|| root.join("Data"))
}
fn validate(&self) -> Result<()> {
let name_ok = !self.project.is_empty()
&& self.project.len() <= 32
@@ -85,6 +101,12 @@ impl Config {
if self.bind_address.parse::<IpAddr>().is_err() {
return Err(Error::Invalid(format!("{} is not an IP address.", self.bind_address)));
}
for d in [&self.data_dir, &self.mysql_data].into_iter().flatten() {
// The folder goes into a `--volume host:container` option, where a colon would be read as a separator.
if !Path::new(d).is_absolute() || d.contains(':') {
return Err(Error::Invalid("A Docker folder must be a full path without a colon.".into()));
}
}
let image_ok = !self.mysql_image.is_empty() && self.mysql_image.chars().all(|c| c.is_ascii_alphanumeric() || "._/:@-".contains(c));
if !image_ok {
return Err(Error::Invalid("The database image name is not valid.".into()));
@@ -103,6 +125,21 @@ impl Config {
}
}
/// Create the world and auth configuration files from their `.dist` templates when they do not exist. A package only
/// carries the templates, and on Windows the launcher writes the active files at every start; here nothing else would.
/// An existing file is never touched, so the person's settings survive updates. Returns the files created.
pub fn ensure_main_configs(root: &Path) -> Result<Vec<String>> {
let mut created = Vec::new();
for name in ["worldserver", "authserver"] {
let (conf, dist) = (root.join(format!("Core/configs/{name}.conf")), root.join(format!("Core/configs/{name}.conf.dist")));
if !conf.exists() && dist.is_file() {
std::fs::copy(&dist, &conf)?;
created.push(format!("{name}.conf"));
}
}
Ok(created)
}
/// Name of the runtime image: it follows the content of its Dockerfile, so changing the libraries builds a new image.
pub(crate) fn runtime_image() -> String {
format!("coa-runtime:{}", &fsx::sha256_bytes(RUNTIME_DOCKERFILE.as_bytes())[..12])
@@ -123,7 +160,8 @@ pub(crate) fn scan(root: &Path) -> Result<ScanReport> {
let bot_active = modules_dir.join("mod_coa_playerbots.conf");
let bot_conf = if bot_active.is_file() { bot_active } else { modules_dir.join("mod_coa_playerbots.conf.dist") };
let bot_config_keys = layout::count_bot_keys(&bot_conf);
let has_data = layout::exists(root, "Data/dbc") && layout::exists(root, "Data/maps");
let data = cfg.as_ref().map(|c| c.data_path(root)).unwrap_or_else(|_| root.join("Data"));
let has_data = data.join("dbc").is_dir() && data.join("maps").is_dir();
let has_confs = layout::exists(root, "Core/configs/worldserver.conf") && layout::exists(root, "Core/configs/authserver.conf");
let items = vec![
@@ -162,3 +200,30 @@ pub(crate) fn scan(root: &Path) -> Result<ScanReport> {
})
}
#[cfg(test)]
mod tests {
use super::*;
use std::fs;
#[test]
fn the_main_configs_are_created_from_their_templates_and_never_overwritten() {
let d = tempfile::tempdir().unwrap();
let cfg = d.path().join("Core/configs");
fs::create_dir_all(&cfg).unwrap();
fs::write(cfg.join("worldserver.conf.dist"), "Setting = default\n").unwrap();
fs::write(cfg.join("authserver.conf.dist"), "Auth = default\n").unwrap();
assert_eq!(ensure_main_configs(d.path()).unwrap(), ["worldserver.conf", "authserver.conf"]);
assert_eq!(fs::read_to_string(cfg.join("worldserver.conf")).unwrap(), "Setting = default\n");
// The person's own settings survive the next start.
fs::write(cfg.join("worldserver.conf"), "Setting = mine\n").unwrap();
assert!(ensure_main_configs(d.path()).unwrap().is_empty());
assert_eq!(fs::read_to_string(cfg.join("worldserver.conf")).unwrap(), "Setting = mine\n");
// Without a template there is nothing to create and nothing fails.
fs::remove_file(cfg.join("authserver.conf")).unwrap();
fs::remove_file(cfg.join("authserver.conf.dist")).unwrap();
assert!(ensure_main_configs(d.path()).unwrap().is_empty());
}
}
+152 -2
View File
@@ -31,8 +31,9 @@ impl Verb {
}
}
fn timeout(self) -> Duration {
fn timeout(self, root: &Path) -> Duration {
match self {
Verb::StartAll | Verb::StartWorld if squid_enabled(root) => Duration::from_secs(2700),
Verb::StartAll | Verb::StartWorld => Duration::from_secs(420),
Verb::StartMysql => Duration::from_secs(120),
Verb::StopAll => Duration::from_secs(240),
@@ -40,6 +41,14 @@ impl Verb {
}
}
fn squid_enabled(root: &Path) -> bool {
let active = root.join("Core/configs/modules/playerbots.conf");
let path = if active.exists() { active } else { root.join("Core/configs/modules/playerbots.conf.dist") };
std::fs::read(path).ok().and_then(|bytes| crate::config::parser::ConfFile::parse_bytes(&bytes).ok())
.is_some_and(|config| config.get("AiPlayerbot.Enabled").is_none_or(|value|
!matches!(value.trim().trim_matches('"').to_ascii_lowercase().as_str(), "0" | "false" | "no" | "off")))
}
#[derive(Debug, Clone, Serialize)]
pub struct DriverOutcome {
pub ok: bool,
@@ -98,6 +107,7 @@ fn run_inner(root: &Path, verb: Verb, validating_update: bool) -> Result<DriverO
}
if matches!(verb, Verb::StartAll | Verb::StartWorld) { crate::modules::ensure_bot_exclusivity(&root)?; }
if crate::docker::is_docker(&root) {
prepare_headless_world(&root, verb)?;
return crate::docker::run(&root, verb);
}
if verb == Verb::StopAll { crate::multiworld::stop(&root)?; }
@@ -114,6 +124,7 @@ fn run_inner(root: &Path, verb: Verb, validating_update: bool) -> Result<DriverO
}
if matches!(verb, Verb::StartAll | Verb::StartWorld) { crate::modules::ensure_bot_exclusivity(&root)?; }
let (python, script) = launcher(&root)?;
prepare_headless_world(&root, verb)?;
let original = std::fs::read_to_string(&script)?;
let patched = patch_launcher_imports(&original)?;
if original != patched {
@@ -127,6 +138,7 @@ fn run_inner(root: &Path, verb: Verb, validating_update: bool) -> Result<DriverO
}
}
}
discard_damaged_launcher_state(&root);
let mut cmd = Command::new(&python);
cmd.arg("-B").arg("-c").arg(LAUNCH_SCRIPT).arg(&script).arg(verb.arg())
.current_dir(&root).stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::piped());
@@ -149,7 +161,7 @@ fn run_inner(root: &Path, verb: Verb, validating_update: bool) -> Result<DriverO
let _ = stderr.read_to_string(&mut s);
s
});
let deadline = Instant::now() + verb.timeout();
let deadline = Instant::now() + verb.timeout(&root);
let status = loop {
if let Some(st) = child.try_wait()? {
break Some(st);
@@ -179,10 +191,55 @@ fn run_inner(root: &Path, verb: Verb, validating_update: bool) -> Result<DriverO
}
};
tracing::info!(?verb, ok, ?code, "driver: launcher verb finished");
if !ok && !output.is_empty() {
let redacted = crate::diag::redact(&output);
let tail: Vec<_> = redacted.lines().rev().take(12).collect();
tracing::warn!(?verb, exit_code, output = %tail.into_iter().rev().collect::<Vec<_>>().join("\n"), "driver: launcher verb failed");
}
if ok && verb == Verb::StartAll { crate::multiworld::start(&root)?; }
Ok(DriverOutcome { ok, exit_code, code, human: code.map(ErrorCode::human), output })
}
/// Background servers receive no interactive stdin. Keep CLI EOF from stopping the world server;
/// the Manager's console uses remote access instead. The template survives launcher regeneration.
fn prepare_headless_world(root: &Path, verb: Verb) -> Result<()> {
if !matches!(verb, Verb::StartAll | Verb::StartWorld) { return Ok(()); }
for relative in ["Settings/worldserver.conf.template", "Core/configs/worldserver.conf"] {
let path = root.join(relative);
let bytes = match std::fs::read(&path) {
Ok(bytes) => bytes,
Err(e) if e.kind() == std::io::ErrorKind::NotFound => continue,
Err(e) => return Err(e.into()),
};
let mut config = crate::config::parser::ConfFile::parse_bytes(&bytes)?;
config.set("Console.Enable", "0", &["Local console is disabled for background startup; the Manager uses remote access."]);
let text = config.to_text();
if text.as_bytes() != bytes {
fsx::atomic_write(&path, text.as_bytes())?;
}
}
Ok(())
}
/// The launcher keeps one JSON record per service in `.state`. A crash or power loss while it writes one can leave
/// a file of the right length that holds only zero bytes (NTFS keeps the length but not the data), and the launcher
/// then dies on every start with an unreadable record. Such a file carries no information, so remove it: the
/// launcher treats a missing record as "not running". Only empty or all-zero `*.json` files are touched.
pub(crate) fn discard_damaged_launcher_state(root: &Path) -> Vec<PathBuf> {
let mut removed = Vec::new();
let Ok(entries) = std::fs::read_dir(root.join(".state")) else { return removed; };
for entry in entries.flatten() {
let path = entry.path();
if path.extension().is_none_or(|e| !e.eq_ignore_ascii_case("json")) || !path.is_file() { continue; }
let Ok(bytes) = std::fs::read(&path) else { continue; };
if bytes.iter().all(|b| *b == 0) && std::fs::remove_file(&path).is_ok() {
tracing::warn!(file = %path.display(), bytes = bytes.len(), "driver: removed a launcher state file damaged by an interrupted write");
removed.push(path);
}
}
removed
}
const LAUNCH_SCRIPT: &str = "import runpy,sys;from pathlib import Path;script=sys.argv[1];sys.path.insert(0,str(Path(script).resolve().parent));sys.argv=sys.argv[1:];runpy.run_path(script,run_name='__main__')";
pub(crate) fn patch_launcher_imports(text: &str) -> Result<String> {
@@ -202,6 +259,20 @@ pub(crate) fn launcher_matches(signed: &str, actual: &[u8]) -> bool {
|| patch_launcher_imports(&s).is_ok_and(|p| p.as_bytes() == actual))
}
/// Recover legacy metadata only when undoing supported Manager edits reproduces the recorded hash.
pub(crate) fn launcher_matches_recorded(recorded: &str, actual: &[u8]) -> bool {
let Ok(text) = std::str::from_utf8(actual) else { return false; };
let without_import = text.replacen(
"ROOT = Path(__file__).resolve().parents[1]\nsys.path.insert(0, str(Path(__file__).resolve().parent))",
"ROOT = Path(__file__).resolve().parents[1]", 1,
);
for candidate in [Some(without_import.clone()), crate::realms::unpatch_launcher(&without_import)].into_iter().flatten() {
if crate::fsx::sha256_bytes(candidate.as_bytes()).eq_ignore_ascii_case(recorded)
&& launcher_matches(&candidate, actual) { return true; }
}
false
}
pub(crate) fn startup_failure(root: &Path, started: &DriverOutcome) -> String {
let code = started.code.filter(|c| *c != ErrorCode::Unknown)
.or_else(|| crate::health::diagnose_installation(root));
@@ -216,6 +287,85 @@ pub(crate) fn startup_failure(root: &Path, started: &DriverOutcome) -> String {
mod tests {
use super::*;
#[test]
fn background_start_disables_cli_in_template_and_rendered_config() {
let folder = tempfile::tempdir().unwrap();
let root = folder.path();
std::fs::create_dir_all(root.join("Settings")).unwrap();
std::fs::create_dir_all(root.join("Core/configs")).unwrap();
let template = root.join("Settings/worldserver.conf.template");
let rendered = root.join("Core/configs/worldserver.conf");
let original = "\u{feff}# Custom settings\r\nConsole.Enable = 1\r\nRa.Enable = 1\r\nPlayerLimit = 42\r\n";
std::fs::write(&template, original).unwrap();
std::fs::write(&rendered, original).unwrap();
let auth = root.join("Core/configs/authserver.conf");
std::fs::write(&auth, "custom auth config").unwrap();
for verb in [Verb::StartMysql, Verb::StopAll] {
prepare_headless_world(root, verb).unwrap();
assert_eq!(std::fs::read_to_string(&template).unwrap(), original);
assert_eq!(std::fs::read_to_string(&rendered).unwrap(), original);
}
for verb in [Verb::StartAll, Verb::StartWorld] {
std::fs::write(&template, original).unwrap();
std::fs::write(&rendered, original).unwrap();
prepare_headless_world(root, verb).unwrap();
let expected = original.replace("Console.Enable = 1", "Console.Enable = 0");
assert_eq!(std::fs::read_to_string(&template).unwrap(), expected);
assert_eq!(std::fs::read_to_string(&rendered).unwrap(), expected);
prepare_headless_world(root, verb).unwrap();
assert_eq!(std::fs::read_to_string(&template).unwrap(), expected);
}
assert_eq!(std::fs::read_to_string(auth).unwrap(), "custom auth config");
}
#[test]
fn background_start_overrides_an_absent_or_duplicate_console_setting() {
let folder = tempfile::tempdir().unwrap();
let root = folder.path();
prepare_headless_world(root, Verb::StartAll).unwrap();
std::fs::create_dir_all(root.join("Core/configs")).unwrap();
let path = root.join("Core/configs/worldserver.conf");
for original in ["Ra.Enable = 1\n", "Console.Enable = 0\nConsole.Enable = 1\n"] {
std::fs::write(&path, original).unwrap();
prepare_headless_world(root, Verb::StartAll).unwrap();
let bytes = std::fs::read(&path).unwrap();
let config = crate::config::parser::ConfFile::parse_bytes(&bytes).unwrap();
assert_eq!(config.get("Console.Enable"), Some("0"));
prepare_headless_world(root, Verb::StartAll).unwrap();
assert_eq!(std::fs::read(&path).unwrap(), bytes);
}
}
#[test]
fn large_squid_provisioning_has_time_to_finish_without_extending_shutdown() {
let folder = tempfile::tempdir().unwrap();
let modules = folder.path().join("Core/configs/modules");
std::fs::create_dir_all(&modules).unwrap();
std::fs::write(modules.join("playerbots.conf.dist"), "AiPlayerbot.Enabled = 1\n").unwrap();
assert_eq!(Verb::StartAll.timeout(folder.path()), Duration::from_secs(2700));
assert_eq!(Verb::StopAll.timeout(folder.path()), Duration::from_secs(240));
std::fs::write(modules.join("playerbots.conf"), "AiPlayerbot.Enabled = 0\n").unwrap();
assert_eq!(Verb::StartWorld.timeout(folder.path()), Duration::from_secs(420));
}
#[test]
fn zero_filled_launcher_state_is_discarded_and_valid_state_is_kept() {
let folder = tempfile::tempdir().unwrap();
let state = folder.path().join(".state");
std::fs::create_dir_all(&state).unwrap();
std::fs::write(state.join("mysql.json"), vec![0u8; 116]).unwrap();
std::fs::write(state.join("configuration.json"), Vec::<u8>::new()).unwrap();
std::fs::write(state.join("world.json"), "{\"pid\": 4}\n").unwrap();
std::fs::write(state.join("stop-relay"), Vec::<u8>::new()).unwrap();
std::fs::write(state.join("auth.json"), "{\"pid\": 0}").unwrap();
let mut removed: Vec<_> = discard_damaged_launcher_state(folder.path()).iter().map(|p| p.file_name().unwrap().to_string_lossy().into_owned()).collect();
removed.sort();
assert_eq!(removed, ["configuration.json", "mysql.json"]);
assert!(state.join("world.json").exists() && state.join("auth.json").exists() && state.join("stop-relay").exists());
assert!(discard_damaged_launcher_state(folder.path()).is_empty());
assert!(discard_damaged_launcher_state(&folder.path().join("missing")).is_empty());
}
#[test]
fn translates_known_launcher_messages() {
assert_eq!(translate("RuntimeError: Port 8085 is already used. Stop the other server"), ErrorCode::PortInUse);
+64 -3
View File
@@ -31,11 +31,25 @@ pub struct Settings {
pub mode: Mode,
/// The address friends type into their client for this mode.
pub host: Option<String>,
/// Independent of the effective host of the current mode. None means automatic LAN detection.
#[serde(default)]
pub lan_address_override: Option<String>,
}
impl Default for Settings {
fn default() -> Self {
Settings { mode: Mode::Local, host: None }
Settings { mode: Mode::Local, host: None, lan_address_override: None }
}
}
impl Settings {
/// Only LAN application changes the LAN preference. Other modes keep it for the next LAN session.
pub fn select_mode(&mut self, mode: Mode, host: String, lan_override: Option<String>) {
if mode == Mode::Lan {
self.lan_address_override = lan_override;
}
self.mode = mode;
self.host = Some(host);
}
}
@@ -233,7 +247,7 @@ CoA.AllowRemoteClients = 0
fn a_shared_server_gets_its_bind_address_back_before_start_and_a_local_one_is_left_alone() {
let (_d, root, meta) = setup();
assert!(!ensure_bind(&root, &meta).unwrap(), "local mode: nothing to do");
save(&meta, &Settings { mode: Mode::Private, host: Some("100.64.1.2".into()) }).unwrap();
save(&meta, &Settings { mode: Mode::Private, host: Some("100.64.1.2".into()), ..Settings::default() }).unwrap();
assert!(ensure_bind(&root, &meta).unwrap(), "templates were reset to 127.0.0.1 -> reopened");
assert!(bind_is_open(&root));
assert!(!ensure_bind(&root, &meta).unwrap(), "already open: idempotent");
@@ -243,11 +257,39 @@ CoA.AllowRemoteClients = 0
fn settings_round_trip_and_default_to_local() {
let d = tempfile::tempdir().unwrap();
assert_eq!(load(d.path()).mode, Mode::Local);
save(d.path(), &Settings { mode: Mode::Private, host: Some("100.64.1.2".into()) }).unwrap();
save(d.path(), &Settings { mode: Mode::Private, host: Some("100.64.1.2".into()), ..Settings::default() }).unwrap();
let s = load(d.path());
assert_eq!((s.mode, s.host.as_deref()), (Mode::Private, Some("100.64.1.2")));
}
#[test]
fn old_settings_load_without_migrating_effective_host_to_override() {
let s: Settings = serde_json::from_str(r#"{"mode":"lan","host":"192.168.1.50"}"#).unwrap();
assert_eq!(s.mode, Mode::Lan);
assert_eq!(s.host.as_deref(), Some("192.168.1.50"));
assert_eq!(s.lan_address_override, None);
}
#[test]
fn lan_preference_survives_save_load_and_every_other_mode_and_can_be_cleared() {
let d = tempfile::tempdir().unwrap();
let mut s = Settings::default();
s.select_mode(Mode::Lan, "192.168.1.50".into(), Some("192.168.1.50".into()));
for (mode, host) in [(Mode::Private, "100.101.20.5"), (Mode::Direct, "203.0.113.9"), (Mode::Local, "127.0.0.1")] {
s.select_mode(mode, host.into(), None);
save(d.path(), &s).unwrap();
s = load(d.path());
assert_eq!(s.lan_address_override.as_deref(), Some("192.168.1.50"));
assert_eq!(s.host.as_deref(), Some(host));
let lan = crate::net::resolve_lan_host(s.lan_address_override.as_deref(), Some("192.168.0.169".parse().unwrap())).unwrap();
s.select_mode(Mode::Lan, lan, s.lan_address_override.clone());
assert_eq!(s.host.as_deref(), Some("192.168.1.50"));
}
s.select_mode(Mode::Lan, "192.168.0.169".into(), None);
save(d.path(), &s).unwrap();
assert_eq!(load(d.path()).lan_address_override, None);
}
#[test]
fn friend_package_contains_only_whitelisted_files() {
let (d, root, _m) = setup();
@@ -274,4 +316,23 @@ CoA.AllowRemoteClients = 0
}
assert!(make_friend_package(&root, "bad host; x", false, &d.path().join("x.zip")).is_err());
}
#[test]
fn manual_lan_host_survives_startup_bind_restoration_and_drives_friend_package() {
let (d, root, meta) = setup();
let mut s = Settings::default();
s.select_mode(Mode::Lan, "192.168.1.50".into(), Some("192.168.1.50".into()));
save(&meta, &s).unwrap();
assert!(ensure_bind(&root, &meta).unwrap());
assert!(bind_is_open(&root));
let restored = load(&meta);
assert_eq!(restored.host.as_deref(), Some("192.168.1.50"));
assert_eq!(restored.lan_address_override.as_deref(), Some("192.168.1.50"));
let package = d.path().join("manual-lan.zip");
make_friend_package(&root, restored.host.as_deref().unwrap(), false, &package).unwrap();
let mut zip = zip::ZipArchive::new(fs::File::open(package).unwrap()).unwrap();
let mut realm = String::new();
std::io::Read::read_to_string(&mut zip.by_name("realmlist.wtf").unwrap(), &mut realm).unwrap();
assert_eq!(realm, "set realmlist 192.168.1.50\r\n");
}
}
+40 -2
View File
@@ -123,7 +123,7 @@ pub fn atomic_write(path: &Path, bytes: &[u8]) -> Result<()> {
let tmp = parent.join(format!(
".{}.{}.tmp",
path.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default(),
std::process::id()
uuid::Uuid::new_v4().simple()
));
let write = || -> std::io::Result<()> {
let mut f = OpenOptions::new().write(true).create_new(true).open(&tmp)?;
@@ -135,13 +135,41 @@ pub fn atomic_write(path: &Path, bytes: &[u8]) -> Result<()> {
let _ = fs::remove_file(&tmp);
return Err(e.into());
}
if let Err(e) = fs::rename(&tmp, path) {
if let Err(e) = durable_replace(&tmp, path) {
let _ = fs::remove_file(&tmp);
return Err(e.into());
}
Ok(())
}
/// The temporary file must already be flushed, on the same volume as the destination.
pub(crate) fn durable_replace(from: &Path, to: &Path) -> std::io::Result<()> {
#[cfg(windows)]
{
use std::os::windows::ffi::OsStrExt;
use windows_sys::Win32::Storage::FileSystem::{MoveFileExW, MOVEFILE_REPLACE_EXISTING, MOVEFILE_WRITE_THROUGH};
fn wide(path: &Path) -> std::io::Result<Vec<u16>> {
let absolute = std::path::absolute(path)?;
let text = absolute.as_os_str().to_string_lossy().replace('/', "\\");
let extended = if text.starts_with("\\\\?\\") { text }
else if let Some(unc) = text.strip_prefix("\\\\") { format!("\\\\?\\UNC\\{unc}") }
else { format!("\\\\?\\{text}") };
Ok(std::ffi::OsStr::new(&extended).encode_wide().chain(Some(0)).collect())
}
let src = wide(from)?;
let dst = wide(to)?;
if unsafe { MoveFileExW(src.as_ptr(), dst.as_ptr(), MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH) } == 0 {
return Err(std::io::Error::last_os_error());
}
Ok(())
}
#[cfg(not(windows))]
{
fs::rename(from, to)?;
File::open(to.parent().unwrap())?.sync_all()
}
}
pub fn atomic_write_json<T: serde::Serialize>(path: &Path, value: &T) -> Result<()> {
let mut bytes = serde_json::to_vec_pretty(value)?;
bytes.push(b'\n');
@@ -199,6 +227,16 @@ pub fn require_space(path: &Path, needed: u64) -> Result<()> {
mod tests {
use super::*;
#[test]
fn durable_replacement_handles_long_transaction_backup_paths() {
let dir = tempfile::tempdir().unwrap();
let parent = dir.path().join("a".repeat(90)).join("b".repeat(90));
let path = parent.join("configuration-with-a-long-name.template");
atomic_write(&path, b"old").unwrap();
atomic_write(&path, b"new").unwrap();
assert_eq!(fs::read(&path).unwrap(), b"new");
}
#[test]
fn safe_join_accepts_normal_and_rejects_traversal() {
let root = Path::new("C:/srv");
+27 -13
View File
@@ -35,7 +35,7 @@ pub struct Preflight {
pub free_bytes: u64,
}
fn problem(code: &'static str, message: &str) -> Problem {
pub(crate) fn problem(code: &'static str, message: &str) -> Problem {
Problem { code, message: message.into() }
}
@@ -133,7 +133,7 @@ pub struct Installed {
pub version: String,
}
fn random_hex(n: usize) -> String {
pub(crate) fn random_hex(n: usize) -> String {
let mut s = String::new();
while s.len() < n {
s.push_str(&uuid::Uuid::new_v4().simple().to_string());
@@ -148,7 +148,7 @@ pub(crate) fn bootstrap_database(root: &Path) -> Result<()> {
with_scratch_ports(root, || bootstrap_database_inner(root))
}
fn free_port() -> Result<u16> {
pub(crate) fn free_port() -> Result<u16> {
Ok(std::net::TcpListener::bind("127.0.0.1:0")?.local_addr()?.port())
}
@@ -183,7 +183,7 @@ fn bootstrap_database_inner(root: &Path) -> Result<()> {
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())));
return Err(Error::Invalid(format!("The database could not be started. {}", driver::startup_failure(root, &started))));
}
let result = (|| -> Result<()> {
let db = Db::from_repack(root, Account::Admin)?;
@@ -210,8 +210,14 @@ fn bootstrap_database_inner(root: &Path) -> Result<()> {
}
Ok(())
})();
let _ = driver::run(root, Verb::StopAll);
let stopped = driver::run(root, Verb::StopAll);
result?;
// A database that keeps running locks its files, and the folder could not be moved into place afterwards.
match stopped {
Ok(out) if out.ok => {}
Ok(out) => return Err(Error::Invalid(format!("The database could not be stopped after preparing it. {}", driver::startup_failure(root, &out)))),
Err(e) => return Err(e),
}
fs::remove_file(&boot)?;
Ok(())
}
@@ -250,7 +256,7 @@ pub fn install_base(p: &Params, report: &dyn Fn(Step)) -> Result<Installed> {
if staging_root.join(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())));
return Err(Error::Invalid(format!("{} is left over from an earlier installation that did not finish, and the Manager cannot tell whether it may be deleted. Delete that folder yourself, then try again.", staging_root.display())));
}
}
fs::create_dir_all(&staging_root)?;
@@ -268,9 +274,8 @@ pub fn install_base(p: &Params, report: &dyn Fn(Step)) -> Result<Installed> {
}
Ok(())
})?;
fs::remove_file(staging_root.join(MARKER))?;
// 4. Commit: the only moment the destination changes.
// 4. Commit: the only moment the destination changes. The marker stays until everything is done, so an
// unfinished install can always be recognised as ours (and cleaned up), wherever it stopped.
say("Finishing", 95, None);
if dest.exists() {
fs::remove_dir(&dest)?; // only succeeds for an empty folder (preflight verified)
@@ -288,15 +293,24 @@ pub fn install_base(p: &Params, report: &dyn Fn(Step)) -> Result<Installed> {
}
let md = MetaDir::create(&dest, &meta)?;
fsx::atomic_write(&md.root.join("manifests").join("base.json"), &manifest_bytes)?;
// Complete from here on: the marker goes just before the server is listed.
fs::remove_file(dest.join(MARKER))?;
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(MARKER).exists() {
// Unfinished work of ours; the destination was never touched.
let _ = driver::run(&staging_root, Verb::StopAll);
let _ = fs::remove_dir_all(&staging_root);
if result.is_err() {
if staging_root.join(MARKER).exists() {
// Unfinished work of ours; the destination was never touched.
let _ = driver::run(&staging_root, Verb::StopAll);
let _ = fs::remove_dir_all(&staging_root);
} else if dest.join(MARKER).is_file() {
// Failed after the folder was moved into place. The destination was empty or absent before (preflight),
// so what carries our marker is only our unfinished install.
let _ = driver::run(&dest, Verb::StopAll);
let _ = fs::remove_dir_all(&dest);
}
}
result
}
+1
View File
@@ -315,6 +315,7 @@ pub fn scan(root: &Path) -> Result<ScanReport> {
(None, None)
};
if crate::squid::imported_repack(&root) { notes.push("import.squidRepackWarning".into()); }
Ok(ScanReport {
path: root.to_string_lossy().into_owned(),
classification,
+11
View File
@@ -2,11 +2,14 @@ pub mod accounts;
pub mod backup;
pub mod cleanbase;
pub mod companions;
pub mod custom_races;
pub mod client;
pub mod remote_client;
pub mod clientdl;
pub mod config;
pub mod console;
pub mod crashes;
pub mod dashboard;
pub mod db;
pub mod diag;
pub mod docker;
@@ -30,6 +33,7 @@ pub mod repair;
pub mod schema_check;
pub mod net;
pub mod package;
pub mod platform;
pub mod ra;
pub mod allsettings;
pub mod modules;
@@ -37,12 +41,19 @@ pub mod realmlist;
pub mod realms;
pub mod registry;
pub mod release;
pub mod report;
pub mod release_schema;
pub mod update;
mod update_isolation;
mod mysql_snapshot;
pub mod wine;
pub mod upnp;
pub mod signing;
pub mod channels;
pub mod srp6;
pub use error::{Error, ErrorCode, Result};
pub const MANAGER_VERSION: &str = env!("CARGO_PKG_VERSION");
pub mod squid;
+96
View File
@@ -48,6 +48,8 @@ pub struct FileEntry {
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Migration {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub compatible_sha256: Vec<String>,
pub id: String,
pub db: String,
pub sha256: String,
@@ -76,9 +78,31 @@ pub struct Revision {
pub commit: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct SourceDatabase {
pub manifest_sha256: String,
pub schema_sha256: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct Compatibility {
pub schema: u32,
pub platform: String,
pub core_commit: String,
pub module_commits: std::collections::BTreeMap<String, String>,
pub client_patch_version: String,
pub source_versions: Vec<String>,
#[serde(default, skip_serializing_if = "std::collections::BTreeMap::is_empty")]
pub source_databases: std::collections::BTreeMap<String, SourceDatabase>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Manifest {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub compatibility: Option<Compatibility>,
pub schema: u32,
pub kind: Kind,
pub version: String,
@@ -134,6 +158,31 @@ impl Manifest {
if parse_version(&self.min_manager_version).is_none() {
return bad(format!("bad minManagerVersion {:?}", self.min_manager_version));
}
if let Some(c) = &self.compatibility {
if parse_version(&self.min_manager_version).is_none_or(|v| v < (0, 6, 13)) {
return bad("Release compatibility matrices require Manager 0.6.13 or newer".into());
}
if c.schema != 1 || !matches!(c.platform.as_str(), "windows-x86_64" | "linux-x86_64")
|| !is_commit(&c.core_commit) || self.core.commit.as_deref() != Some(&c.core_commit)
|| c.module_commits.is_empty() || c.module_commits.values().any(|sha| !is_commit(sha))
|| self.bots.as_ref().and_then(|r| r.commit.as_ref()).is_some_and(|sha| c.module_commits.get("bots") != Some(sha))
|| parse_version(&c.client_patch_version).is_none()
|| c.source_versions.is_empty() || c.source_versions.iter().any(|v| parse_version(v).is_none())
|| c.source_versions.iter().collect::<HashSet<_>>().len() != c.source_versions.len() {
return bad("Invalid release compatibility matrix".into());
}
if !c.source_databases.is_empty() && (c.source_databases.len() != c.source_versions.len()
|| c.source_versions.iter().any(|v| !c.source_databases.contains_key(v))
|| c.source_databases.values().any(|s| !is_sha256(&s.manifest_sha256)
|| s.schema_sha256.as_ref().is_some_and(|sha| !is_sha256(sha)))) {
return bad("Invalid source database compatibility".into());
}
}
for migration in &self.migrations {
if !is_sha256(&migration.sha256) || migration.compatible_sha256.iter().any(|h| !is_sha256(h) || h == &"0".repeat(64)) {
return bad(format!("{}: invalid migration checksum compatibility", migration.id));
}
}
for (label, rev) in [("core", Some(&self.core)), ("bots", self.bots.as_ref())] {
if let Some(Revision { commit: Some(c) }) = rev {
if !is_commit(c) {
@@ -225,6 +274,53 @@ mod tests {
assert!(!m.compatible_with_manager("0.0.9"));
}
#[test]
fn compatibility_matrix_binds_core_and_requires_tested_sources() {
let mut m = Manifest::parse(sample("").as_bytes()).unwrap();
m.min_manager_version = "0.6.13".into();
m.compatibility = Some(Compatibility { schema: 1, platform: "windows-x86_64".into(),
core_commit: "a".repeat(40), module_commits: [("squid".into(), "b".repeat(40))].into(),
source_databases: Default::default(), client_patch_version: "1.5.1".into(), source_versions: vec!["0.261010.32".into()] });
m.validate().unwrap();
m.compatibility.as_mut().unwrap().core_commit = "c".repeat(40);
assert!(m.validate().is_err());
m.compatibility.as_mut().unwrap().core_commit = "a".repeat(40);
m.compatibility.as_mut().unwrap().source_versions.clear();
assert!(m.validate().is_err());
}
#[test]
fn compatibility_cannot_claim_a_different_packaged_bot_revision() {
let mut m = Manifest::parse(sample("").as_bytes()).unwrap();
m.min_manager_version = "0.6.13".into();
m.bots = Some(Revision { commit: Some("b".repeat(40)) });
m.compatibility = Some(Compatibility { schema: 1, platform: "windows-x86_64".into(),
core_commit: "a".repeat(40), module_commits: [("bots".into(), "c".repeat(40))].into(),
source_databases: Default::default(), client_patch_version: "1.5.1".into(), source_versions: vec!["0.2.0".into()] });
assert!(m.validate().is_err());
m.compatibility.as_mut().unwrap().module_commits.insert("bots".into(), "b".repeat(40));
m.validate().unwrap();
m.compatibility.as_mut().unwrap().source_versions.push("0.2.0".into());
assert!(m.validate().is_err());
}
#[test]
fn source_database_contracts_must_cover_the_exact_upgrade_versions() {
let mut m = Manifest::parse(sample("").as_bytes()).unwrap();
m.min_manager_version = "0.6.13".into();
m.compatibility = Some(Compatibility { schema: 1, platform: "windows-x86_64".into(),
core_commit: "a".repeat(40), module_commits: [("squid".into(), "b".repeat(40))].into(),
client_patch_version: "1.5.1".into(), source_versions: vec!["0.2.0".into()],
source_databases: [("0.2.0".into(), SourceDatabase { manifest_sha256: "a".repeat(64), schema_sha256: None })].into() });
m.validate().unwrap();
m.compatibility.as_mut().unwrap().source_databases.get_mut("0.2.0").unwrap().schema_sha256 = Some("bad".into());
assert!(m.validate().is_err());
let c = m.compatibility.as_mut().unwrap();
c.source_databases.get_mut("0.2.0").unwrap().schema_sha256 = None;
c.source_versions = vec!["0.2.1".into()];
assert!(m.validate().is_err());
}
#[test]
fn rejects_traversal_bad_hash_duplicates_and_short_commit() {
let ok = "b".repeat(64);
+139 -21
View File
@@ -35,6 +35,7 @@ pub struct LedgerRow {
/// Storage for the ledger and the ability to run a SQL file; implemented by the real database and by tests.
pub trait Store {
fn load(&self) -> Result<Vec<LedgerRow>>;
fn load_readonly(&self) -> Result<Vec<LedgerRow>> { self.load() }
fn put(&self, row: &LedgerRow) -> Result<()>;
fn run_file(&self, schema: &str, file: &Path) -> Result<()>;
}
@@ -52,7 +53,13 @@ impl Store for Db {
self.query(&format!(
"CREATE TABLE IF NOT EXISTS `{LEDGER_SCHEMA}`.`{LEDGER_TABLE}` (`db` VARCHAR(32) NOT NULL, `id` VARCHAR(190) NOT NULL, `sha256` CHAR(64) NOT NULL, `status` VARCHAR(16) NOT NULL, `applied_at` DATETIME NOT NULL, `error` TEXT NULL, `baseline` TINYINT NOT NULL DEFAULT 0, PRIMARY KEY (`db`,`id`)) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;"
))?;
let out = self.query(&format!("SELECT `db`,`id`,`sha256`,`status`,`baseline`,COALESCE(HEX(`error`),'') FROM `{LEDGER_SCHEMA}`.`{LEDGER_TABLE}` ORDER BY `db`,`id`;"))?;
self.load_readonly()
}
fn load_readonly(&self) -> Result<Vec<LedgerRow>> {
let out = if self.tables(LEDGER_SCHEMA)?.iter().any(|name| name == LEDGER_TABLE) {
self.query(&format!("SELECT `db`,`id`,`sha256`,`status`,`baseline`,COALESCE(HEX(`error`),'') FROM `{LEDGER_SCHEMA}`.`{LEDGER_TABLE}` ORDER BY `db`,`id`;"))?
} else { String::new() };
let mut rows = Vec::new();
// Files the core's own updater (or whoever prepared this database) already recorded count as applied.
for (kind, schema) in db::SCHEMAS {
@@ -147,8 +154,69 @@ fn recorded<'a>(rows: &'a [LedgerRow], m: &Migration) -> Option<&'a LedgerRow> {
rows.iter().rev().find(|r| r.db == m.db && r.id == m.id)
}
/// Migrations that were published with different bytes but have the same effect, so a server that applied either
/// version accepts the other. The Wildcard table repair went out as `c1d8…` (0.261005.0, 0.261006.1) and as `9e4a…`
/// (0.261005.22, 0.261007.24); the packages carry no list of compatible versions, so the Manager knows this pair.
const SAME_EFFECT: &[(&str, &[&str])] = &[(
"manager_repair__20261005_missing_wildcard_tables",
&[
"c1d8dbf2271234283a48a39e4b4aea1106b83b70581f1e3c4aa9fff438e8e4d2",
"9e4a36245c3f83255415c122c01f08ceb3e3b83898d3d427ac4e2fbcf61e9638",
],
)];
fn same_effect(id: &str, a: &str, b: &str) -> bool {
SAME_EFFECT.iter().any(|(known, hashes)| *known == id
&& hashes.iter().any(|h| h.eq_ignore_ascii_case(a)) && hashes.iter().any(|h| h.eq_ignore_ascii_case(b)))
}
fn hash_changed(row: &LedgerRow, m: &Migration) -> bool {
row.status == Status::Applied && row.sha256 != "0".repeat(64) && !row.sha256.eq_ignore_ascii_case(&m.sha256)
&& !m.compatible_sha256.iter().any(|hash| hash.eq_ignore_ascii_case(&row.sha256))
&& !same_effect(&m.id, &row.sha256, &m.sha256)
}
/// Inspect recorded history without creating a ledger or executing migrations.
pub fn preflight(store: &dyn Store, list: &[Migration]) -> Result<()> {
check_history(&store.load_readonly()?, list)
}
pub fn pending_count(store: &dyn Store, list: &[Migration]) -> Result<usize> {
let rows = store.load_readonly()?;
check_history(&rows, list)?;
Ok(list.iter().filter(|m| recorded(&rows, m).is_none_or(|r| r.status != Status::Applied)).count())
}
fn verified_file(m: &Migration, dir: &Path) -> Result<(&'static str, std::path::PathBuf, bool)> {
if !ident_ok(&m.id) { return Err(Error::InvalidManifest(format!("migration id {:?} is not allowed", m.id))); }
let schema = db::schema_of(&m.db)?;
let path = fsx::safe_join(dir, &format!("{}/{}.sql", m.db, m.id))?;
let bytes = std::fs::read(&path).map_err(|_| Error::Invalid(format!("migration file {} is missing", m.id)))?;
let actual = fsx::sha256_bytes(&bytes);
if !actual.eq_ignore_ascii_case(&m.sha256) { return Err(Error::HashMismatch { path: path.display().to_string(), expected: m.sha256.clone(), actual }); }
Ok((schema, path, m.destructive || looks_destructive(&String::from_utf8_lossy(&bytes))))
}
/// Check every migration artifact, including applied history, before replacing server files.
pub fn verify_files(list: &[Migration], dir: &Path) -> Result<()> {
let mut seen = std::collections::BTreeSet::new();
for m in list {
if !seen.insert((&m.db, &m.id)) { return Err(Error::InvalidManifest(format!("duplicate migration {} ({})", m.id, m.db))); }
verified_file(m, dir)?;
}
Ok(())
}
fn check_history(rows: &[LedgerRow], list: &[Migration]) -> Result<()> {
for m in list {
if recorded(rows, m).is_some_and(|r| matches!(r.status, Status::Running | Status::Failed)) {
return Err(Error::Invalid(format!("Database update {} ({}) failed or was interrupted and may be partially applied. Restore its recovery point before retrying.", m.id, m.db)));
}
if recorded(rows, m).is_some_and(|r| hash_changed(r, m)) {
return Err(Error::Invalid(format!("Applied database update {} ({}) has a different checksum. A new migration is required; it was not replayed.", m.id, m.db)));
}
}
Ok(())
}
/// Record migrations as already present without running them (adopting an existing server whose database
@@ -178,14 +246,7 @@ pub struct ApplyReport {
pub fn apply_pending(store: &dyn Store, list: &[Migration], dir: &Path, snapshot: &dyn Fn() -> Result<String>) -> Result<ApplyReport> {
let rows = store.load()?;
// The list order is the release's order of application (released updates, then pending, then modules).
for m in list {
if recorded(&rows, m).is_some_and(|r| matches!(r.status, Status::Running | Status::Failed)) {
return Err(Error::Invalid(format!("Database update {} ({}) failed or was interrupted and may be partially applied. Restore its recovery point before retrying.", m.id, m.db)));
}
if recorded(&rows, m).is_some_and(|r| hash_changed(r, m)) {
return Err(Error::Invalid(format!("Applied database update {} ({}) has a different checksum. A new migration is required; it was not replayed.", m.id, m.db)));
}
}
check_history(&rows, list)?;
let todo: Vec<&Migration> = list.iter().filter(|m| recorded(&rows, m).is_none_or(|r| r.status != Status::Applied)).collect();
tracing::info!(total = list.len(), pending = todo.len(), skipped = list.len() - todo.len(), "database migration plan");
@@ -193,17 +254,8 @@ pub fn apply_pending(store: &dyn Store, list: &[Migration], dir: &Path, snapshot
let mut files = Vec::new();
let mut any_destructive = false;
for m in &todo {
if !ident_ok(&m.id) {
return Err(Error::InvalidManifest(format!("migration id {:?} is not allowed", m.id)));
}
let schema = db::schema_of(&m.db)?;
let path = fsx::safe_join(dir, &format!("{}/{}.sql", m.db, m.id))?;
let bytes = std::fs::read(&path).map_err(|_| Error::Invalid(format!("migration file {} is missing", m.id)))?;
let actual = fsx::sha256_bytes(&bytes);
if !actual.eq_ignore_ascii_case(&m.sha256) {
return Err(Error::HashMismatch { path: path.display().to_string(), expected: m.sha256.clone(), actual });
}
any_destructive |= m.destructive || looks_destructive(&String::from_utf8_lossy(&bytes));
let (schema, path, destructive) = verified_file(m, dir)?;
any_destructive |= destructive;
files.push((*m, schema, path));
}
@@ -240,6 +292,18 @@ mod tests {
use super::*;
use std::cell::RefCell;
#[test]
fn the_two_published_versions_of_the_wildcard_table_repair_are_interchangeable() {
let (old, new) = ("c1d8dbf2271234283a48a39e4b4aea1106b83b70581f1e3c4aa9fff438e8e4d2", "9e4a36245c3f83255415c122c01f08ceb3e3b83898d3d427ac4e2fbcf61e9638");
let id = "manager_repair__20261005_missing_wildcard_tables";
let row = |id: &str, sha: &str| LedgerRow { db: "characters".into(), id: id.into(), sha256: sha.into(), status: Status::Applied, error: None, baseline: false };
let migration = |id: &str, sha: &str| Migration { compatible_sha256: vec![], id: id.into(), db: "characters".into(), sha256: sha.into(), destructive: false };
assert!(!hash_changed(&row(id, old), &migration(id, new)), "applied as c1d8, offered as 9e4a");
assert!(!hash_changed(&row(id, new), &migration(id, old)), "applied as 9e4a, offered as c1d8");
assert!(hash_changed(&row(id, &"a".repeat(64)), &migration(id, new)), "an unknown version is still a change");
assert!(hash_changed(&row("other_migration", old), &migration("other_migration", new)), "only the known pair is exempt");
}
#[derive(Default)]
struct Mem {
rows: RefCell<Vec<LedgerRow>>,
@@ -273,7 +337,7 @@ mod tests {
for (db, id, sql) in files {
std::fs::create_dir_all(d.path().join(db)).unwrap();
std::fs::write(d.path().join(db).join(format!("{id}.sql")), sql).unwrap();
list.push(Migration { id: id.to_string(), db: db.to_string(), sha256: fsx::sha256_bytes(sql.as_bytes()), destructive: false });
list.push(Migration { compatible_sha256: vec![], id: id.to_string(), db: db.to_string(), sha256: fsx::sha256_bytes(sql.as_bytes()), destructive: false });
}
(d, list)
}
@@ -304,6 +368,60 @@ mod tests {
assert!(store.ran.borrow().is_empty());
}
#[test]
fn staged_files_reject_missing_corrupt_duplicate_and_invalid_migrations() {
let (dir, list) = setup(&[("characters", "repair", "SELECT 1;\n")]);
verify_files(&list, dir.path()).unwrap();
let mut bad = list.clone();
bad[0].id = "../outside".into();
assert!(verify_files(&bad, dir.path()).is_err());
bad = list.clone();
bad.push(list[0].clone());
assert!(verify_files(&bad, dir.path()).is_err());
std::fs::write(dir.path().join("characters/repair.sql"), b"SELECT 2;\n").unwrap();
assert!(verify_files(&list, dir.path()).is_err());
std::fs::remove_file(dir.path().join("characters/repair.sql")).unwrap();
assert!(verify_files(&list, dir.path()).is_err());
}
#[test]
fn preflight_uses_readonly_history_and_rejects_conflicts_without_writes() {
struct ReadOnly<'a>(&'a Mem);
impl Store for ReadOnly<'_> {
fn load(&self) -> Result<Vec<LedgerRow>> { panic!("preflight must use readonly access") }
fn load_readonly(&self) -> Result<Vec<LedgerRow>> { self.0.load() }
fn put(&self, _: &LedgerRow) -> Result<()> { panic!("preflight must not rewrite history") }
fn run_file(&self, _: &str, _: &Path) -> Result<()> { panic!("preflight must not run SQL") }
}
let (_d, list) = setup(&[("characters", "repair", "SELECT 1;\n")]);
for state in [Status::Applied, Status::Running, Status::Failed] {
let store = Mem::default();
store.rows.borrow_mut().push(LedgerRow { db: "characters".into(), id: "repair".into(), sha256: "a".repeat(64), status: state, error: None, baseline: false });
assert!(preflight(&ReadOnly(&store), &list).is_err());
assert_eq!(store.rows.borrow()[0].sha256, "a".repeat(64));
assert_eq!(store.rows.borrow()[0].status, state);
}
}
#[test]
fn published_compatibility_preserves_history_and_never_replays_sql() {
let (d, mut list) = setup(&[("characters", "repair", "SELECT 1;\n")]);
let store = Mem::default();
let old = fsx::sha256_bytes(b"SELECT 1;\r\n");
store.rows.borrow_mut().push(LedgerRow { db: "characters".into(), id: "repair".into(), sha256: old.clone(), status: Status::Applied, error: None, baseline: false });
assert!(apply_pending(&store, &list, d.path(), &no_snapshot).is_err());
list[0].compatible_sha256.push(old.clone());
assert_eq!(status(&store, &list).unwrap()[0].status, Status::Applied);
assert!(apply_pending(&store, &list, d.path(), &no_snapshot).unwrap().applied.is_empty());
assert!(store.ran.borrow().is_empty());
assert_eq!(store.rows.borrow()[0].sha256, old);
store.rows.borrow_mut()[0].status = Status::Running;
assert!(apply_pending(&store, &list, d.path(), &no_snapshot).is_err());
store.rows.borrow_mut()[0].status = Status::Failed;
assert!(apply_pending(&store, &list, d.path(), &no_snapshot).is_err());
assert!(store.ran.borrow().is_empty());
}
#[test]
fn applies_in_order_once_and_records_the_ledger() {
let (d, list) = setup(&[("world", "2026_09_01_00_a", "CREATE TABLE t (id INT);"), ("world", "2026_09_02_00_b", "ALTER TABLE t ADD c INT;")]);
+114 -7
View File
@@ -87,6 +87,7 @@ fn truthy(v: &str) -> bool {
pub struct ModuleView {
pub id: String,
pub name: String,
pub version: Option<String>,
pub description: BTreeMap<String, String>,
pub repo: String,
/// The module's configuration is present on this server (otherwise it is not part of this server build).
@@ -137,7 +138,11 @@ fn list_in(cat: &[Entry], root: &Path) -> Vec<ModuleView> {
!e.switchable || read(&conf).or_else(|| read(&dist)).and_then(|c| c.get(&e.enable_key).map(truthy)).unwrap_or(e.default_on)
};
let blocked = wildcard && matches!(e.id.as_str(), "companions" | "playerbots");
let version = if e.id == "playerbots" { crate::squid::release(root).map(|release| {
[release.tag, release.commit.map(|commit| commit.chars().take(8).collect())].into_iter().flatten().collect::<Vec<_>>().join(" · ")
}) } else { None };
ModuleView {
version,
compatibility: if blocked { "unsupported" } else if wildcard && e.id != "client-compat" { "experimental" } else { "compatible" }.into(),
id: e.id,
name: e.name,
@@ -198,6 +203,28 @@ pub fn set_enabled(root: &Path, meta: &Path, id: &str, on: bool) -> Result<()> {
Some(lock)
} else { None };
if on { crate::realms::guard_module(root, id)?; }
if id == "custom-races" {
if let Ok(meta_content) = fs::read_to_string(meta.join("install.json")) {
if let Ok(install_meta) = serde_json::from_str::<crate::registry::InstallMeta>(&meta_content) {
if let Some(cp) = install_meta.client_path {
let client_path = PathBuf::from(cp);
if client_path.is_dir() {
crate::custom_races::set_client_patch_enabled(&client_path, on)?;
}
}
}
}
if !on {
let _ = crate::custom_races::sync_bot_races_config(root, false);
} else {
let allow = crate::custom_races::is_bot_custom_races_allowed(root).unwrap_or_else(|| {
read(&dir(root).join("coa_custom_races.conf"))
.and_then(|c| c.get("CoACustomRaces.BotsEnable").map(truthy))
.unwrap_or(false)
});
let _ = crate::custom_races::sync_bot_races_config(root, allow);
}
}
set_enabled_in(&catalog(), root, meta, id, on)
}
@@ -243,13 +270,14 @@ fn set_enabled_in(cat: &[Entry], root: &Path, meta: &Path, id: &str, on: bool) -
Ok(())
}
#[derive(Debug, Serialize, PartialEq, Eq)]
#[derive(Debug, Serialize, PartialEq)]
pub struct Setting {
pub key: String,
pub value: String,
pub default: Option<String>,
/// The documentation the module ships above the setting.
pub doc: String,
pub field: Option<crate::squid::Field>,
}
/// Every active setting of the module with its current value, its documented default and its description.
@@ -263,6 +291,7 @@ fn settings_in(cat: &[Entry], root: &Path, id: &str) -> Result<Vec<Setting>> {
let conf = dir(root).join(&name);
let dist = read(&dir(root).join(format!("{name}.dist")));
let active = read(&conf).or_else(|| dist.clone()).ok_or_else(|| Error::Invalid("This module is not part of this server.".into()))?;
let fields = if id == "playerbots" { crate::squid::fields(root)? } else { Default::default() };
let mut effective = active.clone();
if let Some(defaults) = &dist {
for (key, value) in defaults.entries() {
@@ -271,13 +300,27 @@ fn settings_in(cat: &[Entry], root: &Path, id: &str) -> Result<Vec<Setting>> {
}
}
}
let bot_custom_races_allowed = if id == "custom-races" {
crate::custom_races::is_bot_custom_races_allowed(root)
} else {
None
};
Ok(effective
.entries()
.map(|(k, v)| Setting {
key: k.to_string(),
value: v.to_string(),
default: dist.as_ref().and_then(|d| d.get(k)).map(str::to_string),
doc: dist.as_ref().map(|d| d.doc_for(k)).filter(|d| !d.is_empty()).unwrap_or_else(|| active.doc_for(k)).join(" "),
.map(|(k, v)| {
let mut val = fields.get(k).and_then(|field| field.default_if_missing.as_ref()).filter(|_| active.get(k).is_none()).and_then(crate::squid::scalar).unwrap_or_else(|| v.to_string());
if k == "CoACustomRaces.BotsEnable" {
if let Some(allowed) = bot_custom_races_allowed {
val = if allowed { "1".into() } else { "0".into() };
}
}
Setting {
key: k.to_string(),
value: val,
default: fields.get(k).and_then(|field| crate::squid::scalar(&field.default)).or_else(|| dist.as_ref().and_then(|d| d.get(k)).map(str::to_string)),
field: fields.get(k).cloned(),
doc: dist.as_ref().map(|d| d.doc_for(k)).filter(|d| !d.is_empty()).unwrap_or_else(|| active.doc_for(k)).join(" "),
}
})
.collect())
}
@@ -293,9 +336,11 @@ fn save_settings_in(cat: &[Entry], root: &Path, meta: &Path, id: &str, changes:
let conf = active_file(root, &e)?;
let mut file = ConfFile::parse_bytes(&fs::read(&conf)?)?;
let dist = read(&dir(root).join(format!("{}.dist", conf_name(root, &e))));
let fields = if id == "playerbots" { crate::squid::fields(root)? } else { Default::default() };
let mut changed = Vec::new();
for (key, value) in changes {
let value = value.trim();
if let Some(field) = fields.get(key) { crate::squid::validate(field, value)?; }
if e.switchable && key == &e.enable_key {
return Err(Error::Invalid("Use the module switch to turn this module on or off.".into()));
}
@@ -331,6 +376,12 @@ fn save_settings_in(cat: &[Entry], root: &Path, meta: &Path, id: &str, changes:
changed.push((key.clone(), value.to_string()));
}
}
if id == "custom-races" {
if let Some(bots_enable) = changes.get("CoACustomRaces.BotsEnable") {
let allow = truthy(bots_enable);
crate::custom_races::sync_bot_races_config(root, allow)?;
}
}
if changed.is_empty() {
return Ok(Vec::new());
}
@@ -374,6 +425,27 @@ mod tests {
(root, meta)
}
#[test]
fn squid_missing_keys_use_code_defaults_and_saves_enforce_json_ranges() {
let d = tempfile::tempdir().unwrap();
let root = d.path();
fs::create_dir_all(dir(root)).unwrap();
fs::write(dir(root).join("playerbots.conf"), "AiPlayerbot.Enabled = 0\n").unwrap();
fs::write(dir(root).join("playerbots.conf.dist"), "AiPlayerbot.Enabled = 0\nAiPlayerbot.MinRandomBots = 500\n").unwrap();
fs::write(dir(root).join("playerbots.conf.settings.json"), r#"{"format":1,"groups":{"population":"Population"},"settings":[{"key":"AiPlayerbot.MinRandomBots","type":"int","group":"population","title":"Minimum bots","description":"Lower bound","default":500,"default_if_missing":50,"min":0,"max":5000}]}"#).unwrap();
let cat = catalog();
let options = settings_in(&cat, root, "playerbots").unwrap();
let option = options.iter().find(|setting| setting.key == "AiPlayerbot.MinRandomBots").unwrap();
assert_eq!(option.value, "50");
assert_eq!(option.default.as_deref(), Some("500"));
assert_eq!(option.field.as_ref().unwrap().group_title.as_deref(), Some("Population"));
let before = fs::read(dir(root).join("playerbots.conf")).unwrap();
assert!(save_settings_in(&cat, root, root, "playerbots", &BTreeMap::from([("AiPlayerbot.MinRandomBots".into(), "5001".into())])).is_err());
assert_eq!(fs::read(dir(root).join("playerbots.conf")).unwrap(), before);
save_settings_in(&cat, root, root, "playerbots", &BTreeMap::from([("AiPlayerbot.MinRandomBots".into(), "42".into())])).unwrap();
assert_eq!(settings_in(&cat, root, "playerbots").unwrap().iter().find(|setting| setting.key == "AiPlayerbot.MinRandomBots").unwrap().value, "42");
}
#[test]
fn bot_systems_are_mutually_exclusive_in_both_directions_and_manual_configs() {
let d = tempfile::tempdir().unwrap();
@@ -456,7 +528,7 @@ mod tests {
let (root, meta) = server(d.path());
let s = settings_in(&test_catalog(), &root, "war-games").unwrap();
assert_eq!(s.len(), 2);
assert_eq!(s[1], Setting { key: "WarGames.ChallengeSeconds".into(), value: "60".into(), default: Some("60".into()), doc: "How long a challenge stays open.".into() });
assert_eq!(s[1], Setting { key: "WarGames.ChallengeSeconds".into(), value: "60".into(), default: Some("60".into()), doc: "How long a challenge stays open.".into(), field: None });
assert_eq!(s[0].doc, "Turns War Games on. Second line.");
let ok = BTreeMap::from([("WarGames.ChallengeSeconds".to_string(), "90".to_string())]);
@@ -629,4 +701,39 @@ mod tests {
assert!(fs::read_to_string(dir(&root).join("war_games.conf")).unwrap().contains("WarGames.Enable = 0"));
assert!(!list_in(&cat, &root).into_iter().find(|m| m.id == "war-games").unwrap().enabled);
}
#[test]
fn custom_races_bot_settings_synchronize_playerbots_conf() {
let d = tempfile::tempdir().unwrap();
let (root, meta) = server(d.path());
let cat = catalog();
fs::write(dir(&root).join("coa_custom_races.conf.dist"), "CoACustomRaces.Enable = 1\nCoACustomRaces.BotsEnable = 0\n").unwrap();
fs::write(dir(&root).join("coa_custom_races.conf"), "CoACustomRaces.Enable = 1\nCoACustomRaces.BotsEnable = 0\n").unwrap();
fs::write(dir(&root).join("playerbots.conf"), "AiPlayerbot.Enabled = 1\n").unwrap();
// 1. Initially CoACustomRaces.BotsEnable is 0
let s = settings_in(&cat, &root, "custom-races").unwrap();
assert_eq!(s.iter().find(|s| s.key == "CoACustomRaces.BotsEnable").unwrap().value, "0");
// 2. Enable bots for custom races: should write experimental exclusions to playerbots.conf
let change_on = BTreeMap::from([("CoACustomRaces.BotsEnable".into(), "1".into())]);
assert_eq!(save_settings_in(&cat, &root, &meta, "custom-races", &change_on).unwrap(), ["CoACustomRaces.BotsEnable"]);
let pb = fs::read_to_string(dir(&root).join("playerbots.conf")).unwrap();
assert!(pb.contains("AiPlayerbot.ExcludedBotRaces"));
assert!(pb.contains(crate::custom_races::EXCLUDED_BOT_RACES_EXPERIMENTAL));
// Settings view now sees "1"
let s = settings_in(&cat, &root, "custom-races").unwrap();
assert_eq!(s.iter().find(|s| s.key == "CoACustomRaces.BotsEnable").unwrap().value, "1");
// 3. Disable bots for custom races: should write recommended exclusions to playerbots.conf
let change_off = BTreeMap::from([("CoACustomRaces.BotsEnable".into(), "0".into())]);
assert_eq!(save_settings_in(&cat, &root, &meta, "custom-races", &change_off).unwrap(), ["CoACustomRaces.BotsEnable"]);
let pb = fs::read_to_string(dir(&root).join("playerbots.conf")).unwrap();
assert!(pb.contains(crate::custom_races::EXCLUDED_BOT_RACES_RECOMMENDED));
// Settings view now sees "0"
let s = settings_in(&cat, &root, "custom-races").unwrap();
assert_eq!(s.iter().find(|s| s.key == "CoACustomRaces.BotsEnable").unwrap().value, "0");
}
}
+478
View File
@@ -0,0 +1,478 @@
use std::{collections::{BTreeMap, BTreeSet}, fs, path::{Path, PathBuf}};
use std::io::{BufReader, BufWriter, Write};
use serde::{Deserialize, Serialize};
use crate::{fsx, Error, Result};
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub(crate) struct Snapshot {
pub path: String,
pub files: BTreeMap<String, String>,
pub directories: BTreeSet<String>,
pub server_sha256: String,
#[serde(default)]
pub bytes: u64,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub archive_sha256: Option<String>,
#[serde(default)]
pub expanded_bytes: u64,
}
fn reject_link(metadata: &fs::Metadata) -> Result<()> {
let linked = metadata.file_type().is_symlink();
#[cfg(windows)] let linked = { use std::os::windows::fs::MetadataExt; linked || metadata.file_attributes() & 0x400 != 0 };
if linked { return Err(Error::Invalid("Recovery copies cannot follow symbolic links or junctions.".into())); }
Ok(())
}
fn directories(root: &Path) -> Result<BTreeSet<String>> {
let canonical = fsx::canonicalize_lenient(root)?;
let root = canonical.as_path();
let mut result = BTreeSet::new();
let mut pending = vec![root.to_path_buf()];
while let Some(directory) = pending.pop() {
for entry in fs::read_dir(directory)? {
let entry = entry?;
reject_link(&fs::symlink_metadata(entry.path())?)?;
let path = fsx::ensure_within(root, &entry.path())?;
if entry.file_type()?.is_dir() {
let relative = path.strip_prefix(root).map_err(|e| Error::Invalid(e.to_string()))?.to_string_lossy().replace('\\', "/");
result.insert(relative);
pending.push(path);
}
}
}
Ok(result)
}
fn copy_snapshot(point: &Path, snapshot: &Snapshot, target: &Path) -> Result<()> {
if snapshot.archive_sha256.is_some() {
verify(point, snapshot)?;
if target.exists() { return Err(Error::Invalid("The recovery destination already exists.".into())); }
let parent = target.parent().ok_or_else(|| Error::Invalid("Invalid recovery destination.".into()))?;
fs::create_dir_all(parent)?;
fsx::require_space(parent, snapshot.expanded_bytes)?;
fs::create_dir(target)?;
let input = fsx::ensure_within(point, &fsx::safe_join(point, &snapshot.path)?)?;
let decoder = zstd::Decoder::new(BufReader::new(fs::File::open(input)?))?;
let mut archive = tar::Archive::new(decoder);
let mut seen = BTreeSet::new();
let mut expanded = 0u64;
for entry in archive.entries()? {
let mut entry = entry?;
let name = entry.path()?.to_string_lossy().trim_end_matches('/').to_string();
if !seen.insert(name.clone()) { return Err(Error::Invalid("Duplicate entry in MySQL recovery archive.".into())); }
let output = fsx::ensure_within(target, &fsx::safe_join(target, &name)?)?;
if entry.header().entry_type().is_dir() && snapshot.directories.contains(&name) {
fs::create_dir_all(output)?;
} else if entry.header().entry_type().is_file() && snapshot.files.contains_key(&name) {
expanded = expanded.checked_add(entry.size()).filter(|bytes| *bytes <= snapshot.expanded_bytes)
.ok_or_else(|| Error::Invalid("MySQL recovery archive exceeds its declared size.".into()))?;
fs::create_dir_all(output.parent().unwrap())?;
let mut file = fs::OpenOptions::new().write(true).create_new(true).open(output)?;
if std::io::copy(&mut entry, &mut file)? != entry.size() { return Err(Error::Invalid("Truncated MySQL recovery file.".into())); }
file.flush()?;
} else { return Err(Error::Invalid("Unexpected entry in MySQL recovery archive.".into())); }
}
if expanded != snapshot.expanded_bytes || inventory(target)? != snapshot.files {
return Err(Error::Invalid("MySQL recovery files failed verification.".into()));
}
} else { copy_verified(&point.join(&snapshot.path), target, &snapshot.files)?; }
for directory in &snapshot.directories {
fs::create_dir_all(fsx::ensure_within(target, &fsx::safe_join(target, directory)?)?)?;
}
if directories(target)? != snapshot.directories { return Err(Error::Invalid("The recovery directory inventory differs.".into())); }
Ok(())
}
fn compress(source: &Path, point: &Path, snapshot: &mut Snapshot) -> Result<()> {
snapshot.path = "mysql-data.tar.zst".into();
let path = fsx::safe_join(point, &snapshot.path)?;
fs::create_dir_all(point)?;
fsx::require_space(point, snapshot.expanded_bytes)?;
let file = fs::OpenOptions::new().write(true).create_new(true).open(&path)?;
let encoder = zstd::Encoder::new(BufWriter::new(file), 3)?;
let mut archive = tar::Builder::new(encoder);
for directory in &snapshot.directories {
archive.append_dir(directory, fsx::ensure_within(source, &fsx::safe_join(source, directory)?)?)?;
}
for name in snapshot.files.keys() {
let input = fsx::ensure_within(source, &fsx::safe_join(source, name)?)?;
archive.append_file(name, &mut fs::File::open(input)?)?;
}
archive.into_inner()?.finish()?.flush()?;
snapshot.archive_sha256 = Some(fsx::sha256_file(&path)?);
snapshot.bytes = fs::metadata(path)?.len();
Ok(())
}
pub(crate) fn inventory(root: &Path) -> Result<BTreeMap<String, String>> {
let canonical = fsx::canonicalize_lenient(root)?;
let root = canonical.as_path();
let mut files = BTreeMap::new();
let mut directories = vec![root.to_path_buf()];
while let Some(directory) = directories.pop() {
for entry in fs::read_dir(directory)? {
let entry = entry?;
let metadata = fs::symlink_metadata(entry.path())?;
let path = fsx::ensure_within(root, &entry.path())?;
reject_link(&metadata)?;
if metadata.is_dir() { directories.push(path); continue; }
if !metadata.is_file() { return Err(Error::Invalid("Unsupported database snapshot file.".into())); }
let relative = path.strip_prefix(root).map_err(|e| Error::Invalid(e.to_string()))?.to_string_lossy().replace('\\', "/");
fsx::safe_join(root, &relative)?;
if relative.ends_with(".isl") { return Err(Error::Invalid("External MySQL tablespaces require a separate recovery method.".into())); }
files.insert(relative, fsx::sha256_file(&path)?);
}
}
Ok(files)
}
pub(crate) fn copy_verified(source: &Path, target: &Path, files: &BTreeMap<String, String>) -> Result<()> {
if target.exists() { return Err(Error::Invalid("Database snapshot destination already exists.".into())); }
let bytes = files.keys().try_fold(0u64, |total, name| -> Result<u64> {
let path = fsx::ensure_within(source, &fsx::safe_join(source, name)?)?;
total.checked_add(fs::metadata(path)?.len()).ok_or_else(|| Error::Invalid("Snapshot size overflow.".into()))
})?;
let parent = target.parent().ok_or_else(|| Error::Invalid("Invalid snapshot destination.".into()))?;
fs::create_dir_all(parent)?;
fsx::require_space(parent, bytes)?;
fs::create_dir(target)?;
for (relative, expected) in files {
let source_file = fsx::ensure_within(source, &fsx::safe_join(source, relative)?)?;
let target_file = fsx::ensure_within(target, &fsx::safe_join(target, relative)?)?;
fs::create_dir_all(target_file.parent().unwrap())?;
fs::copy(&source_file, &target_file)?;
if fsx::sha256_file(&target_file)? != *expected { return Err(Error::Invalid(format!("Database snapshot file {relative} failed verification."))); }
}
if inventory(target)? != *files { return Err(Error::Invalid("Database snapshot inventory differs.".into())); }
Ok(())
}
pub(crate) fn stop(root: &Path) -> Result<()> {
let observed = crate::process::observe(root, &crate::layout::read_ports(root));
if [observed.mysql.state, observed.auth.state, observed.world.state].iter().all(|state| *state == crate::process::ServiceState::Stopped)
&& !crate::multiworld::is_running(root) { return Ok(()); }
let outcome = crate::driver::run(root, crate::driver::Verb::StopAll)?;
let status = crate::process::observe(root, &crate::layout::read_ports(root));
if !outcome.ok || [status.mysql.state, status.auth.state, status.world.state].iter().any(|state| *state != crate::process::ServiceState::Stopped)
|| crate::multiworld::is_running(root) {
return Err(Error::Invalid("The complete server must be stopped before copying or restoring MySQL.".into()));
}
Ok(())
}
pub(crate) fn stop_previous_rehearsals(meta: &Path) -> Result<()> {
let location = meta.join("rehearsals");
if !location.exists() { return Ok(()); }
for entry in fs::read_dir(&location)? {
let entry = entry?;
let name = entry.file_name().to_string_lossy().into_owned();
if name.len() != 32 || !name.bytes().all(|byte| byte.is_ascii_hexdigit()) { continue; }
let fixture = fsx::ensure_within(&location, &entry.path().join("server"))?;
let metadata = crate::registry::metadata_dir_for(&fixture)?;
if !metadata.join("install.json").is_file() { continue; }
let (_, installed) = crate::registry::MetaDir::open(&metadata)?;
if fsx::canonicalize_lenient(Path::new(&installed.server_path))? != fsx::canonicalize_lenient(&fixture)? {
return Err(Error::Invalid("The interrupted rehearsal metadata does not match its private server.".into()));
}
stop(&fixture)?;
}
Ok(())
}
pub(crate) fn capture(root: &Path, partial: &Path) -> Result<Snapshot> {
if crate::docker::is_docker(root) || !cfg!(windows) { return Err(Error::Invalid("Cold MySQL snapshots require a Windows repack.".into())); }
crate::backup::with_database(root, |db| {
if db.query("SELECT COUNT(*) FROM performance_schema.replication_connection_configuration;")?.trim() != "0" {
return Err(Error::Invalid("A replicated MySQL instance requires a separate isolated recovery method.".into()));
}
let data = fsx::ensure_within(root, &root.join("mysql/data"))?;
for path in db.query("SELECT PATH FROM information_schema.INNODB_DATAFILES;")?.lines() {
fsx::ensure_within(&data, &data.join(path))?;
}
Ok(())
})?;
stop(root)?;
let data = fsx::ensure_within(root, &root.join("mysql/data"))?;
if !data.join("mysql").is_dir() || !data.join("ibdata1").is_file() {
return Err(Error::Invalid("The bundled MySQL data directory is incomplete.".into()));
}
let files = inventory(&data)?;
let bytes = files.keys().try_fold(0u64, |total, file| -> Result<u64> {
total.checked_add(fs::metadata(fsx::safe_join(&data, file)?)?.len()).ok_or_else(|| Error::Invalid("Snapshot size overflow.".into()))
})?;
let mut snapshot = Snapshot { path: "mysql-data".into(), files, directories:directories(&data)?, server_sha256: fsx::sha256_file(&root.join("mysql/bin/mysqld.exe"))?, bytes, expanded_bytes:bytes, archive_sha256:None };
compress(&data, partial, &mut snapshot)?;
verify(partial, &snapshot)?;
Ok(snapshot)
}
pub(crate) fn verify(point: &Path, snapshot: &Snapshot) -> Result<()> {
if snapshot.files.is_empty() || snapshot.server_sha256.len() != 64 {
return Err(Error::Invalid("Invalid cold MySQL recovery inventory.".into()));
}
let data = fsx::ensure_within(point, &fsx::safe_join(point, &snapshot.path)?)?;
if let Some(hash) = &snapshot.archive_sha256 {
if snapshot.path != "mysql-data.tar.zst" || snapshot.expanded_bytes == 0 || fsx::sha256_file(&data)? != *hash {
return Err(Error::Invalid("The compressed MySQL recovery copy is damaged.".into()));
}
for name in snapshot.files.keys().chain(snapshot.directories.iter()) { fsx::safe_join(point, name)?; }
return Ok(());
}
if snapshot.path != "mysql-data" { return Err(Error::Invalid("Unsupported MySQL recovery format.".into())); }
if inventory(&data)? != snapshot.files { return Err(Error::Invalid("The cold MySQL recovery copy is damaged or incomplete.".into())); }
if directories(&data)? != snapshot.directories { return Err(Error::Invalid("The cold MySQL recovery directories are incomplete.".into())); }
Ok(())
}
pub(crate) fn rehearsal_copy(root: &Path, meta: &Path, point: &Path, snapshot: &Snapshot) -> Result<PathBuf> {
verify(point, snapshot)?;
let destination = meta.join("rehearsals").join(uuid::Uuid::new_v4().simple().to_string()).join("server");
let mut files = BTreeMap::new();
let mut directories = vec![root.to_path_buf()];
while let Some(directory) = directories.pop() {
for entry in fs::read_dir(directory)? {
let entry = entry?;
let raw = entry.path();
let relative = raw.strip_prefix(root).map_err(|e| Error::Invalid(e.to_string()))?.to_string_lossy().replace('\\', "/");
let lower = relative.to_ascii_lowercase();
let first = lower.split('/').next().unwrap();
if entry.file_type()?.is_dir() && !relative.contains('/')
&& !["core", "data", "scripts", "settings", "runtime", "mysql", ".realms", "bugreport", "extras", "licenses"].contains(&first) { continue; }
if lower == "mysql/data" || lower.starts_with("mysql/data-")
|| lower.split('/').any(|part| part == ".state")
|| lower == "bugreport/reports" || lower == "core/logs" || lower == "mysql/logs" { continue; }
let metadata = fs::symlink_metadata(&raw)?;
reject_link(&metadata)?;
let path = fsx::ensure_within(root, &raw)?;
if metadata.is_dir() { directories.push(path); }
else if metadata.is_file() { files.insert(relative, fsx::sha256_file(&path)?); }
else { return Err(Error::Invalid("Unsupported rehearsal file.".into())); }
}
}
copy_verified(root, &destination, &files)?;
copy_snapshot(point, snapshot, &destination.join("mysql/data"))?;
let (_, mut installed) = crate::registry::MetaDir::open(meta)?;
installed.id = uuid::Uuid::new_v4().to_string();
installed.server_path = destination.to_string_lossy().into_owned();
installed.client_path = None;
crate::registry::MetaDir::create(&destination, &installed)?;
Ok(destination)
}
pub(crate) fn isolate_connections(root: &Path) -> Result<()> {
for relative in ["Settings/worldserver.conf.template", "Settings/authserver.conf.template", "Core/configs/worldserver.conf", "Core/configs/authserver.conf"] {
let path = fsx::ensure_within(root, &root.join(relative))?;
if !path.is_file() {
if relative.ends_with(".template") { return Err(Error::Invalid("The private update copy lacks connection templates.".into())); }
continue;
}
let mut config = crate::config::parser::ConfFile::parse_bytes(&fs::read(&path)?)?;
for key in ["LoginDatabaseInfo", "WorldDatabaseInfo", "CharacterDatabaseInfo"] {
if relative.contains("worldserver") || key == "LoginDatabaseInfo" {
config.set(key, &format!("\"@{key}@\""), &[]);
}
}
config.set("BindIP", "\"127.0.0.1\"", &[]);
if relative.contains("worldserver") {
config.set("Ra.IP", "\"127.0.0.1\"", &[]);
config.set("DataDir", "\"@DATA@\"", &[]);
}
fsx::atomic_write(&path, config.to_text().as_bytes())?;
}
Ok(())
}
pub(crate) fn unchanged(root: &Path, snapshot: &Snapshot) -> Result<()> {
let data = fsx::ensure_within(root, &root.join("mysql/data"))?;
if inventory(&data)? != snapshot.files || directories(&data)? != snapshot.directories {
return Err(Error::Invalid("The installed database changed during the private rehearsal. Retry after stopping other database access.".into()));
}
Ok(())
}
pub(crate) fn validate_connections(templates: &Path, installation: &Path) -> Result<()> {
let port = crate::layout::read_ports(installation).mysql.to_string();
let (_, password) = crate::db::credentials(installation)?;
let realm = crate::realms::state(installation)?.active;
for relative in ["Settings/worldserver.conf.template", "Settings/authserver.conf.template"] {
let path = fsx::ensure_within(templates, &templates.join(relative))?;
let config = crate::config::parser::ConfFile::parse_bytes(&fs::read(path)?)?;
for (key, kind) in [("LoginDatabaseInfo", "auth"), ("WorldDatabaseInfo", "world"), ("CharacterDatabaseInfo", "characters")] {
if relative.contains("authserver") && kind != "auth" { continue; }
let value = config.get(key).ok_or_else(|| Error::Invalid(format!("The update cannot isolate the missing {key} connection.")))?.trim().trim_matches('"');
if value == format!("@{key}@") { continue; }
let fields: Vec<_> = value.split(';').collect();
if fields.len() != 5 || !matches!(fields[0], "127.0.0.1" | "localhost") || fields[1] != port || fields[2] != "acore" || fields[3] != password || fields[4] != realm.schema(kind)? {
return Err(Error::Invalid(format!("The {key} connection does not use this repack's bundled database. A private update cannot safely qualify an external database.")));
}
}
}
Ok(())
}
// Keep the replaced data directory. If interrupted between renames, a retry can install a new verified copy.
pub(crate) fn swap(root: &Path, meta: &Path, point: &Path, snapshot: &Snapshot, fail_after_move: bool) -> Result<PathBuf> {
verify(point, snapshot)?;
if fsx::sha256_file(&root.join("mysql/bin/mysqld.exe"))? != snapshot.server_sha256 {
return Err(Error::Invalid("The MySQL executable differs from the recovery point.".into()));
}
let mysql = fsx::ensure_within(root, &root.join("mysql"))?;
let token = uuid::Uuid::new_v4().simple().to_string();
let staging = fsx::ensure_within(&mysql, &mysql.join(format!("data-restore-{token}")))?;
let previous = fsx::ensure_within(&mysql, &mysql.join(format!("data-before-restore-{token}")))?;
let live = fsx::ensure_within(&mysql, &mysql.join("data"))?;
copy_snapshot(point, snapshot, &staging)?;
let journal = meta.join("diagnostics").join(format!("database-restore-{token}.json"));
fsx::atomic_write_json(&journal, &serde_json::json!({"schema":1,"state":"prepared","previous":previous,"staging":staging}))?;
if live.exists() { fs::rename(&live, &previous)?; }
if fail_after_move { return Err(Error::Invalid("Simulated interruption after saving the previous MySQL directory.".into())); }
fs::rename(&staging, &live)?;
fsx::atomic_write_json(&journal, &serde_json::json!({"schema":1,"state":"restored","previous":previous}))?;
Ok(previous)
}
#[cfg(test)]
mod tests {
use super::*;
#[cfg(windows)]
#[test]
#[ignore = "requires COA_MYSQL_TEST_BIN pointing to the bundled MySQL tools"]
fn real_mysql_restores_objects_users_rows_and_missing_defaults() {
use std::process::{Child, Command, Stdio};
use std::os::windows::process::CommandExt;
struct Server(Child);
impl Drop for Server { fn drop(&mut self) { let _ = self.0.kill(); let _ = self.0.wait(); } }
let bin = PathBuf::from(std::env::var("COA_MYSQL_TEST_BIN").unwrap());
let temp = tempfile::tempdir().unwrap();
let root = temp.path().join("server");
let meta = temp.path().join("metadata");
let point = temp.path().join("point");
copy_verified(&bin, &root.join("mysql/bin"), &inventory(&bin).unwrap()).unwrap();
let data = root.join("mysql/data");
let executable = root.join("mysql/bin/mysqld.exe");
let initialized = Command::new(&executable).args(["--no-defaults", "--initialize-insecure"])
.arg(format!("--datadir={}", data.display())).creation_flags(0x0800_0000).output().unwrap();
assert!(initialized.status.success(), "{}", String::from_utf8_lossy(&initialized.stderr));
let port = crate::install::free_port().unwrap();
fsx::atomic_write_json(&root.join("Settings/repack.json"), &serde_json::json!({"mysqlPort":port})).unwrap();
fsx::atomic_write_json(&root.join("Settings/database.json"), &serde_json::json!({"rootPassword":"","appPassword":""})).unwrap();
let db = crate::db::Db::from_repack(&root, crate::db::Account::Admin).unwrap();
let start = || {
let server = Server(Command::new(&executable).args(["--no-defaults", "--bind-address=127.0.0.1", "--mysqlx=0", "--skip-log-bin"])
.arg(format!("--datadir={}", data.display())).arg(format!("--port={port}"))
.arg(format!("--log-error={}", root.join("mysql-test.log").display()))
.stdout(Stdio::null()).stderr(Stdio::null()).creation_flags(0x0800_0000).spawn().unwrap());
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(60);
while !db.ping() { assert!(std::time::Instant::now() < deadline, "{}", fs::read_to_string(root.join("mysql-test.log")).unwrap_or_default()); std::thread::sleep(std::time::Duration::from_millis(200)); }
server
};
let mut server = start();
db.query("CREATE DATABASE acore_characters; CREATE DATABASE acore_world; CREATE DATABASE acore_auth; CREATE TABLE acore_characters.probe(id INT PRIMARY KEY, note VARCHAR(40)); CREATE TABLE acore_world.probe(id INT NOT NULL DEFAULT 0); INSERT INTO acore_world.probe VALUES(43); CREATE TABLE acore_auth.probe(id INT); INSERT INTO acore_auth.probe VALUES(44); CREATE USER 'fixture_user'@'localhost' IDENTIFIED BY 'fixture'; CREATE TRIGGER acore_characters.probe_insert BEFORE INSERT ON acore_characters.probe FOR EACH ROW SET NEW.note='triggered'; INSERT INTO acore_characters.probe VALUES(42,'original'); CREATE VIEW acore_characters.probe_view AS SELECT c.id,w.id AS world_id FROM acore_characters.probe c CROSS JOIN acore_world.probe w; CREATE PROCEDURE acore_characters.probe_proc() SELECT id FROM acore_characters.probe; CREATE FUNCTION acore_characters.probe_func() RETURNS INT DETERMINISTIC RETURN 73;").unwrap();
assert_eq!(db.recovery_objects("acore_characters").unwrap().len(), 4);
crate::schema_check::capture(&db, &root).unwrap();
let hash = fsx::sha256_file(&root.join(crate::schema_check::CONTRACT)).unwrap();
db.query("ALTER TABLE acore_world.probe ALTER COLUMN id DROP DEFAULT;").unwrap();
crate::schema_check::repair_missing_defaults(&db, &root, Some(&hash)).unwrap();
assert_eq!(db.query("SELECT COLUMN_DEFAULT FROM information_schema.COLUMNS WHERE TABLE_SCHEMA='acore_world' AND TABLE_NAME='probe' AND COLUMN_NAME='id';").unwrap(), "0");
assert_eq!(db.query("SELECT id FROM acore_world.probe;").unwrap(), "43");
db.query("ALTER TABLE acore_world.probe ALTER COLUMN id SET DEFAULT 99;").unwrap();
crate::schema_check::repair_missing_defaults(&db, &root, Some(&hash)).unwrap();
assert_eq!(db.query("SELECT COLUMN_DEFAULT FROM information_schema.COLUMNS WHERE TABLE_SCHEMA='acore_world' AND TABLE_NAME='probe' AND COLUMN_NAME='id';").unwrap(), "99");
db.query("SHUTDOWN;").unwrap(); server.0.wait().unwrap();
let files = inventory(&data).unwrap();
copy_verified(&data, &point.join("mysql-data"), &files).unwrap();
let expanded_bytes = files.keys().map(|name| fs::metadata(data.join(name)).unwrap().len()).sum();
let mut snapshot = Snapshot {path:"mysql-data".into(), files, directories:directories(&data).unwrap(), server_sha256:fsx::sha256_file(&executable).unwrap(), bytes:0, expanded_bytes, archive_sha256:None};
for directory in &snapshot.directories { fs::create_dir_all(point.join("mysql-data").join(directory)).unwrap(); }
compress(&data, &point, &mut snapshot).unwrap();
let mut changed = start();
db.query("DROP VIEW acore_characters.probe_view; DROP TRIGGER acore_characters.probe_insert; DROP PROCEDURE acore_characters.probe_proc; DROP FUNCTION acore_characters.probe_func; DELETE FROM acore_characters.probe; DROP USER 'fixture_user'@'localhost';").unwrap();
db.query("SHUTDOWN;").unwrap(); changed.0.wait().unwrap();
swap(&root, &meta, &point, &snapshot, false).unwrap();
let mut restored = start();
assert_eq!(db.recovery_objects("acore_characters").unwrap().len(), 4);
assert_eq!(db.query("SELECT * FROM acore_characters.probe_view; CALL acore_characters.probe_proc(); SELECT acore_characters.probe_func(); SELECT COUNT(*) FROM mysql.user WHERE user='fixture_user';").unwrap().replace("\r\n", "\n"), "42\t43\n42\n73\n1");
db.query("INSERT INTO acore_characters.probe VALUES(45,'check');").unwrap();
assert_eq!(db.query("SELECT note FROM acore_characters.probe WHERE id=45;").unwrap(), "triggered");
db.query("SHUTDOWN;").unwrap(); restored.0.wait().unwrap();
}
fn fixture() -> (tempfile::TempDir, PathBuf, PathBuf, PathBuf, Snapshot) {
let temp = tempfile::tempdir().unwrap();
let root = temp.path().join("server");
let meta = temp.path().join("metadata");
let point = temp.path().join("point");
fsx::atomic_write(&root.join("mysql/bin/mysqld.exe"), b"same-engine").unwrap();
fsx::atomic_write(&root.join("mysql/data/characters.ibd"), b"live").unwrap();
fsx::atomic_write(&point.join("mysql-data/characters.ibd"), b"saved").unwrap();
fs::create_dir_all(point.join("mysql-data/empty_schema")).unwrap();
let snapshot = Snapshot { path:"mysql-data".into(), files:inventory(&point.join("mysql-data")).unwrap(), directories:directories(&point.join("mysql-data")).unwrap(), server_sha256:fsx::sha256_file(&root.join("mysql/bin/mysqld.exe")).unwrap(), bytes:5, expanded_bytes:5, archive_sha256:None };
(temp, root, meta, point, snapshot)
}
#[test]
fn interrupted_directory_swap_is_recoverable_and_keeps_previous_bytes() {
let (_temp, root, meta, point, snapshot) = fixture();
assert!(swap(&root, &meta, &point, &snapshot, true).is_err());
assert!(!root.join("mysql/data").exists());
let old = fs::read_dir(root.join("mysql")).unwrap().flatten().find(|e| e.file_name().to_string_lossy().starts_with("data-before-")).unwrap().path();
assert_eq!(fs::read(old.join("characters.ibd")).unwrap(), b"live");
swap(&root, &meta, &point, &snapshot, false).unwrap();
assert_eq!(fs::read(root.join("mysql/data/characters.ibd")).unwrap(), b"saved");
assert!(root.join("mysql/data/empty_schema").is_dir());
}
#[test]
fn corrupt_or_different_engine_snapshots_do_not_move_live_data() {
let (_temp, root, meta, point, snapshot) = fixture();
fsx::atomic_write(&point.join("mysql-data/characters.ibd"), b"corrupt").unwrap();
assert!(swap(&root, &meta, &point, &snapshot, false).is_err());
assert_eq!(fs::read(root.join("mysql/data/characters.ibd")).unwrap(), b"live");
fsx::atomic_write(&point.join("mysql-data/characters.ibd"), b"saved").unwrap();
fsx::atomic_write(&root.join("mysql/bin/mysqld.exe"), b"new-engine").unwrap();
assert!(swap(&root, &meta, &point, &snapshot, false).is_err());
assert_eq!(fs::read(root.join("mysql/data/characters.ibd")).unwrap(), b"live");
}
#[test]
fn compressed_snapshots_verify_every_file_and_reject_unlisted_entries() {
let (_temp, root, meta, point, mut snapshot) = fixture();
let source = point.join("mysql-data");
compress(&source, &point, &mut snapshot).unwrap();
assert!(snapshot.archive_sha256.is_some());
swap(&root, &meta, &point, &snapshot, false).unwrap();
assert_eq!(fs::read(root.join("mysql/data/characters.ibd")).unwrap(), b"saved");
fsx::atomic_write(&root.join("mysql/data/characters.ibd"), b"preserve").unwrap();
let archive_path = point.join(&snapshot.path);
let encoder = zstd::Encoder::new(fs::File::create(&archive_path).unwrap(), 3).unwrap();
let mut archive = tar::Builder::new(encoder);
archive.append_file("unlisted.ibd", &mut fs::File::open(source.join("characters.ibd")).unwrap()).unwrap();
archive.into_inner().unwrap().finish().unwrap();
snapshot.archive_sha256 = Some(fsx::sha256_file(&archive_path).unwrap());
assert!(swap(&root, &meta, &point, &snapshot, false).is_err());
assert_eq!(fs::read(root.join("mysql/data/characters.ibd")).unwrap(), b"preserve");
fsx::atomic_write(&archive_path, b"damaged").unwrap();
assert!(verify(&point, &snapshot).is_err());
}
#[test]
fn private_rehearsals_reject_external_database_connections() {
let (_temp, root, _meta, _point, _snapshot) = fixture();
fsx::atomic_write_json(&root.join("Settings/repack.json"), &serde_json::json!({"mysqlPort":3307})).unwrap();
fsx::atomic_write_json(&root.join("Settings/database.json"), &serde_json::json!({"rootPassword":"test-root","appPassword":"test-app"})).unwrap();
fsx::atomic_write(&root.join("Settings/worldserver.conf.template"), b"LoginDatabaseInfo = \"@LoginDatabaseInfo@\"\nWorldDatabaseInfo = \"@WorldDatabaseInfo@\"\nCharacterDatabaseInfo = \"@CharacterDatabaseInfo@\"\n").unwrap();
fsx::atomic_write(&root.join("Settings/authserver.conf.template"), b"LoginDatabaseInfo = \"127.0.0.1;3307;acore;test-app;acore_auth\"\n").unwrap();
validate_connections(&root, &root).unwrap();
fsx::atomic_write(&root.join("Settings/authserver.conf.template"), b"LoginDatabaseInfo = \"192.0.2.1;3307;acore;test-app;acore_auth\"\n").unwrap();
let error = validate_connections(&root, &root).unwrap_err().to_string();
assert!(error.contains("external database"));
assert!(!error.contains("test-app"));
}
#[test]
fn a_changed_live_database_invalidates_the_rehearsal() {
let (_temp, root, _meta, _point, snapshot) = fixture();
assert!(unchanged(&root, &snapshot).is_err());
fsx::atomic_write(&root.join("mysql/data/characters.ibd"), b"saved").unwrap();
fs::create_dir_all(root.join("mysql/data/empty_schema")).unwrap();
unchanged(&root, &snapshot).unwrap();
fsx::atomic_write(&root.join("mysql/data/extra.ibd"), b"new data").unwrap();
assert!(unchanged(&root, &snapshot).is_err());
}
}
+81
View File
@@ -19,6 +19,51 @@ pub fn lan_ip() -> Option<Ipv4Addr> {
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
pub struct LanAddress {
pub interface: String,
pub address: String,
pub is_default: bool,
}
/// Suitable unicast IPv4 addresses; shared carrier/Tailscale space belongs to Private mode.
pub fn is_lan_address(ip: Ipv4Addr) -> bool {
!ip.is_unspecified() && !ip.is_loopback() && !ip.is_link_local()
&& !ip.is_multicast() && !ip.is_broadcast() && ip.octets()[0] != 0
&& ip.octets()[0] < 240 && !is_cgnat_range(ip)
}
pub fn validate_lan_address(address: &str) -> Result<Ipv4Addr> {
address.parse::<Ipv4Addr>().ok().filter(|ip| is_lan_address(*ip))
.ok_or_else(|| Error::Invalid("Invalid IPv4 address for local network.".into()))
}
/// An absent/disconnected manual address is intentional: never fall back to another adapter.
pub fn resolve_lan_host(manual: Option<&str>, automatic: Option<Ipv4Addr>) -> Result<String> {
match manual {
Some(address) => validate_lan_address(address).map(|ip| ip.to_string()),
None => automatic.filter(|ip| is_lan_address(*ip)).map(|ip| ip.to_string())
.ok_or_else(|| Error::Invalid("This computer has no usable local network address.".into())),
}
}
fn lan_candidates(rows: impl IntoIterator<Item = (String, Ipv4Addr)>, automatic: Option<Ipv4Addr>) -> Vec<LanAddress> {
let mut rows: Vec<_> = rows.into_iter().filter(|(_, ip)| is_lan_address(*ip)).collect();
rows.sort_by(|a, b| a.0.cmp(&b.0).then(a.1.cmp(&b.1)));
let mut seen = std::collections::HashSet::new();
rows.into_iter().filter(|(_, ip)| seen.insert(*ip)).map(|(interface, ip)| LanAddress {
interface, address: ip.to_string(), is_default: Some(ip) == automatic,
}).collect()
}
/// Native OS enumeration (GetAdaptersAddresses on Windows, getifaddrs on Unix).
pub fn lan_addresses(automatic: Option<Ipv4Addr>) -> Result<Vec<LanAddress>> {
let interfaces = if_addrs::get_if_addrs()?;
Ok(lan_candidates(interfaces.into_iter().filter(|i| i.is_oper_up()).filter_map(|i| {
match i.ip() { IpAddr::V4(ip) => Some((i.name, ip)), _ => None }
}), automatic))
}
pub fn is_private(ip: Ipv4Addr) -> bool {
ip.is_private() || ip.is_loopback() || ip.is_link_local()
}
@@ -132,6 +177,42 @@ mod tests {
s.parse().unwrap()
}
#[test]
fn lan_validation_and_resolution_never_replace_manual_addresses() {
for good in ["192.168.1.20", "10.0.0.5", "172.16.2.4"] {
assert!(validate_lan_address(good).is_ok());
}
for bad in ["abc", "999.1.1.1", "0.0.0.0", "0.1.2.3", "127.0.0.1", "127.9.1.2", "169.254.10.20", "100.101.20.5", "224.0.0.1", "255.255.255.255", "240.0.0.1", "192.168.1.1'; DROP TABLE realmlist"] {
assert!(validate_lan_address(bad).is_err(), "{bad}");
}
let automatic = Some(ip("192.168.0.169"));
assert_eq!(resolve_lan_host(None, automatic).unwrap(), "192.168.0.169");
assert_eq!(resolve_lan_host(Some("192.168.1.50"), automatic).unwrap(), "192.168.1.50");
assert_eq!(resolve_lan_host(Some("192.168.1.50"), None).unwrap(), "192.168.1.50");
assert!(resolve_lan_host(Some("invalid"), automatic).is_err());
assert!(resolve_lan_host(None, None).is_err());
assert!(resolve_lan_host(None, Some(ip("169.254.1.2"))).is_err());
assert!(resolve_lan_host(None, Some(ip("100.100.1.2"))).is_err());
}
#[test]
fn candidates_are_filtered_deduplicated_deterministic_and_default_marked() {
let rows = vec![
("Wi-Fi", "192.168.0.25"), ("Ethernet 2", "192.168.1.50"),
("Ethernet", "192.168.0.169"), ("Duplicate", "192.168.1.50"),
("Loopback", "127.0.0.2"), ("APIPA", "169.254.1.2"),
("Tailscale", "100.101.20.5"), ("Empty", "0.0.0.0"),
("Hyper-V Virtual", "10.0.0.5"),
];
let make = |rows: Vec<(&str, &str)>| lan_candidates(rows.into_iter().map(|(name, address)| (name.into(), ip(address))), Some(ip("192.168.0.169")));
let result = make(rows.clone());
assert_eq!(result.len(), 4);
assert_eq!(result.iter().filter(|a| a.is_default).count(), 1);
assert!(result.iter().any(|a| a.interface == "Hyper-V Virtual"));
assert!(result.iter().any(|a| a.is_default && a.address == "192.168.0.169"));
assert_eq!(result, make(rows.into_iter().rev().collect()));
}
#[test]
fn address_classes() {
assert!(is_private(ip("192.168.1.5")) && is_private(ip("10.0.0.2")) && is_private(ip("172.16.4.4")) && is_private(ip("127.0.0.1")));
+24 -2
View File
@@ -21,6 +21,12 @@ pub const DEFAULT_PART_SIZE: u64 = 1_900_000_000;
/// Archive path of the one-time database credentials shipped with a base package.
pub const BOOTSTRAP_CREDENTIALS: &str = "Settings/database.bootstrap.json";
/// Folder of a Linux (Docker) package that holds the starting databases: `<kind>.sql.zst` for `auth`, `characters`
/// and `world`, in the format of the Manager's own backups. They hold the state in which every migration of the package is
/// already applied (a world database cannot be rebuilt from the repository's SQL files: some migrations are guarded and
/// only apply to the maintainers' own database).
pub const BASELINE_DIR: &str = "Database/baseline";
/// Files that never belong in a shipped package: per-install state, logs, secrets, old binaries.
pub fn excluded(rel: &str) -> bool {
if rel.replace('\\', "/").to_lowercase().starts_with(".realms/") { return true; }
@@ -41,7 +47,7 @@ pub fn excluded(rel: &str) -> bool {
|| l == "mysql/my.ini"
|| l == "mysql/mysql.pid"
|| l == "mysql/data.7z"
|| l.starts_with("core/configs/") && !l.ends_with(".dist") // generated at first start from Settings templates
|| l.starts_with("core/configs/") && !l.ends_with(".dist") && l != "core/configs/modules/playerbots.conf.settings.json" // generated at first start from Settings templates
|| name.ends_with(".pdb")
|| name.ends_with(".bak")
|| name.ends_with(".log")
@@ -56,7 +62,7 @@ fn policy_for(rel: &str) -> (Owner, ReplacePolicy) {
let l = rel.to_lowercase();
if l.starts_with("_migrations/") {
(Owner::Core, ReplacePolicy::NeverTouch) // staged for the migration runner, never copied into the server
} else if l.ends_with(".dist") {
} else if l.ends_with(".dist") || l == "core/configs/modules/playerbots.conf.settings.json" {
(Owner::Core, ReplacePolicy::Replace)
} else if l.starts_with("mysql/data/") {
(Owner::User, ReplacePolicy::NeverTouch)
@@ -211,6 +217,7 @@ pub fn build(src: &Path, out: &Path, opts: &BuildOptions, progress: &dyn Fn(&str
split.close_current()?;
let manifest = Manifest {
compatibility: None,
schema: crate::manifest::SCHEMA,
kind: opts.kind,
version: opts.version.clone(),
@@ -370,6 +377,20 @@ mod tests {
v
}
#[test]
fn upstream_settings_metadata_ships_and_updates_but_active_configs_stay_private() {
let d = tempfile::tempdir().unwrap();
let src = d.path().join("src");
fs::create_dir_all(src.join("Core/configs/modules")).unwrap();
fs::write(src.join("Core/configs/modules/playerbots.conf.settings.json"), "{}\n").unwrap();
fs::write(src.join("Core/configs/modules/playerbots.conf"), "PlayerbotsDatabaseInfo = private\n").unwrap();
let out = d.path().join("package");
let manifest = build(&src, &out, &BuildOptions { kind: Kind::Update, version: "1.0.0".into(), core_commit: None, built_at: "test".into(), part_size: 1 << 20, bots_commit: None, migrations: vec![] }, &|_| {}).unwrap();
assert_eq!(manifest.files.len(), 1);
assert_eq!(manifest.files[0].path, "Core/configs/modules/playerbots.conf.settings.json");
assert_eq!(manifest.files[0].policy, ReplacePolicy::Replace);
}
fn source() -> (tempfile::TempDir, PathBuf) {
let d = tempfile::tempdir().unwrap();
let src = d.path().join("src");
@@ -483,6 +504,7 @@ mod tests {
fs::write(d.path().join(name), &bytes).unwrap();
let ok_sha = fsx::sha256_bytes(b"data");
let m = Manifest {
compatibility: None,
schema: 1,
kind: Kind::Base,
version: "0.1.0".into(),
+41
View File
@@ -0,0 +1,41 @@
//! Which kind of server a new installation is on this computer. This is the one place where the host decides: a Windows
//! computer installs a repack, anything else installs a Docker server. The screens and the commands ask here and then
//! call the code of that kind, so no platform check is scattered through shared code.
use serde::Serialize;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
#[serde(rename_all = "kebab-case")]
pub enum Flavor {
/// The CoA Repack: Windows executables supervised by the repack's launcher.
Repack,
/// MySQL, the auth server and the world server in Docker containers.
Docker,
}
pub fn flavor() -> Flavor {
if cfg!(windows) {
Flavor::Repack
} else {
Flavor::Docker
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_host_decides_once() {
#[cfg(windows)]
assert_eq!(flavor(), Flavor::Repack);
#[cfg(not(windows))]
assert_eq!(flavor(), Flavor::Docker);
}
#[test]
fn the_screens_read_the_flavor_as_a_plain_word() {
assert_eq!(serde_json::to_string(&Flavor::Repack).unwrap(), "\"repack\"");
assert_eq!(serde_json::to_string(&Flavor::Docker).unwrap(), "\"docker\"");
}
}
+28 -3
View File
@@ -250,6 +250,19 @@ pub fn is_alive(record: &ProcessIdentity) -> bool {
identity(record.pid).map(|cur| cur.same_as(record)).unwrap_or(false)
}
/// Every running process whose image file is named one of `names` (compared without case), wherever it lives. Only for
/// diagnostics: a process found this way is not trusted to belong to any installation.
pub fn find_by_file_names(names: &[&str]) -> Vec<ProcessIdentity> {
sys::all_pids()
.into_iter()
.filter_map(identity)
.filter(|p| {
let file = p.exe.rsplit(['\\', '/']).next().unwrap_or("");
names.iter().any(|n| file.eq_ignore_ascii_case(n))
})
.collect()
}
/// Every running process whose image is exactly `exe`.
pub fn find_by_exe(exe: &Path) -> Vec<ProcessIdentity> {
let want = exe.to_string_lossy().to_lowercase().replace('/', "\\");
@@ -265,12 +278,24 @@ fn uptime_secs(p: &ProcessIdentity) -> Option<u64> {
(now >= p.created).then(|| (now - p.created) / 10_000_000)
}
/// The world server of the `coa-bots` repack folder lives inside the server folder and is started by its own
/// launcher (`coa-bots\Core\worldserver.exe`). It serves the same realm, so it counts as this server's world.
fn world_alternatives(root: &Path) -> Vec<PathBuf> {
vec![root.join("coa-bots").join("Core").join("worldserver.exe")]
}
fn service(root: &Path, name: &'static str, exe: PathBuf, port: u16, listen: &[(u16, u32)]) -> ServiceStatus {
service_with(root, name, exe, &[], port, listen)
}
fn service_with(root: &Path, name: &'static str, exe: PathBuf, alternatives: &[PathBuf], port: u16, listen: &[(u16, u32)]) -> ServiceStatus {
// Prefer the repack's own record when it still matches a live process; otherwise discover by exact exe path.
let norm = |p: &Path| p.to_string_lossy().replace('/', "\\");
let expected: Vec<String> = std::iter::once(&exe).chain(alternatives).map(|p| norm(p)).collect();
let proc = read_state_record(root, name)
.filter(is_alive)
.filter(|r| r.exe.eq_ignore_ascii_case(&exe.to_string_lossy().replace('/', "\\")))
.or_else(|| find_by_exe(&exe).into_iter().next());
.filter(|r| expected.iter().any(|e| r.exe.eq_ignore_ascii_case(e)))
.or_else(|| std::iter::once(&exe).chain(alternatives).find_map(|p| find_by_exe(p).into_iter().next()));
let owner = listen.iter().find(|(p, _)| *p == port).map(|(_, pid)| *pid);
let (state, port_ready, conflict) = match (&proc, owner) {
@@ -306,7 +331,7 @@ pub fn observe(root: &Path, ports: &Ports) -> Observed {
Observed {
mysql: service(root, "mysql", mysql, ports.mysql, &listen),
auth: service(root, "auth", auth, ports.auth, &listen),
world: service(root, "world", world, ports.world, &listen),
world: service_with(root, "world", world, &world_alternatives(root), ports.world, &listen),
secondary_world,
}
}
+54 -11
View File
@@ -65,10 +65,16 @@ pub fn state(root: &Path) -> Result<RealmState> {
fsx::read_json(&root.join(STATE))
}
/// The world server executable of this folder: `worldserver.exe` in a repack, `worldserver` in a Docker server.
fn world_binary(root: &Path) -> std::path::PathBuf {
let exe = root.join("Core/worldserver.exe");
if exe.exists() { exe } else { root.join("Core/worldserver") }
}
pub fn view(root: &Path) -> Result<View> {
let s = state(root)?;
// Inspect the binary itself; templates or an old log cannot prove installed support.
let supported = fs::read(root.join("Core/worldserver.exe"))?
let supported = fs::read(world_binary(root))?
.windows(b"Wildcard synergy settings".len()).any(|w| w == b"Wildcard synergy settings");
Ok(View { active: s.active, wildcard_created: s.wildcard_created, supported, recovery_pending: root.join(JOURNAL).exists(), simultaneous: s.simultaneous, secondary_world_port: s.secondary_world_port, secondary_running: crate::multiworld::is_running(root) })
}
@@ -269,6 +275,8 @@ pub fn select(root: &Path, mode: Mode) -> Result<View> {
/// Adapt the bundled launcher's canonical schema and realm choices without changing its supervision logic.
pub fn prepare_launcher(root: &Path) -> Result<()> {
// A Docker server has no launcher to adapt: the Docker backend reads the active realm itself.
if crate::docker::is_docker(root) { return Ok(()); }
let path = root.join("Scripts/manage.py");
let source = fs::read_to_string(&path)?;
let patched = patch_launcher(&source)?;
@@ -287,25 +295,35 @@ pub fn prepare_launcher(root: &Path) -> Result<()> {
Ok(())
}
const LAUNCHER_REALM_REPLACEMENTS: &[(&str, &str)] = &[
("(\"WorldDatabaseInfo\", \"acore_world\")", "(\"WorldDatabaseInfo\", \"acore_world_wildcard\" if coa_realm() == 'wildcard' else \"acore_world\")"),
("(\"CharacterDatabaseInfo\", \"acore_characters\")", "(\"CharacterDatabaseInfo\", \"acore_characters_wildcard\" if coa_realm() == 'wildcard' else \"acore_characters\")"),
("SET name='AzerothCore',address=", "SET name='{coa_realm_name()}',address="),
("WHERE id=1;", "WHERE id={coa_realm_id()};"),
("mysql(\"UPDATE acore_auth.realmlist SET flag=0", "mysql(f\"UPDATE acore_auth.realmlist SET flag=0"),
];
const LAUNCHER_REALM_INSERT: &str = "# coa-manager-realm-profiles-v1\ndef coa_realm():\n path = ROOT / 'Settings/realm-profile.json'\n return json.loads(path.read_text(encoding='utf-8')).get('active', 'coa') if path.exists() else 'coa'\n\ndef coa_realm_id():\n return 2 if coa_realm() == 'wildcard' else 1\n\ndef coa_realm_name():\n return 'Wildcard' if coa_realm() == 'wildcard' else 'Conquest of Azeroth'\n\n";
pub(crate) fn patch_launcher(source: &str) -> Result<String> {
if source.contains("# coa-manager-realm-profiles-v1") { return Ok(source.into()); }
let replacements = [
("(\"WorldDatabaseInfo\", \"acore_world\")", "(\"WorldDatabaseInfo\", \"acore_world_wildcard\" if coa_realm() == 'wildcard' else \"acore_world\")"),
("(\"CharacterDatabaseInfo\", \"acore_characters\")", "(\"CharacterDatabaseInfo\", \"acore_characters_wildcard\" if coa_realm() == 'wildcard' else \"acore_characters\")"),
("SET name='AzerothCore',address=", "SET name='{coa_realm_name()}',address="),
("WHERE id=1;", "WHERE id={coa_realm_id()};"),
("mysql(\"UPDATE acore_auth.realmlist SET flag=0", "mysql(f\"UPDATE acore_auth.realmlist SET flag=0"),
];
let mut out = source.to_string();
for (from, to) in replacements {
for &(from, to) in LAUNCHER_REALM_REPLACEMENTS {
if !out.contains(from) { return Err(Error::Invalid("This launcher does not support realm profiles. Update the server package first.".into())); }
out = out.replace(from, to);
}
let insert = "# coa-manager-realm-profiles-v1\ndef coa_realm():\n path = ROOT / 'Settings/realm-profile.json'\n return json.loads(path.read_text(encoding='utf-8')).get('active', 'coa') if path.exists() else 'coa'\n\ndef coa_realm_id():\n return 2 if coa_realm() == 'wildcard' else 1\n\ndef coa_realm_name():\n return 'Wildcard' if coa_realm() == 'wildcard' else 'Conquest of Azeroth'\n\n";
// Insert before the entry point so ROOT, json and functions are all defined when called.
let marker = "if __name__ == \"__main__\":";
if !out.contains(marker) { return Err(Error::Invalid("Unrecognised server launcher entry point.".into())); }
Ok(out.replace(marker, &format!("{insert}{marker}")))
Ok(out.replace(marker, &format!("{LAUNCHER_REALM_INSERT}{marker}")))
}
/// Reverse only our exact realm transformation; callers must verify the recovered original hash.
pub(crate) fn unpatch_launcher(source: &str) -> Option<String> {
if !source.contains(LAUNCHER_REALM_INSERT) { return None; }
let mut original = source.replacen(LAUNCHER_REALM_INSERT, "", 1);
for &(from, to) in LAUNCHER_REALM_REPLACEMENTS { original = original.replace(to, from); }
patch_launcher(&original).ok().filter(|patched| patched == source).map(|_| original)
}
pub fn before_start(root: &Path) -> Result<()> {
@@ -343,6 +361,31 @@ pub fn setup_realmlist(root: &Path) -> Result<()> {
mod tests {
use super::*;
#[test]
fn a_docker_server_is_checked_for_wildcard_support_in_its_own_binary() {
let d = tempfile::tempdir().unwrap();
fs::create_dir_all(d.path().join("Core")).unwrap();
fs::create_dir_all(d.path().join("Settings")).unwrap();
fs::write(d.path().join("Settings/docker.json"), br#"{"project":"t1"}"#).unwrap();
fs::write(d.path().join("Core/worldserver"), b"ELF...Wildcard synergy settings...").unwrap();
assert!(view(d.path()).unwrap().supported, "worldserver without .exe is read too");
fs::write(d.path().join("Core/worldserver"), b"ELF...an older build").unwrap();
assert!(!view(d.path()).unwrap().supported);
// The repack's executable still wins when both exist, so a repack is read as before.
fs::write(d.path().join("Core/worldserver.exe"), b"MZ...Wildcard synergy settings").unwrap();
assert!(view(d.path()).unwrap().supported);
}
#[test]
fn a_docker_server_has_no_launcher_to_adapt() {
let d = tempfile::tempdir().unwrap();
fs::create_dir_all(d.path().join("Settings")).unwrap();
// No Scripts/manage.py anywhere: on a repack this fails, on a Docker server there is nothing to do.
assert!(prepare_launcher(d.path()).is_err());
fs::write(d.path().join("Settings/docker.json"), br#"{"project":"t1"}"#).unwrap();
prepare_launcher(d.path()).unwrap();
}
#[test]
fn fresh_wildcard_disables_bots_and_preserves_scaling() {
let mut f = Files::new();
+1
View File
@@ -14,6 +14,7 @@ use crate::fsx;
pub const META_SCHEMA: u32 = 1;
pub const LAYOUT_REPACK_V1: &str = "repack-v1";
pub const LAYOUT_DOCKER_V1: &str = "docker-v1";
const META_SUBDIRS: [&str; 6] = ["manifests", "backups", "migrations", "logs", "cache", "staging"];
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+52 -4
View File
@@ -44,8 +44,17 @@ fn introduction_rank(repo: &Path, pathspecs: &[&str]) -> std::collections::HashM
rank
}
/// Every SQL script of a core checkout (released + pending updates, module base and update scripts), in application order.
/// Incremental SQL of a core checkout. Installation-only module bases must never be replayed on a live database.
pub fn collect_core_sql(core: &Path) -> Result<Vec<SqlFile>> {
collect_core_sql_mode(core, false)
}
/// A clean installation also needs the module tables and initial seed data.
pub fn collect_core_install_sql(core: &Path) -> Result<Vec<SqlFile>> {
collect_core_sql_mode(core, true)
}
fn collect_core_sql_mode(core: &Path, include_base: bool) -> Result<Vec<SqlFile>> {
let mut out = Vec::new();
let mut push = |db: &str, id: String, abs: PathBuf, origin: String| -> Result<()> {
let sha256 = fsx::sha256_file(&abs)?;
@@ -69,7 +78,7 @@ pub fn collect_core_sql(core: &Path) -> Result<Vec<SqlFile>> {
let mname = name.replace('-', "_");
for kind in ["auth", "characters", "world"] {
let base = m.path().join(format!("data/sql/db-{kind}"));
for f in sql_in(&base.join("base")) {
for f in if include_base { sql_in(&base.join("base")) } else { vec![] } {
let stem = f.file_stem().unwrap().to_string_lossy().into_owned();
let rel = format!("modules/{name}/data/sql/db-{kind}/base/{}", f.file_name().unwrap().to_string_lossy());
push(kind, format!("mod_{mname}__base__{stem}"), f, rel)?;
@@ -87,6 +96,21 @@ pub fn collect_core_sql(core: &Path) -> Result<Vec<SqlFile>> {
Ok(out)
}
/// Dump the three game databases of `server` (a repack or a Docker server, started if needed) into `out` as the starting
/// databases of a Linux package: `<kind>.sql.zst`. The databases must be in the state in which every migration of the
/// package is applied. Returns (kind, compressed bytes) per database.
pub fn export_baseline(server: &Path, out: &Path) -> Result<Vec<(String, u64)>> {
fs::create_dir_all(out)?;
crate::backup::with_database(server, |db| {
let mut done = Vec::new();
for (kind, schema) in crate::db::SCHEMAS {
let (bytes, _) = db.dump_to(schema, &out.join(format!("{kind}.sql.zst")))?;
done.push((kind.to_string(), bytes));
}
Ok(done)
})
}
/// SQL a bots module checkout ships for the characters database (its `dist/sql`).
pub fn collect_bots_sql(bots: &Path) -> Result<Vec<SqlFile>> {
let mut out = Vec::new();
@@ -98,7 +122,7 @@ pub fn collect_bots_sql(bots: &Path) -> Result<Vec<SqlFile>> {
}
fn to_migrations(files: &[SqlFile]) -> Vec<Migration> {
files.iter().map(|f| Migration { id: f.id.clone(), db: f.db.clone(), sha256: f.sha256.clone(), destructive: false }).collect()
files.iter().map(|f| Migration { compatible_sha256: vec![], id: f.id.clone(), db: f.db.clone(), sha256: f.sha256.clone(), destructive: false }).collect()
}
pub struct UpdateParams<'a> {
@@ -129,6 +153,9 @@ fn walk(root: &Path, dir: &Path, out: &mut Vec<String>) -> Result<()> {
/// Build a cumulative update: every file of `tree` that differs from the base, plus every SQL script. Unsigned.
pub fn pack_update(p: &UpdateParams, progress: &dyn Fn(&str)) -> Result<Manifest> {
if let Some(file) = p.sql.iter().find(|file| file.id.starts_with("mod_") && file.id.contains("__base__")) {
return Err(Error::Invalid(format!("Module installation SQL {} cannot be included in an update package.", file.id)));
}
let base: BTreeMap<String, &str> = p.base_manifest.files.iter().map(|f| (f.path.to_lowercase(), f.sha256.as_str())).collect();
let work = p.out.with_file_name(format!("{}-staging", p.out.file_name().unwrap().to_string_lossy()));
let _ = fs::remove_dir_all(&work);
@@ -203,7 +230,7 @@ mod tests {
write(c, "data/sql/updates/db_characters/2026_01_02_00.sql", "SELECT 3;");
write(c, "modules/mod-x/data/sql/db-world/base/01_a.sql", "SELECT 4;");
write(c, "modules/mod-x/data/sql/db-world/2026_02_02_00_b.sql", "SELECT 5;");
let v = collect_core_sql(c).unwrap();
let v = collect_core_install_sql(c).unwrap();
let ids: Vec<(&str, &str)> = v.iter().map(|f| (f.db.as_str(), f.id.as_str())).collect();
assert!(ids.contains(&("world", "2026_01_01_00")) && ids.contains(&("world", "rev_1")) && ids.contains(&("characters", "2026_01_02_00")));
assert!(ids.contains(&("world", "mod_mod_x__base__01_a")) && ids.contains(&("world", "mod_mod_x__2026_02_02_00_b")));
@@ -211,6 +238,27 @@ mod tests {
let base_pos = ids.iter().position(|x| x.1 == "mod_mod_x__base__01_a").unwrap();
let upd_pos = ids.iter().position(|x| x.1 == "mod_mod_x__2026_02_02_00_b").unwrap();
assert!(base_pos < upd_pos, "a module's base script precedes its updates");
let updates = collect_core_sql(c).unwrap();
assert!(!updates.iter().any(|f| f.id.contains("__base__")));
assert!(updates.iter().any(|f| f.id == "mod_mod_x__2026_02_02_00_b"));
}
#[test]
fn update_packaging_rejects_module_seed_sql_before_creating_output() {
let d = tempfile::tempdir().unwrap();
let base: Manifest = serde_json::from_value(serde_json::json!({
"schema": 1, "kind": "base", "version": "1.0.0", "core": {"commit": null},
"builtAt": "test", "minManagerVersion": "0.1.0", "files": []
})).unwrap();
let out = d.path().join("out");
let sql = vec![SqlFile { db: "world".into(), id: "mod_mod_raid__base__03_boss_schedule".into(),
origin: "modules/mod-raid/data/sql/db-world/base/03_boss_schedule.sql".into(),
abs: d.path().join("seed.sql"), sha256: "a".repeat(64) }];
let result = pack_update(&UpdateParams { tree: d.path(), base_manifest: &base, sql: &sql,
out: &out, version: "1.1.0".into(), core_commit: None, bots_commit: None, part_size: 1024 }, &|_| {});
assert!(result.unwrap_err().to_string().contains("installation SQL"));
assert!(!out.exists());
assert!(!d.path().join("out-staging").exists());
}
#[test]
+216 -2
View File
@@ -5,6 +5,90 @@ use crate::{backup, fsx, install, manifest::{Kind, Migration}, migrations, packa
const MARKER: &str = ".release-schema-fixture";
struct QualificationEnv<'a>(crate::update::RepackEnv<'a>);
impl crate::update::Env for QualificationEnv<'_> {
fn activate(&self) -> Result<()> { Ok(()) }
fn ensure_stopped(&self) -> Result<()> { self.0.ensure_stopped() }
fn preflight(&self, manifest: &crate::manifest::Manifest) -> Result<()> { self.0.preflight(manifest) }
fn snapshot(&self) -> Result<String> { self.0.snapshot() }
fn verify_snapshot(&self, id: &str) -> Result<()> { self.0.verify_snapshot(id) }
fn rehearse(&self, manifest: &crate::manifest::Manifest, tree: &Path, items: &[crate::update::PlanItem], point: &str) -> Result<()> { self.0.rehearse(manifest, tree, items, point) }
fn restore_snapshot(&self, id: &str) -> Result<()> { self.0.restore_snapshot(id) }
fn migrate(&self, manifest: &crate::manifest::Manifest, staged: &Path) -> Result<crate::migrations::ApplyReport> { self.0.migrate(manifest, staged) }
fn validate(&self) -> Result<()> { self.0.validate() }
fn validate_recovery(&self) -> Result<()> { self.0.validate_recovery() }
fn recover_validation(&self) -> Result<()> { self.0.recover_validation() }
fn automatic_rollback(&self) -> bool { true }
// Health checks use the normal private validation; qualification never opens game ports after commit.
}
pub fn qualify_upgrade(base: &Path, source: &Path, candidate: &Path, fixture: &Path, trusted_key: &str) -> Result<serde_json::Value> {
use crate::update::Env;
if !cfg!(windows) { return Err(Error::Invalid("Manager upgrade qualification requires a Windows fixture.".into())); }
if fixture.exists() || !fixture.file_name().is_some_and(|name| name.to_string_lossy().starts_with("coa-schema-fixture-")) {
return Err(Error::Invalid("Upgrade qualification requires a new disposable coa-schema-fixture-* directory.".into()));
}
let fixture_root = std::path::absolute(fixture)?;
let fixture = fixture_root.as_path();
let base_root = fsx::canonicalize_lenient(base)?;
let base = base_root.as_path();
let source_root = fsx::canonicalize_lenient(source)?;
let source = source_root.as_path();
let candidate_root = fsx::canonicalize_lenient(candidate)?;
let candidate = candidate_root.as_path();
let metadata = crate::registry::metadata_dir_for(fixture)?;
if metadata.exists() { return Err(Error::Invalid("Upgrade fixture metadata already exists.".into())); }
let (base_manifest, base_bytes) = pkgsource::fetch_manifest(&pkgsource::Source::Dir(base.into()), trusted_key)?;
let (source_manifest, source_bytes) = pkgsource::fetch_manifest(&pkgsource::Source::Dir(source.into()), trusted_key)?;
let (candidate_manifest, _) = pkgsource::fetch_manifest(&pkgsource::Source::Dir(candidate.into()), trusted_key)?;
if candidate_manifest.kind != Kind::Update || !matches!(source_manifest.kind, Kind::Base | Kind::Update)
|| (source_manifest.kind == Kind::Base && fsx::sha256_bytes(&base_bytes) != fsx::sha256_bytes(&source_bytes)) {
return Err(Error::Invalid("Invalid source or candidate package for upgrade qualification.".into()));
}
extract_base(base, fixture, trusted_key)?;
package::extract_selected(base, &base_manifest, fixture, &|path| path.starts_with("Data/"), &|_, _| {})?;
let mut meta = crate::registry::InstallMeta::new(crate::registry::InstallKind::New, fixture);
meta.core.version = Some(base_manifest.version.clone());
meta.core.commit = base_manifest.core.commit.clone();
meta.original_hashes = base_manifest.files.iter().map(|file| (file.path.clone(), file.sha256.clone())).collect();
crate::registry::MetaDir::create(fixture, &meta)?;
let env = QualificationEnv(crate::update::RepackEnv { root: fixture, meta_dir: &metadata });
let apply = |package: &Path| -> Result<()> {
let outcome = crate::update::apply(&crate::update::Params {
root: fixture, meta_dir: &metadata, source: pkgsource::Source::Dir(package.into()),
trusted_key, cancel: crate::download::Cancel::default(), resolutions: Default::default(),
env: &env, fail_after_ops: None,
}, &|_, _| {})?;
if outcome.txn.state != crate::update::State::Committed {
return Err(Error::Invalid("Upgrade qualification did not commit.".into()));
}
env.ensure_stopped()
};
install::with_scratch_ports(fixture, || {
if source_manifest.kind == Kind::Update { apply(source)?; }
let user_file = fixture.join("Core/configs/coa-qualification-user.conf");
let user_bytes = b"Qualification.UserSetting = 7391\r\n";
fsx::atomic_write(&user_file, user_bytes)?;
apply(candidate)?;
if std::fs::read(&user_file)?.as_slice() != user_bytes {
return Err(Error::Invalid("The update changed a user configuration file.".into()));
}
let (_, installed) = crate::registry::MetaDir::open(&metadata)?;
if installed.core.version.as_deref() != Some(candidate_manifest.version.as_str())
|| crate::update_isolation::pending(&metadata) || crate::update::pending_checked(&metadata)?.is_some() {
return Err(Error::Invalid("The update left inconsistent metadata or an unfinished transaction.".into()));
}
Ok(())
})?;
Ok(serde_json::json!({
"schema": 1, "result": "passed", "fromVersion": source_manifest.version,
"toVersion": candidate_manifest.version, "fromManifestSha256": fsx::sha256_bytes(&source_bytes),
"fromSchemaSha256": source_manifest.files.iter().find(|file| file.path == schema_check::CONTRACT).map(|file| &file.sha256),
"checks": ["manager-transaction", "private-user-database-rehearsal", "database-schema", "private-auth-world-startup", "existing-identities", "user-file-preservation"],
}))
}
pub fn collect(core: &Path, bots: Option<&Path>, repairs: Option<&Path>) -> Result<Vec<SqlFile>> {
let mut files = release::collect_core_sql(core)?;
if let Some(bots) = bots { files.extend(release::collect_bots_sql(bots)?); }
@@ -38,7 +122,12 @@ pub fn extract_base(source: &Path, fixture: &Path, trusted_key: &str) -> Result<
["mysql/", "settings/", "runtime/", "scripts/", "core/", "bugreport/"].iter().any(|prefix| path.starts_with(prefix))
}, &|_, _| {})?;
fsx::atomic_write(&fixture.join(MARKER), b"disposable release-schema fixture")?;
install::bootstrap_database(fixture)
// A Linux computer has no Windows database program: the fixture is a Docker server over the package's data directory.
if cfg!(windows) {
install::bootstrap_database(fixture)
} else {
crate::docker::fixture::prepare(fixture)
}
}
pub fn capture_release(fixture: &Path, tree: &Path, sql: &[SqlFile]) -> Result<()> {
@@ -47,7 +136,7 @@ pub fn capture_release(fixture: &Path, tree: &Path, sql: &[SqlFile]) -> Result<(
return Err(Error::Invalid("Refusing to apply release SQL to a non-fixture server.".into()));
}
let staging = tempfile::tempdir()?;
let migrations: Vec<_> = sql.iter().map(|f| Migration { db: f.db.clone(), id: f.id.clone(), sha256: f.sha256.clone(), destructive: false }).collect();
let migrations: Vec<_> = sql.iter().map(|f| Migration { compatible_sha256: vec![], db: f.db.clone(), id: f.id.clone(), sha256: f.sha256.clone(), destructive: false }).collect();
for file in sql {
let path = fsx::safe_join(staging.path(), &format!("{}/{}.sql", file.db, file.id))?;
fsx::atomic_write(&path, &std::fs::read(&file.abs)?)?;
@@ -67,6 +156,69 @@ pub fn capture_release(fixture: &Path, tree: &Path, sql: &[SqlFile]) -> Result<(
}))
}
pub fn validate_startup(fixture: &Path, tree: &Path, base: &Path, trusted_key: &str) -> Result<()> {
use crate::update::Env;
if !cfg!(windows) {
return Err(Error::Invalid("Repack startup qualification requires a Windows runner.".into()));
}
if !fixture.file_name().is_some_and(|n| n.to_string_lossy().starts_with("coa-schema-fixture-"))
|| std::fs::read(fixture.join(MARKER)).ok().as_deref() != Some(b"disposable release-schema fixture") {
return Err(Error::Invalid("Startup qualification requires a disposable release-schema fixture.".into()));
}
let fixture_root = fsx::canonicalize_lenient(fixture)?;
let fixture = fixture_root.as_path();
let tree_root = fsx::canonicalize_lenient(tree)?;
let tree = tree_root.as_path();
let metadata = crate::registry::metadata_dir_for(fixture)?;
if metadata.exists() { return Err(Error::Invalid("Startup fixture already has Manager metadata; use a fresh fixture.".into())); }
schema_check::require_release_contract(tree)?;
for name in ["worldserver.exe", "authserver.exe"] {
if !tree.join("Core").join(name).is_file() {
return Err(Error::Invalid(format!("Startup candidate is missing {name}.")));
}
}
let (manifest, _) = pkgsource::fetch_manifest(&pkgsource::Source::Dir(base.into()), trusted_key)?;
if manifest.kind != Kind::Base { return Err(Error::Invalid("Startup qualification requires a signed base package.".into())); }
let mut directories = vec![tree.to_path_buf()];
let mut files = Vec::new();
while let Some(directory) = directories.pop() {
for entry in std::fs::read_dir(directory)? {
let entry = entry?;
let kind = entry.file_type()?;
if kind.is_symlink() { return Err(Error::Invalid("Startup release tree must not contain symbolic links.".into())); }
let path = entry.path();
fsx::ensure_within(tree, &path)?;
if kind.is_dir() { directories.push(path); continue; }
if !kind.is_file() { return Err(Error::Invalid("Startup release tree contains an unsupported file type.".into())); }
let relative = path.strip_prefix(tree).map_err(|e| Error::Invalid(e.to_string()))?.to_path_buf();
let first = relative.components().next().unwrap().as_os_str().to_string_lossy();
if !matches!(first.as_ref(), "Core" | "Scripts" | "Data" | "Extras" | "Licenses") {
return Err(Error::Invalid("Startup release tree contains installation-specific files.".into()));
}
fsx::ensure_within(fixture, &fixture.join(&relative))?;
files.push(relative);
}
}
package::extract_selected(base, &manifest, fixture, &|path| path.starts_with("Data/"), &|_, _| {})?;
for relative in files {
let target = fsx::ensure_within(fixture, &fixture.join(&relative))?;
fsx::atomic_write(&target, &std::fs::read(tree.join(&relative))?)?;
let expected = fsx::sha256_file(&tree.join(relative))?;
if fsx::sha256_file(&target)? != expected {
return Err(Error::Invalid("Startup candidate copy failed verification.".into()));
}
}
let meta = crate::registry::InstallMeta::new(crate::registry::InstallKind::New, fixture);
crate::registry::MetaDir::create(fixture, &meta)?;
let env = crate::update::RepackEnv { root: fixture, meta_dir: &metadata };
env.validate()?;
env.ensure_stopped()?;
if crate::update_isolation::pending(&metadata) {
return Err(Error::Invalid("Startup qualification left unfinished isolated validation.".into()));
}
Ok(())
}
pub fn verify_package(dir: &Path, trusted_key: &str) -> Result<()> {
let (manifest, _) = pkgsource::fetch_manifest(&pkgsource::Source::Dir(dir.into()), trusted_key)?;
if !manifest.files.iter().any(|f| f.path == schema_check::CONTRACT && f.size > 0) {
@@ -78,12 +230,49 @@ pub fn verify_package(dir: &Path, trusted_key: &str) -> Result<()> {
Ok(())
}
pub fn verify_upgrade_fixture(dir: &Path, trusted_key: &str) -> Result<()> {
let (manifest, _) = pkgsource::fetch_manifest(&pkgsource::Source::Dir(dir.into()), trusted_key)?;
if !matches!(manifest.kind, Kind::Base | Kind::Update) {
return Err(Error::Invalid("Upgrade fixtures must be base or server update packages.".into()));
}
let scratch = tempfile::tempdir()?;
package::extract_selected(dir, &manifest, scratch.path(), &|path| path == schema_check::CONTRACT, &|_, _| {})?;
if manifest.kind == Kind::Update || manifest.files.iter().any(|file| file.path == schema_check::CONTRACT) {
schema_check::require_release_contract(scratch.path())?;
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use base64::{engine::general_purpose::STANDARD, Engine};
use ed25519_dalek::{Signer, SigningKey};
#[test]
fn relative_startup_fixture_targets_replace_the_original_location() {
let directory = tempfile::Builder::new().prefix("coa-schema-fixture-path-test-").tempdir_in(".").unwrap();
let current = std::env::current_dir().unwrap();
let relative = directory.path().strip_prefix(&current).unwrap();
fsx::atomic_write(&relative.join("Core/worldserver.exe"), b"old").unwrap();
let root = fsx::canonicalize_lenient(relative).unwrap();
let target = fsx::ensure_within(&root, &root.join("Core/worldserver.exe")).unwrap();
fsx::atomic_write(&target, b"candidate").unwrap();
assert_eq!(std::fs::read(relative.join("Core/worldserver.exe")).unwrap(), b"candidate");
assert!(!root.join(relative).join("Core/worldserver.exe").exists());
}
#[test]
fn startup_qualification_refuses_real_server_folders_before_writes() {
let directory = tempfile::tempdir().unwrap();
let server = directory.path().join("live-server");
std::fs::create_dir(&server).unwrap();
fsx::atomic_write(&server.join("owner-data"), b"untouched").unwrap();
assert!(validate_startup(&server, directory.path(), directory.path(), "unused").is_err());
assert_eq!(std::fs::read(server.join("owner-data")).unwrap(), b"untouched");
assert!(!crate::registry::metadata_dir_for(&server).unwrap().exists());
}
#[test]
fn signed_packages_must_carry_a_real_complete_schema_contract() {
let dir = tempfile::tempdir().unwrap();
@@ -122,6 +311,31 @@ mod tests {
let dir = tempfile::tempdir().unwrap();
assert!(extract_base(dir.path(), dir.path(), "irrelevant").is_err());
assert!(capture_release(dir.path(), dir.path(), &[]).is_err());
assert!(qualify_upgrade(dir.path(), dir.path(), dir.path(), dir.path(), "irrelevant").is_err());
assert!(!dir.path().join(schema_check::CONTRACT).exists());
}
#[test]
fn only_legacy_base_fixtures_may_omit_the_schema_contract() {
let dir = tempfile::tempdir().unwrap();
let tree = dir.path().join("tree");
let out = dir.path().join("package");
fsx::atomic_write(&tree.join("Core/example.txt"), b"fixture").unwrap();
let key = SigningKey::from_bytes(&[29; 32]);
let public = STANDARD.encode(key.verifying_key().as_bytes());
let options = package::BuildOptions { kind: Kind::Base, version: "0.2.0".into(), core_commit: None, bots_commit: None, built_at: "test".into(), part_size: 1024 * 1024, migrations: vec![] };
package::build(&tree, &out, &options, &|_| {}).unwrap();
let sign = || {
let bytes = std::fs::read(out.join("manifest.json")).unwrap();
fsx::atomic_write(&out.join("manifest.json.sig"), STANDARD.encode(key.sign(&bytes).to_bytes()).as_bytes()).unwrap();
};
sign();
verify_upgrade_fixture(&out, &public).unwrap();
assert!(verify_package(&out, &public).is_err());
let mut manifest: serde_json::Value = fsx::read_json(&out.join("manifest.json")).unwrap();
manifest["kind"] = "update".into();
fsx::atomic_write_json(&out.join("manifest.json"), &manifest).unwrap();
sign();
assert!(verify_upgrade_fixture(&out, &public).is_err());
}
}
+116
View File
@@ -0,0 +1,116 @@
//! Where a problem report goes. A report about the bots goes to the repository of the bot system in question, anything
//! else to the Manager's own. The repositories come from the module catalog, so there is one list to keep right.
use std::path::Path;
use serde::Serialize;
pub const MANAGER_REPO: &str = "Corfirean/coa-server-manager";
/// One place a report can be filed. `id` is what the page sends back; `repo` is `owner/name` on GitHub.
#[derive(Debug, Clone, Serialize, PartialEq, Eq)]
pub struct Target {
pub id: &'static str,
pub repo: String,
/// The report form asks for the Manager's labels only where we own the repository.
pub ours: bool,
}
/// `https://github.com/owner/name/tree/main/x` -> `owner/name`.
fn repo_of(url: &str) -> Option<String> {
let rest = url.strip_prefix("https://github.com/")?;
let mut parts = rest.split('/');
let (owner, name) = (parts.next()?, parts.next()?);
let ok = |s: &str| !s.is_empty() && s.chars().all(|c| c.is_ascii_alphanumeric() || "._-".contains(c));
(ok(owner) && ok(name)).then(|| format!("{owner}/{name}"))
}
fn catalog_repo(id: &str) -> Option<String> {
crate::modules::catalog().into_iter().find(|e| e.id == id).and_then(|e| repo_of(&e.repo))
}
/// The three places, in the order the page lists them. A bot system whose repository is unknown falls back to the Manager's.
pub fn targets() -> Vec<Target> {
let mut v = vec![Target { id: "manager", repo: MANAGER_REPO.into(), ours: true }];
for (id, module) in [("companions", "companions"), ("squid", "playerbots")] {
if let Some(repo) = catalog_repo(module) {
v.push(Target { id, repo: repo.clone(), ours: repo.starts_with("Corfirean/") });
}
}
v
}
pub fn target(id: &str) -> Option<Target> {
targets().into_iter().find(|t| t.id == id)
}
/// True for the "new issue" page of one of the targets: exactly that page, optionally with a query.
pub fn is_new_issue_url(url: &str) -> bool {
targets().iter().any(|t| {
let base = format!("https://github.com/{}/issues/new", t.repo);
url == base || url.starts_with(&format!("{base}?"))
})
}
/// What the report form fills in about the bot systems of this server.
#[derive(Debug, Clone, Serialize, PartialEq, Eq)]
pub struct Bots {
/// The target the form should start with: the bot system that is switched on, else the Manager.
pub suggested: &'static str,
/// The release of SQUID Playerbots, when it is the one switched on.
pub squid_version: Option<String>,
}
pub fn bots(root: &Path) -> Bots {
let list = crate::modules::list(root);
let on = |id: &str| list.iter().find(|m| m.id == id).filter(|m| m.installed && m.enabled);
let squid = on("playerbots");
Bots {
suggested: if squid.is_some() { "squid" } else if on("companions").is_some() { "companions" } else { "manager" },
squid_version: squid.and_then(|m| m.version.clone()).filter(|v| !v.is_empty()),
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_three_targets_come_from_the_catalog() {
let t = targets();
let repo = |id: &str| t.iter().find(|x| x.id == id).map(|x| x.repo.clone());
assert_eq!(repo("manager").as_deref(), Some("Corfirean/coa-server-manager"));
assert_eq!(repo("companions").as_deref(), Some("Corfirean/mod-coa-playerbots"));
assert_eq!(repo("squid").as_deref(), Some("Zyth45/mod-playerbots"));
assert!(t.iter().find(|x| x.id == "squid").is_some_and(|x| !x.ours));
}
#[test]
fn repository_names_are_read_from_module_links() {
assert_eq!(repo_of("https://github.com/Corfirean/azerothcore-wotlk-coa/tree/coa-bots/modules/x").as_deref(), Some("Corfirean/azerothcore-wotlk-coa"));
assert_eq!(repo_of("https://github.com/Zyth45/mod-playerbots").as_deref(), Some("Zyth45/mod-playerbots"));
assert_eq!(repo_of("https://example.com/a/b"), None);
assert_eq!(repo_of("https://github.com/a"), None);
}
#[test]
fn only_the_new_issue_pages_of_the_targets_are_allowed() {
assert!(is_new_issue_url("https://github.com/Zyth45/mod-playerbots/issues/new"));
assert!(is_new_issue_url("https://github.com/Corfirean/mod-coa-playerbots/issues/new?title=a&body=b"));
assert!(!is_new_issue_url("https://github.com/Zyth45/mod-playerbots/issues/newer"));
assert!(!is_new_issue_url("https://github.com/Zyth45/other/issues/new"));
assert!(!is_new_issue_url("https://evil.example/Corfirean/coa-server-manager/issues/new"));
}
#[test]
fn the_suggested_target_follows_the_bot_system_that_is_on() {
let d = tempfile::tempdir().unwrap();
let root = d.path().join("srv");
crate::layout::testkit::fake_repack(&root);
let conf = root.join("Core/configs/modules");
std::fs::write(conf.join("mod_coa_playerbots.conf"), "CoaBots.Enable = 1\n").unwrap();
assert_eq!(bots(&root).suggested, "companions");
std::fs::write(conf.join("mod_coa_playerbots.conf"), "CoaBots.Enable = 0\n").unwrap();
assert_eq!(bots(&root).suggested, "manager");
}
}
+87 -1
View File
@@ -39,6 +39,35 @@ pub fn require_release_contract(root: &Path) -> Result<Contract> {
#[derive(Debug, Serialize)]
pub struct Problem { pub database: String, pub table: String, pub column: String, pub detail: String }
/// Keep all differences for support; never change a database to match a contract automatically.
pub fn check_with_report(db: &Db, root: &Path) -> Result<Vec<Problem>> {
let problems = check(db, root)?;
if problems.is_empty() { return Ok(problems); }
let report = serde_json::json!({
"schema": 1, "checkedAt": chrono::Utc::now().to_rfc3339(),
"realm": db.realm().name(), "problems": problems,
});
let path = crate::registry::metadata_dir_for(root)?.join("diagnostics")
.join(format!("schema-validation-{}-{}.json", db.realm().name(), uuid::Uuid::new_v4()));
// A log write failure must neither hide the original mismatch nor accept an invalid schema.
if let Err(error) = fsx::atomic_write_json(&path, &report) {
tracing::warn!(%error, path = %path.display(), "Could not save database schema report");
}
Ok(problems)
}
fn describe_signature(signature: &str) -> String {
let fields: Vec<_> = signature.split('|').collect();
if fields.len() != 4 { return signature.into(); }
let decode = |value: &str| -> String {
if value == "<NULL>" { return "no default".into(); }
if value == "<NONE>" { return "none".into(); }
hex::decode(value).ok().and_then(|bytes| String::from_utf8(bytes).ok())
.map(|text| format!("{text:?}")).unwrap_or_else(|| value.into())
};
format!("type={}, nullable={}, default={}, extra={}", fields[0], fields[1], decode(fields[2]), decode(fields[3]))
}
fn read_columns(db: &Db, kind: &str) -> Result<BTreeMap<String, BTreeMap<String, String>>> {
let schema = db.realm_schema(crate::db::schema_of(kind)?);
let text = db.query(&format!("SELECT TABLE_NAME,COLUMN_NAME,CONCAT(COLUMN_TYPE,'|',IS_NULLABLE,'|',IF(COLUMN_DEFAULT IS NULL,'<NULL>',HEX(COLUMN_DEFAULT)),'|',IF(EXTRA='','<NONE>',HEX(EXTRA))) FROM information_schema.COLUMNS WHERE TABLE_SCHEMA='{schema}' ORDER BY TABLE_NAME,ORDINAL_POSITION;"))?;
@@ -56,6 +85,46 @@ pub fn capture(db: &Db, root: &Path) -> Result<()> {
fsx::atomic_write_json(&root.join(CONTRACT), &Contract { schema: 1, columns })
}
fn missing_default(expected: &str, actual: &str) -> Option<String> {
let expected: Vec<_> = expected.split('|').collect();
let actual: Vec<_> = actual.split('|').collect();
if expected.len() != 4 || actual.len() != 4 || expected[0] != actual[0]
|| expected[1] != "NO" || actual[1] != "NO" || expected[3] != "<NONE>" || actual[3] != "<NONE>"
|| actual[2] != "<NULL>" || matches!(expected[2], "<NULL>" | "<NONE>") { return None; }
String::from_utf8(hex::decode(expected[2]).ok()?).ok()
}
/// Only restore a missing literal default from the exact signed target contract. Never alter data or custom defaults.
pub(crate) fn repair_missing_defaults(db: &Db, root: &Path, signed_hash: Option<&str>) -> Result<()> {
let Some(signed_hash) = signed_hash else { return Ok(()); };
if fsx::sha256_file(&root.join(CONTRACT))? != signed_hash {
return Err(crate::Error::Invalid("The target schema contract differs from the signed update.".into()));
}
let contract = require_release_contract(root)?;
let mut repaired = Vec::new();
let quote = |identifier: &str| format!("`{}`", identifier.replace('`', "``"));
for (kind, tables) in &contract.columns {
let schema = db.realm_schema(crate::db::schema_of(kind)?);
let actual = read_columns(db, kind)?;
let base_tables: BTreeSet<_> = db.tables(crate::db::schema_of(kind)?)?.into_iter().collect();
for (table, columns) in tables {
if !base_tables.contains(table) { continue; }
if matches!(table.as_str(), "updates" | "updates_include" | "coa_manager_migrations") { continue; }
for (column, expected) in columns {
let Some(found) = actual.get(table).and_then(|columns| columns.get(column)) else { continue; };
let Some(value) = missing_default(expected, found) else { continue; };
db.query(&format!("SET SESSION sql_mode=CONCAT_WS(',',@@SESSION.sql_mode,'NO_BACKSLASH_ESCAPES'); ALTER TABLE {}.{} ALTER COLUMN {} SET DEFAULT '{}';", quote(schema), quote(table), quote(column), value.replace('\'', "''")))?;
repaired.push(serde_json::json!({"database":schema,"table":table,"column":column,"action":"restore-missing-default"}));
}
}
}
if !repaired.is_empty() {
let path = crate::registry::metadata_dir_for(root)?.join("diagnostics").join(format!("database-repair-{}.json", uuid::Uuid::new_v4()));
fsx::atomic_write_json(&path, &serde_json::json!({"schema":1,"checkedAt":chrono::Utc::now().to_rfc3339(),"contractSha256":signed_hash,"repairs":repaired}))?;
}
Ok(())
}
pub fn check(db: &Db, root: &Path) -> Result<Vec<Problem>> {
let contract = if root.join(CONTRACT).is_file() {
let contract: Contract = fsx::read_json(&root.join(CONTRACT))?;
@@ -98,7 +167,7 @@ pub fn check(db: &Db, root: &Path) -> Result<Vec<Problem>> {
for (column, want) in cols {
let found = actual[table].get(column);
if found.is_none() || (!want.is_empty() && found != Some(want)) {
problems.push(Problem { database: kind.clone(), table: table.clone(), column: column.clone(), detail: found.map(|s| format!("Expected {want}, found {s}")).unwrap_or_else(|| "Missing column".into()) });
problems.push(Problem { database: kind.clone(), table: table.clone(), column: column.clone(), detail: found.map(|s| format!("Expected {}, found {}", describe_signature(want), describe_signature(s))).unwrap_or_else(|| "Missing column".into()) });
}
}
}
@@ -146,6 +215,23 @@ fn missing_coa_starts(rows: &str) -> Vec<Problem> {
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn default_repair_only_accepts_missing_literal_defaults_without_other_schema_changes() {
assert_eq!(missing_default("int unsigned|NO|30|<NONE>", "int unsigned|NO|<NULL>|<NONE>"), Some("0".into()));
for actual in ["int unsigned|NO|3939|<NONE>", "int|NO|<NULL>|<NONE>", "int unsigned|YES|<NULL>|<NONE>", "int unsigned|NO|<NULL>|6175746f5f696e6372656d656e74"] {
assert!(missing_default("int unsigned|NO|30|<NONE>", actual).is_none());
}
assert!(missing_default("timestamp|NO|43555252454e545f54494d455354414d50|44454641554c545f47454e455241544544", "timestamp|NO|<NULL>|<NONE>").is_none());
assert!(missing_default("int|NO|zz|<NONE>", "int|NO|<NULL>|<NONE>").is_none());
}
#[test]
fn schema_defaults_are_readable_and_not_conflated() {
assert_eq!(describe_signature("int unsigned|NO|30|<NONE>"), "type=int unsigned, nullable=NO, default=\"0\", extra=none");
assert!(describe_signature("int unsigned|NO|<NULL>|<NONE>").contains("default=no default"));
assert!(describe_signature("varchar(8)|YES||<NONE>").contains("default=\"\""));
assert_eq!(describe_signature("legacy"), "legacy");
}
#[test]
fn a_release_cannot_use_a_partial_or_empty_schema_contract() {
+187
View File
@@ -0,0 +1,187 @@
use std::path::Path;
use serde::{Deserialize, Serialize};
#[derive(Debug, Serialize, PartialEq, Eq)]
pub struct Release {
pub tag: Option<String>,
pub commit: Option<String>,
}
pub fn imported_repack(root: &Path) -> bool {
root.join("CoA-Bots/release.json").is_file()
}
pub fn release(root: &Path) -> Option<Release> {
for name in ["Extras/SquidPlayerbots/release.json", "Core/configs/modules/playerbots.conf.settings.json", "CoA-Bots/release.json"] {
let Ok(bytes) = std::fs::read(root.join(name)) else { continue; };
if bytes.len() > 1024 * 1024 { continue; }
let Ok(json) = serde_json::from_slice::<serde_json::Value>(&bytes) else { continue; };
let safe = |key: &str| json.get(key).and_then(|value| value.as_str())
.filter(|value| !value.is_empty() && value.len() <= 80 && value.chars().all(|c| c.is_ascii_alphanumeric() || "._-".contains(c))).map(str::to_owned);
let tag = safe("tag").or_else(|| safe("version"));
let revision = if name == "CoA-Bots/release.json" {
json.get("botsModuleRevision").and_then(|value| value.as_str()).and_then(|value| value.split_whitespace().next()).map(str::to_owned).or_else(|| safe("commit"))
} else if name.ends_with(".settings.json") { None } else { safe("commit") };
let commit = revision.filter(|value| value.len() >= 7 && value.len() <= 40 && value.chars().all(|c| c.is_ascii_hexdigit()));
if tag.is_some() || commit.is_some() { return Some(Release { tag, commit }); }
}
None
}
#[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
pub struct Field {
pub key: String,
#[serde(rename = "type")]
pub kind: String,
pub title: String,
pub description: String,
#[serde(default)]
pub group: String,
#[serde(default)]
pub group_title: Option<String>,
pub default: serde_json::Value,
#[serde(default)]
pub default_if_missing: Option<serde_json::Value>,
pub min: Option<f64>,
pub max: Option<f64>,
/// A fixed list of allowed values with their labels (SQUID 1.9+); the editor shows it as a drop-down.
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub choices: Vec<Choice>,
}
#[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
pub struct Choice {
pub value: serde_json::Value,
pub label: String,
}
#[derive(Deserialize)]
struct Settings {
format: u32,
settings: Vec<serde_json::Value>,
#[serde(default)]
groups: std::collections::BTreeMap<String, String>,
}
pub fn fields(root: &Path) -> crate::Result<std::collections::BTreeMap<String, Field>> {
let path = root.join("Core/configs/modules/playerbots.conf.settings.json");
if !path.is_file() { return Ok(Default::default()); }
let Ok(bytes) = std::fs::read(path) else { return Ok(Default::default()); };
if bytes.len() > 1024 * 1024 { return Ok(Default::default()); }
let Ok(settings) = serde_json::from_slice::<Settings>(&bytes) else { return Ok(Default::default()); };
if settings.format != 1 { return Ok(Default::default()); }
let mut fields = std::collections::BTreeMap::new();
for value in settings.settings {
let Ok(mut field) = serde_json::from_value::<Field>(value) else { continue; };
field.group_title = settings.groups.get(&field.group).cloned();
if !matches!(field.kind.as_str(), "bool" | "int" | "float" | "string")
|| field.key.len() > 200 || field.key.is_empty()
|| !field.key.chars().all(|c| c.is_ascii_alphanumeric() || "._".contains(c))
|| field.min.zip(field.max).is_some_and(|(min,max)| min > max)
|| !default_type(&field.kind, &field.default)
|| field.default_if_missing.as_ref().is_some_and(|value| !default_type(&field.kind, value))
|| !valid_choices(&field)
|| fields.contains_key(&field.key) { continue; }
fields.insert(field.key.clone(), field);
}
Ok(fields)
}
/// A list of choices must be small, labelled, free of repeats and made of values of the field's own type.
fn valid_choices(field: &Field) -> bool {
field.choices.len() <= 64
&& field.choices.iter().all(|c| !c.label.trim().is_empty() && c.label.len() <= 80 && default_type(&field.kind, &c.value))
&& field.choices.iter().enumerate().all(|(i, c)| field.choices[..i].iter().all(|earlier| scalar(&earlier.value) != scalar(&c.value)))
}
fn default_type(kind: &str, value: &serde_json::Value) -> bool {
match kind {
"bool" => value.is_boolean(),
"int" => value.is_i64() || value.is_u64(),
"float" => value.is_number(),
"string" => value.is_string(),
_ => false,
}
}
pub fn scalar(value: &serde_json::Value) -> Option<String> {
match value {
serde_json::Value::Bool(value) => Some(if *value { "1" } else { "0" }.into()),
serde_json::Value::String(value) => Some(value.clone()),
serde_json::Value::Number(value) => Some(value.to_string()),
_ => None,
}
}
pub fn validate(field: &Field, value: &str) -> crate::Result<()> {
let valid = match field.kind.as_str() {
"bool" => matches!(value, "0" | "1"),
"int" | "float" => value.parse::<f64>().is_ok_and(|number| number.is_finite()
&& (field.kind != "int" || number.fract() == 0.0)
&& field.min.is_none_or(|min| number >= min) && field.max.is_none_or(|max| number <= max)),
"string" => true,
_ => false,
} && (field.choices.is_empty() || field.choices.iter().any(|c| scalar(&c.value).as_deref() == Some(value)));
if valid { Ok(()) } else { Err(crate::Error::Invalid(format!("{} must match its documented SquidBots type and range.", field.key))) }
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_setting_with_choices_only_accepts_one_of_them() {
let root = tempfile::tempdir().unwrap();
crate::fsx::atomic_write(&root.path().join("Core/configs/modules/playerbots.conf.settings.json"), br#"{"format":1,"settings":[
{"key":"AiPlayerbot.BotTextLocale","type":"int","group":"chat","title":"Language","description":"x","default":-1,"min":-1,"max":8,
"choices":[{"value":-1,"label":"Auto"},{"value":0,"label":"English"},{"value":8,"label":"Russian"}]},
{"key":"AiPlayerbot.Broken","type":"int","group":"chat","title":"b","description":"x","default":0,"choices":[{"value":"a","label":"wrong type"}]}]}"#).unwrap();
let fields = fields(root.path()).unwrap();
let locale = &fields["AiPlayerbot.BotTextLocale"];
assert_eq!(locale.choices.len(), 3);
for ok in ["-1", "0", "8"] { assert!(validate(locale, ok).is_ok(), "{ok}"); }
for bad in ["1", "7", "x"] { assert!(validate(locale, bad).is_err(), "{bad}"); }
assert!(!fields.contains_key("AiPlayerbot.Broken"), "a choice of the wrong type invalidates the setting");
}
#[test]
fn upstream_settings_preserve_types_ranges_and_distinct_defaults() {
let root = tempfile::tempdir().unwrap();
crate::fsx::atomic_write(&root.path().join("Core/configs/modules/playerbots.conf.settings.json"), br#"{"format":1,"settings":[{"key":"AiPlayerbot.MinRandomBots","type":"int","group":"population","title":"Minimum bots","description":"Lower bound","default":500,"default_if_missing":50,"min":0,"max":5000}]}"#).unwrap();
let fields = fields(root.path()).unwrap();
let field = &fields["AiPlayerbot.MinRandomBots"];
assert_eq!(scalar(&field.default).as_deref(), Some("500"));
assert_eq!(scalar(field.default_if_missing.as_ref().unwrap()).as_deref(), Some("50"));
assert!(validate(field, "5000").is_ok());
for value in ["5001", "-1", "0.5", "NaN"] { assert!(validate(field, value).is_err()); }
}
#[test]
fn unsupported_metadata_falls_back_and_bad_entries_do_not_hide_valid_fields() {
let root = tempfile::tempdir().unwrap();
let path = root.path().join("Core/configs/modules/playerbots.conf.settings.json");
for data in [r#"{"format":99,"settings":[]}"#, "invalid json", r#"{"format":1,"settings":{}}"#] {
crate::fsx::atomic_write(&path, data.as_bytes()).unwrap();
assert!(fields(root.path()).unwrap().is_empty());
}
crate::fsx::atomic_write(&path, br#"{"format":1,"settings":[{"key":"Broken","type":"enum","title":"Broken","description":"Unknown type","default":1},{"key":"Malformed"},{"key":"WrongDefault","type":"int","title":"Wrong","description":"Bad default","default":"oops"},{"key":"Good","type":"bool","title":"Good","description":"Good field","default":true}]}"#).unwrap();
let parsed = fields(root.path()).unwrap();
assert_eq!(parsed.len(), 1);
assert!(parsed.contains_key("Good"));
}
#[test]
fn imported_revision_uses_its_first_word_and_empty_tags_are_hidden() {
let root = tempfile::tempdir().unwrap();
crate::fsx::atomic_write(&root.path().join("CoA-Bots/release.json"), br#"{"tag":"","botsModuleRevision":"48c4786a 2026-10-01 (coa branch)","commit":"abcdef01"}"#).unwrap();
assert_eq!(release(root.path()).unwrap(), Release { tag: None, commit: Some("48c4786a".into()) });
crate::fsx::atomic_write(&root.path().join("Core/configs/modules/playerbots.conf.settings.json"), br#"{"tag":"v1.8.1","commit":"11111111"}"#).unwrap();
assert_eq!(release(root.path()).unwrap(), Release { tag: Some("v1.8.1".into()), commit: None });
}
#[test]
fn diagnostics_only_expose_release_identifiers() {
let root = tempfile::tempdir().unwrap();
crate::fsx::atomic_write(&root.path().join("CoA-Bots/release.json"), br#"{"tag":"v1.8","commit":"48c4786a","password":"secret"}"#).unwrap();
assert!(imported_repack(root.path()));
assert_eq!(release(root.path()).unwrap(), Release { tag: Some("v1.8".into()), commit: Some("48c4786a".into()) });
}
}
Loaded 100 of 157 files, more files were not shown because too many files have changed in this diff. Show more