Compare commits

...
Author SHA1 Message Date
ДмитрийandClaude Opus 5.5 2e6fcceb05 CI: drop the launcher bridge test (the bridge was removed)
tools/test_launcher_bridge.py tested crates/coa-core/src/launcher_bridge.py,
which the Rust launcher replaced; check.yml and release.yml still ran it, so
the release build failed.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 16:48:17 +05:00
ДмитрийandClaude Opus 5.5 abcc816581 Stop: ask the world again when a shutdown request is lost
A console shutdown request is sometimes lost, and the world then keeps
running until the stop times out. While the world still runs and its
console still answers after 15 s, the launcher asks again (twice at most);
asking twice is harmless. Verified on a disposable repack with the first
World::ShutdownServ call suppressed in a debugger: the second request
stopped the world.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 16:07:54 +05:00
ДмитрийandClaude Opus 5.5 8353b791fb The Manager no longer edits Scripts/manage.py
Repacks ship no .bat files, and the Manager starts servers with
coa-core::launcher, so the realm-profile patch it wrote into manage.py
served no one. It is no longer applied (realm creation, realm switching and
start).

Recognising the edits older Managers made (realm patch, bridge import fix)
moves into legacy_launcher, so updates and file checks still treat such a
file as unmodified. Nothing there writes a file.

manage.py itself stays complete in the repack: Managers up to 0.9.10 run it
through their bridge and patch its text, so it cannot become a thin wrapper
until those Managers are no longer supported.

Verified: coa-core unit tests; examples/manager_launcher_e2e on a disposable
repack (manage.py unchanged after a start with a realm profile).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 13:07:41 +05:00
ДмитрийandClaude Opus 5.5 b81227b0ea Bug-report relay in Rust (coa-launcher relay-worker)
launcher::relay does what BugReport/relay.py and manage.py relay-worker do,
with the same spool: the <key>.status files the world reads, the journal
relay.sqlite3 (deliveries, settings), relay.lock (byte 0) and the
relay-ready record. Service answers map to the same states and retry times;
a post interrupted mid-flight stays uncertain and is never resent.

When coa-launcher.exe supervises a world it runs the relay itself; the
Python supervisor still runs relay.py.

Verified:
- examples/relay_equivalence: the same reports and scripted service answers
  through relay.py and the Rust relay give identical statuses, journal rows
  (including retry times) and posts, and each continues the other's journal.
- examples/manager_launcher_e2e on a disposable repack: supervisor and relay
  are coa-launcher.exe, start/stop interoperates with manage.py.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 12:00:40 +05:00
ДмитрийandClaude Opus 5.5 a9fb982ab0 Console shutdown request reads the reply before closing
send_without_answer closed the socket right after writing "server shutdown".
With the reply still unread, Windows resets the connection, and the world
can drop the command: a world supervised by coa-launcher.exe ignored the
shutdown and the stop timed out after 90 seconds. The reply is now read up
to the next prompt, the end of the connection or 10 seconds.

The E2E also checks which supervisor runs the world and that manage.py
stops a world the Manager started.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 09:38:59 +05:00
ДмитрийandClaude Opus 5.5 a822bfc99b Manager starts and stops servers through the Rust launcher
driver::run now calls coa-core::launcher::ops::run in-process instead of
running Scripts/manage.py through launcher_bridge.py. Failures carry a typed
code (Error::Service) instead of being guessed from stderr text.

Moved into the launcher: realm profiles (realm id, name and databases from
Settings/realm-profile.json), extra worlds sharing the main database,
the shared world startup deadline and console readiness check, the owned-world
check on shutdown, force-stop-all, and an environment block without
AC_REALM_SERVER_PORT for update validation.

The world supervisor is Scripts/coa-launcher.exe when the repack ships it,
otherwise manage.py watch-world. Extra worlds get an unmodified manage.py.
The realm patch of manage.py stays for the repack's own .bat files.

Verified with examples/manager_launcher_e2e on a disposable repack.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 08:45:08 +05:00
ДмитрийandClaude Opus 5.5 1211de5a77 launcher (Rust): services inherit only their log and NUL; MySQL errors carry the server's text
std::process::Command lets a Windows child inherit every inheritable handle of the parent: a
MySQL started by the launcher kept the caller's files and pipes open (found by the SQUID test,
whose log stayed locked). Services now start through CreateProcessW with
PROC_THREAD_ATTRIBUTE_HANDLE_LIST = [log, NUL], as Python's subprocess does. The MySQL client's
outputs are read while it runs (a full pipe stopped it) and its last error line is reported.

E2E on a disposable repack: launcher_e2e PASS again; squid_equivalence PASS: Rust and
squid_playerbots.py leave identical journals, acore_playerbots tables (row counts) and
playerbots.conf (4106 lines), and a second run of either changes nothing.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 07:48:04 +05:00
ДмитрийandClaude Opus 5.5 ee36692db7 launcher (Rust): services, world supervisor, SQUID provisioning, coa-launcher.exe
- services: exclusive-bind port check, readiness by listener row or the server side of a
  loopback connection, MySQL client, start MySQL/auth, stop-all (world through its console,
  database last), status.
- world: start-world through a supervisor process (coa-launcher watch-world) that keeps the
  bug-report relay (still BugReport/relay.py via the repack's Python) alive; detailed logging.
- squid: squid_playerbots.py in Rust with the same journals (coa_squid_migrations,
  coa_squid_pending, coa_bots_installed).
- coa-launcher.exe: the manage.py commands and error texts (the Manager reads them).
- Services no longer inherit the launcher's stdin/stdout/stderr: a server holding the
  output pipe kept whoever read the launcher's output waiting.

E2E (examples/launcher_e2e, disposable stable repack on free ports): coa-launcher start-all ->
manage.py sees and stops it; manage.py start-all -> coa-launcher sees and stops it; a second
Rust-only cycle leaves nothing running.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 07:29:55 +05:00
ДмитрийandClaude Opus 5.5 ee43522019 launcher (Rust): settings, state records, control lock, prepare
First part of moving Scripts/manage.py into coa-core (plan §17, PY-1). Same formats on disk as
manage.py so both can run on one server: .state records, the byte-0 control lock msvcrt.locking
takes, configuration.json. prepare renders byte-for-byte what manage.py renders (checked against
the real script, COA_MANAGE_PY). State files are flushed to disk before they replace the old ones,
and a damaged record counts as no process instead of failing every later start.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 06:58:16 +05:00
github-actions[bot] b4dc30b84a Update published Manager changelog 2026-11-08 10:21:07 +00:00
Дмитрий 73a6cca753 Integrate the qualified November release sources [skip ci] 2026-11-08 15:09:20 +05:00
Corfirean 705bee7d56 Merge verified Custom Races download recovery [skip ci]
Recover interrupted Custom Races patch downloads
2026-11-08 01:44:09 +05:00
Corfirean 5aa9b32283 Merge release cold-cache preparation fix [skip ci]
release: build the frontend before the tests
2026-11-08 01:44:05 +05:00
Дмитрий 711f378ae8 Bind translated release notes to the exact candidate sources [skip ci] 2026-11-08 01:23:56 +05:00
Corfirean c29d56e2b3 Register local installer preparation workflow [skip ci] 2026-11-08 01:21:16 +05:00
Дмитрий d63e85bb18 Prepare Manager 0.9.10 with reviewed notes and signing of local installers [skip ci] 2026-11-08 01:20:32 +05:00
Дмитрий c513649beb Merge remote-tracking branch 'origin/fix/recover-client-patch-downloads' into release/20261108-manager 2026-11-08 01:09:43 +05:00
ДмитрийandClaude Opus 5.5 2224afd2ea release: build the frontend before the tests
tauri::generate_context! needs ../dist. The tests run before tauri-action builds the frontend, so a
run without a warm target cache cannot compile the app (seen on preview/modules-v2, run 42224568581).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-06 19:47:11 +05:00
github-actions[bot] 3a5558f388 Update published Manager changelog 2026-11-04 11:39:56 +00:00
Дмитрий 173248efbe Prepare Manager 0.9.9 with isolated login validation and translated release notes 2026-11-03 19:44:03 +05:00
Дмитрий 5697a1d36e Merge commit '076fba1' into release/20261103-manager 2026-11-03 19:41:07 +05:00
github-actions[bot] bc62ae206f Update published Manager changelog 2026-11-01 11:00:31 +00:00
Дмитрий 1a1976d9ad Recover interrupted Custom Races patch downloads 2026-10-31 07:55:15 +05:00
45 changed files with 4489 additions and 1017 deletions

No files matched your search

-1
View File
@@ -26,5 +26,4 @@ jobs:
- run: node tools/check-i18n.mjs
- run: npm run build
- run: node --experimental-strip-types --test tools/*.test.mjs
- run: python -B -m unittest discover -s tools -p test_launcher_bridge.py
- run: cargo test --workspace --locked
+2 -1
View File
@@ -69,10 +69,11 @@ jobs:
with:
node-version: 22
- run: npm ci
# tauri::generate_context! needs ../dist; without a warm target cache the tests do not compile without it.
- run: npm run build
- name: Tests
run: cargo test --workspace --locked -- --test-threads=1
- run: node --experimental-strip-types --test tools/*.test.mjs
- run: python -B -m unittest discover -s tools -p test_launcher_bridge.py
- name: Build and sign (publish only when requested)
id: tauri
uses: tauri-apps/tauri-action@v0
@@ -0,0 +1,72 @@
name: sign-local-installer
on:
push:
branches: [release/20261108-manager]
workflow_dispatch:
inputs:
build_run_id:
description: Successful manager-local run in coa-server-build
required: true
permissions:
contents: read
actions: read
jobs:
sign:
if: github.event_name == 'workflow_dispatch'
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v7
- uses: actions/setup-node@v4
with:
node-version: 22
- name: Verify local build provenance
env:
GH_TOKEN: ${{ github.token }}
BUILD_RUN: ${{ inputs.build_run_id }}
run: |
python3 - <<'PY'
import json, os, subprocess
run = os.environ['BUILD_RUN']
if not run.isdigit():
raise RuntimeError('Invalid build run')
data = json.loads(subprocess.check_output(['gh', 'api', f'repos/Corfirean/coa-server-build/actions/runs/{run}']))
if data['conclusion'] != 'success' or data['path'] != '.github/workflows/manager-local.yml':
raise RuntimeError('Not a successful local Manager build')
subprocess.run(['gh', 'run', 'download', run, '-R', 'Corfirean/coa-server-build', '-n', 'unsigned-manager-windows', '-D', '_prepared-manager'], check=True)
from pathlib import Path
import hashlib
root = Path('_prepared-manager')
meta = json.loads((root / 'prepared-source.json').read_text())
version = json.loads(Path('package.json').read_text())['version']
name = meta['installer']
if Path(name).name != name or meta['source'] != os.environ['GITHUB_SHA'] or meta['version'] != version or str(meta['run']) != run:
raise RuntimeError('Installer identity differs')
if hashlib.sha256((root / name).read_bytes()).hexdigest() != meta['sha256']:
raise RuntimeError('Installer hash differs')
PY
- run: npm ci
- name: Sign exact locally compiled bytes
env:
TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY }}
TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY_PASSWORD }}
run: |
node --input-type=module <<'JS'
import { readFileSync, writeFileSync } from 'node:fs';
import { execFileSync } from 'node:child_process';
import { createHash } from 'node:crypto';
const root = '_prepared-manager/';
const meta = JSON.parse(readFileSync(root + 'prepared-source.json'));
execFileSync('node_modules/.bin/tauri', ['signer', 'sign', '--app-version', meta.version, root + meta.installer], {stdio: 'inherit'});
if (createHash('sha256').update(readFileSync(root + meta.installer)).digest('hex') !== meta.sha256) throw new Error('Signed bytes changed');
const signature = readFileSync(root + meta.installer + '.sig', 'utf8').trim();
const url = `https://github.com/Corfirean/coa-server-manager/releases/download/v${meta.version}/${encodeURIComponent(meta.installer)}`;
writeFileSync(root + 'latest.json', JSON.stringify({version: meta.version, notes: 'See the release notes.', pub_date: new Date().toISOString(), platforms: {'windows-x86_64': {signature, url}}}, null, 2) + '\n');
meta.signingRun = process.env.GITHUB_RUN_ID;
writeFileSync(root + 'prepared-source.json', JSON.stringify(meta, null, 2) + '\n');
JS
- uses: actions/upload-artifact@v4
with:
name: prepared-manager-windows
path: _prepared-manager/*
retention-days: 14
if-no-files-found: error
+22
View File
@@ -8,6 +8,28 @@ Published releases and previews. Pre-release entries do not change the stable up
Dates follow GitHub publication (UTC); legacy records retain their archived dates. Newest releases first.
## 0.9.10 — 2026-11-08
- Custom Races patch installation recovers from interrupted downloads.
[Release](https://github.com/Corfirean/coa-server-manager/releases/tag/v0.9.10) · [Source changes](https://github.com/Corfirean/coa-server-manager/compare/v0.9.9...v0.9.10)
## 0.9.9 — 2026-11-04
- Update and recovery checks use the temporary login port even with a Windows override.
[Release](https://github.com/Corfirean/coa-server-manager/releases/tag/v0.9.9) · [Source changes](https://github.com/Corfirean/coa-server-manager/compare/v0.9.8...v0.9.9)
## 0.9.8 — 2026-11-01
- Dungeon Clear can be enabled when SQUID bots are active.
- Diagnostic exports include launcher stages and lock owner records.
- Choose normal logs, errors only or no server logs in maintenance settings.
- Update checks temporarily suspend bot population and restore your configuration.
- Update validation keeps MySQL running between compatible checks.
[Release](https://github.com/Corfirean/coa-server-manager/releases/tag/v0.9.8) · [Source changes](https://github.com/Corfirean/coa-server-manager/compare/v0.9.7...v0.9.8)
## 0.9.7 — 2026-10-30
- Show available update notes even when release history is cached.
Generated
+13 -3
View File
@@ -586,7 +586,7 @@ dependencies = [
[[package]]
name = "coa-core"
version = "0.9.8"
version = "0.9.10"
dependencies = [
"base64 0.22.1",
"chrono",
@@ -606,6 +606,7 @@ dependencies = [
"serde_json",
"sha1",
"sha2",
"socket2",
"tar",
"tempfile",
"thiserror 2.0.21",
@@ -618,6 +619,15 @@ dependencies = [
"zstd",
]
[[package]]
name = "coa-launcher"
version = "0.9.10"
dependencies = [
"coa-core",
"serde_json",
"windows-sys 0.60.2",
]
[[package]]
name = "coa-registry-proto"
version = "0.1.0"
@@ -634,7 +644,7 @@ dependencies = [
[[package]]
name = "coa-release"
version = "0.9.8"
version = "0.9.10"
dependencies = [
"chrono",
"coa-core",
@@ -643,7 +653,7 @@ dependencies = [
[[package]]
name = "coa-server-manager"
version = "0.9.8"
version = "0.9.10"
dependencies = [
"coa-control-proto",
"coa-core",
+2 -2
View File
@@ -1,10 +1,10 @@
[workspace]
resolver = "2"
members = ["crates/coa-core", "crates/coa-release", "crates/coa-registry-proto", "crates/coa-control-proto", "src-tauri"]
members = ["crates/coa-core", "crates/coa-launcher", "crates/coa-release", "crates/coa-registry-proto", "crates/coa-control-proto", "src-tauri"]
exclude = ["services/coa-registry", "services/coa-registry-e2e", "services/coa-coordinator", "services/coa-relay"]
[workspace.package]
version = "0.9.8"
version = "0.9.10"
edition = "2021"
license = "AGPL-3.0-only"
@@ -0,0 +1,7 @@
---
area: manager
type: fixed
audience: admins
title: Custom Races patch installation recovers from interrupted downloads
---
Unfinished downloads resume automatically. Invalid archives in Downloads are skipped without changing them, and damaged cached archives are downloaded again.
@@ -0,0 +1,6 @@
---
area: manager
type: fixed
audience: admins
title: Update and recovery checks use the temporary login port even with a Windows override
---
+45 -1
View File
@@ -169,7 +169,14 @@
"Corfirean/coa-server-manager:20261030-stop-does-not-trigger-auto-restart.md",
"Corfirean/coa-server-manager:20261030-update-history-target-cache.md",
"Corfirean/coa-server-manager:20261030-wait-for-world-console-readiness.md",
"Corfirean/coa-server-manager:20261030-window-lifecycle.md"
"Corfirean/coa-server-manager:20261030-window-lifecycle.md",
"Corfirean/coa-server-manager:20261031-dungeon-clear-dependency.md",
"Corfirean/coa-server-manager:20261031-launcher-diagnostics-export.md",
"Corfirean/coa-server-manager:20261031-recover-client-patch-downloads.md",
"Corfirean/coa-server-manager:20261031-server-logging-controls.md",
"Corfirean/coa-server-manager:20261031-validation-bot-population.md",
"Corfirean/coa-server-manager:20261031-validation-mysql-reuse.md",
"Corfirean/coa-server-manager:20261103-isolated-login-port.md"
],
"releases": [
{
@@ -868,6 +875,43 @@
],
"commit": "ba5816e3aea471d5b870e5f0db0b03920c071ed3",
"compare": "https://github.com/Corfirean/coa-server-manager/compare/v0.9.5...v0.9.7"
},
{
"tag": "v0.9.8",
"version": "0.9.8",
"date": "2026-11-01",
"url": "https://github.com/Corfirean/coa-server-manager/releases/tag/v0.9.8",
"notes": [
"Dungeon Clear can be enabled when SQUID bots are active",
"Diagnostic exports include launcher stages and lock owner records",
"Choose normal logs, errors only or no server logs in maintenance settings",
"Update checks temporarily suspend bot population and restore your configuration",
"Update validation keeps MySQL running between compatible checks"
],
"commit": "076fba185c4d96d74f7258d6ca0cae6a4ae4a613",
"compare": "https://github.com/Corfirean/coa-server-manager/compare/v0.9.7...v0.9.8"
},
{
"tag": "v0.9.9",
"version": "0.9.9",
"date": "2026-11-04",
"url": "https://github.com/Corfirean/coa-server-manager/releases/tag/v0.9.9",
"notes": [
"Update and recovery checks use the temporary login port even with a Windows override"
],
"commit": "173248efbe24da9b4c1b5ca12fa7580fcd1e8ea7",
"compare": "https://github.com/Corfirean/coa-server-manager/compare/v0.9.8...v0.9.9"
},
{
"tag": "v0.9.10",
"version": "0.9.10",
"date": "2026-11-08",
"url": "https://github.com/Corfirean/coa-server-manager/releases/tag/v0.9.10",
"notes": [
"Custom Races patch installation recovers from interrupted downloads"
],
"commit": "711f378ae82f75d3fc64368c042889c773315c54",
"compare": "https://github.com/Corfirean/coa-server-manager/compare/v0.9.9...v0.9.10"
}
]
}
+2 -1
View File
@@ -5,6 +5,7 @@ edition.workspace = true
license.workspace = true
[dependencies]
socket2 = "0.6"
serde = { version = "1", features = ["derive"] }
serde_json = "1"
sha2 = "0.10"
@@ -37,7 +38,7 @@ 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_Storage_FileSystem", "Win32_System_Threading", "Win32_System_SystemInformation", "Win32_System_Diagnostics_ToolHelp", "Win32_NetworkManagement_IpHelper", "Win32_Networking_WinSock", "Win32_Security_Cryptography", "Win32_UI_Shell", "Win32_System_Registry", "Win32_UI_WindowsAndMessaging"] }
windows-sys = { version = "0.60", features = ["Win32_Foundation", "Win32_Storage_FileSystem", "Win32_System_Threading", "Win32_System_Console", "Win32_System_SystemInformation", "Win32_System_Diagnostics_ToolHelp", "Win32_NetworkManagement_IpHelper", "Win32_Networking_WinSock", "Win32_Security_Cryptography", "Win32_UI_Shell", "Win32_System_Registry", "Win32_UI_WindowsAndMessaging"] }
[features]
testkit = []
+114
View File
@@ -0,0 +1,114 @@
//! The Rust launcher on a DISPOSABLE repack, side by side with Scripts/manage.py:
//!
//! 1. install the stable server into a new folder on unused ports;
//! 2. coa-launcher start-all, then manage.py status-json must see every service;
//! 3. manage.py stop-all stops what coa-launcher started;
//! 4. manage.py start-all, coa-launcher status-json sees it, coa-launcher stop-all stops it;
//! 5. both stop-alls leave nothing of the repack running.
//!
//! usage: launcher_e2e <new folder ending in -fixture> <coa-launcher.exe>
use std::path::Path;
use std::process::Command;
use coa_core::install::{install_base, Params};
use coa_core::registry::Registry;
fn free_port() -> u16 {
std::net::TcpListener::bind("127.0.0.1:0").unwrap().local_addr().unwrap().port()
}
fn run(exe: &Path, args: &[&str]) -> (bool, String) {
let out = Command::new(exe).args(args).output().unwrap();
let text = String::from_utf8_lossy(&out.stdout).into_owned() + &String::from_utf8_lossy(&out.stderr);
(out.status.success(), text)
}
fn launcher(root: &Path, exe: &Path, action: &str) -> (bool, String) {
let r = root.to_string_lossy().into_owned();
let t = std::time::Instant::now();
let out = run(exe, &["--root", &r, action]);
println!("[coa-launcher {action}] ok={} in {:?}\n{}", out.0, t.elapsed(), indent(&out.1));
out
}
fn manage(root: &Path, action: &str) -> (bool, String) {
let python = root.join("Runtime/python/python.exe");
let script = root.join("Scripts/manage.py").to_string_lossy().into_owned();
let t = std::time::Instant::now();
let out = run(&python, &["-B", &script, action]);
println!("[manage.py {action}] ok={} in {:?}\n{}", out.0, t.elapsed(), indent(&out.1));
out
}
fn indent(s: &str) -> String {
s.lines().map(|l| format!(" {l}")).collect::<Vec<_>>().join("\n")
}
fn status(out: &str) -> serde_json::Value {
let line = out.lines().rev().find(|l| l.trim_start().starts_with('{')).expect("a JSON status line");
serde_json::from_str(line).unwrap()
}
fn all(v: &serde_json::Value, running: bool) -> bool {
["mysql", "auth", "world", "relay"].iter().all(|k| v[*k] == running)
}
fn main() {
let a: Vec<String> = std::env::args().skip(1).collect();
let root = Path::new(&a[0]);
let exe = Path::new(&a[1]);
assert!(a[0].ends_with("-fixture"), "a folder ending in -fixture is required");
if root.join("Core/worldserver.exe").is_file() {
println!("reusing the installed fixture");
} else {
install(root);
}
test(root, exe);
}
fn install(root: &Path) {
assert!(!root.exists(), "a new folder is required");
let reg_dir = std::env::temp_dir().join("coa-launcher-e2e-registry");
let _ = std::fs::remove_dir_all(&reg_dir);
let reg = Registry::at(reg_dir.join("installs.json"));
// what the Manager installs: the stable release's installation image
let image = coa_core::install::Source::Installation(Box::new(coa_core::channels::resolve("stable").expect("stable channel")));
let installed = install_base(
&Params { source: image, dest: root.into(), trusted_key: coa_core::signing::EMBEDDED_PUBLIC_KEY, registry: &reg, cancel: Default::default() },
&|s| eprintln!(" {:>3}% {}", s.percent, s.step),
)
.expect("install");
println!("installed {}", installed.version);
let repack = root.join("Settings/repack.json");
let mut cfg: serde_json::Value = serde_json::from_slice(&std::fs::read(&repack).unwrap()).unwrap();
for k in ["mysqlPort", "authPort", "worldPort", "raPort"] {
cfg[k] = free_port().into();
}
std::fs::write(&repack, serde_json::to_vec_pretty(&cfg).unwrap()).unwrap();
}
fn test(root: &Path, exe: &Path) {
// 2. Rust starts, Python sees it
assert!(launcher(root, exe, "start-all").0, "coa-launcher start-all");
let seen = status(&manage(root, "status-json").1);
assert!(all(&seen, true), "manage.py must see the services coa-launcher started: {seen}");
// 3. Python stops what Rust started
assert!(manage(root, "stop-all").0, "manage.py stop-all");
assert!(all(&status(&launcher(root, exe, "status-json").1), false));
// 4. Python starts, Rust sees and stops it
assert!(manage(root, "start-all").0, "manage.py start-all");
let seen = status(&launcher(root, exe, "status-json").1);
assert!(all(&seen, true), "coa-launcher must see the services manage.py started: {seen}");
assert!(launcher(root, exe, "stop-all").0, "coa-launcher stop-all");
assert!(all(&status(&manage(root, "status-json").1), false));
// 5. Rust alone, a second time (start on a server it stopped)
assert!(launcher(root, exe, "start-all").0);
assert!(launcher(root, exe, "stop-all").0);
let left = coa_core::process::find_by_exe(&root.join("mysql/bin/mysqld.exe")).len()
+ coa_core::process::find_by_exe(&root.join("Core/worldserver.exe")).len()
+ coa_core::process::find_by_exe(&root.join("Core/authserver.exe")).len();
assert_eq!(left, 0, "nothing of the repack may be left running");
println!("LAUNCHER E2E PASS");
}
@@ -0,0 +1,149 @@
//! The Manager's start/stop (`driver`) on the Rust launcher, on a DISPOSABLE repack:
//!
//! 1. driver start-all: every service runs, the console answers, manage.py is not touched and sees the services;
//! 2. driver stop-all stops everything;
//! 3. manage.py start-all, then driver stop-all stops what Python started;
//! 4. a taken world port fails with the typed "port in use" code (no stderr parsing), then stop-all;
//! 5. driver start-all, then the forced stop;
//! 6. with a realm profile: the realm row gets the profile's name, manage.py is still not edited;
//! 7. nothing of the repack is left running.
//!
//! usage: manager_launcher_e2e <existing folder ending in -fixture>
use std::path::Path;
use std::process::Command;
use std::time::Instant;
use coa_core::driver::{self, Verb};
use coa_core::error::ErrorCode;
use coa_core::launcher::{services, settings::Settings, state};
fn indent(s: &str) -> String {
s.lines().map(|l| format!(" {l}")).collect::<Vec<_>>().join("\n")
}
fn drive(root: &Path, verb: Verb) -> driver::DriverOutcome {
let t = Instant::now();
let out = driver::run(root, verb).expect("driver");
println!("[driver {verb:?}] ok={} code={:?} in {:?}\n{}", out.ok, out.code, t.elapsed(), indent(&out.output));
out
}
fn manage(root: &Path, action: &str) -> (bool, String) {
let python = root.join("Runtime/python/python.exe");
let script = root.join("Scripts/manage.py").to_string_lossy().into_owned();
let t = Instant::now();
let out = Command::new(python).args(["-B", &script, action]).output().unwrap();
let text = String::from_utf8_lossy(&out.stdout).into_owned() + &String::from_utf8_lossy(&out.stderr);
println!("[manage.py {action}] ok={} in {:?}\n{}", out.status.success(), t.elapsed(), indent(&text));
(out.status.success(), text)
}
fn python_status(root: &Path) -> serde_json::Value {
let (ok, out) = manage(root, "status-json");
assert!(ok);
let line = out.lines().rev().find(|l| l.trim_start().starts_with('{')).expect("a JSON status line");
serde_json::from_str(line).unwrap()
}
fn all(v: &serde_json::Value, running: bool) -> bool {
["mysql", "auth", "world", "relay"].iter().all(|k| v[*k] == running)
}
fn nothing_running(root: &Path) -> bool {
["mysql", "auth", "world", "supervisor", "relay"].iter().all(|n| state::running(root, n).is_none())
&& ["mysql/bin/mysqld.exe", "Core/authserver.exe", "Core/worldserver.exe"]
.iter()
.all(|exe| coa_core::process::find_by_exe(&root.join(exe)).is_empty())
}
fn console(root: &Path) -> String {
let cfg = Settings::load(root, 0).unwrap();
let mut ra = coa_core::ra::Ra::connect_to(cfg.ra_port, &cfg.ra_username, &cfg.ra_password).unwrap();
ra.run("server info").unwrap()
}
fn realm_name(root: &Path) -> String {
services::mysql(root, Some("SELECT name FROM acore_auth.realmlist WHERE id=1;"), None).unwrap()
}
fn main() {
let a: Vec<String> = std::env::args().skip(1).collect();
let root = Path::new(&a[0]);
assert!(a[0].ends_with("-fixture"), "a folder ending in -fixture is required");
assert!(nothing_running(root), "the fixture must be stopped before the test");
let manage_py = root.join("Scripts/manage.py");
let original = std::fs::read(&manage_py).unwrap();
let profile = root.join("Settings/realm-profile.json");
assert!(!profile.exists(), "the fixture starts without a realm profile");
// 1
let started = drive(root, Verb::StartAll);
assert!(started.ok, "start-all");
assert!(all(&python_status(root), true), "manage.py sees what the Manager started");
let info = console(root);
println!("[console] {}", info.lines().next().unwrap_or(""));
assert_eq!(std::fs::read(&manage_py).unwrap(), original, "manage.py is not rewritten");
assert_eq!(realm_name(root), "AzerothCore", "no profile: the launcher's own realm name");
let shipped = root.join("Scripts/coa-launcher.exe");
let supervisor = state::running(root, "supervisor").expect("a supervisor");
println!("[supervisor] {}", supervisor.exe);
let expected = if shipped.is_file() { "coa-launcher.exe" } else { "python.exe" };
assert!(supervisor.exe.to_lowercase().ends_with(expected), "the world is supervised by {expected}");
let relay = state::running(root, "relay").expect("a bug-report relay");
println!("[relay] {}", relay.exe);
assert!(relay.exe.to_lowercase().ends_with(expected), "the relay is run by {expected}");
assert!(state::running(root, "relay-ready").is_some_and(|r| r.pid == relay.pid), "the relay reported ready");
// 2
assert!(drive(root, Verb::StopAll).ok, "stop-all");
assert!(nothing_running(root), "1-2 left something running");
// 2b: the repack's Python launcher stops a world the Manager started
assert!(drive(root, Verb::StartAll).ok);
assert!(manage(root, "stop-all").0, "manage.py stops what the Manager started");
assert!(nothing_running(root), "2b left something running");
// 3
assert!(manage(root, "start-all").0);
assert!(drive(root, Verb::StopAll).ok, "driver stops what manage.py started");
assert!(nothing_running(root), "3 left something running");
// 4
let cfg = Settings::load(root, 0).unwrap();
let blocker = std::net::TcpListener::bind(("127.0.0.1", cfg.world_port)).unwrap();
let refused = drive(root, Verb::StartAll);
assert!(!refused.ok);
assert_eq!(refused.code, Some(ErrorCode::PortInUse), "typed port error");
assert!(refused.output.contains(&format!("Port {}", cfg.world_port)));
drop(blocker);
assert!(drive(root, Verb::StopAll).ok);
assert!(nothing_running(root), "4 left something running");
// 5
assert!(drive(root, Verb::StartAll).ok);
let t = Instant::now();
let forced = driver::force_stop(root).expect("force stop");
println!("[driver force_stop] ok={} in {:?}\n{}", forced.ok, t.elapsed(), indent(&forced.output));
assert!(forced.ok && forced.output.contains("Force-stopped"));
assert!(nothing_running(root), "5 left something running");
// 6
std::fs::write(&profile, br#"{"active":"coa","wildcard_created":false}"#).unwrap();
let result = std::panic::catch_unwind(|| {
assert!(drive(root, Verb::StartAll).ok, "start-all with a realm profile");
assert_eq!(realm_name(root), "Conquest of Azeroth");
assert_eq!(std::fs::read(&manage_py).unwrap(), original, "manage.py is not edited for a realm profile either");
assert!(drive(root, Verb::StopAll).ok);
});
std::fs::remove_file(&profile).unwrap();
std::fs::write(&manage_py, &original).unwrap();
if result.is_err() {
let _ = driver::run(root, Verb::StopAll);
panic!("step 6 failed");
}
// 7
assert!(nothing_running(root), "something of the repack is still running");
println!("PASS: the Manager starts and stops through the Rust launcher, interoperates with manage.py, typed errors");
}
@@ -0,0 +1,170 @@
//! The Rust bug-report relay against the repack's `BugReport/relay.py`, offline (a scripted service, no network):
//!
//! 1. the same reports and the same service answers give the same `.status` files and journal rows;
//! 2. each relay continues the other's journal: what one delivered is never sent again by the other, and a post the
//! other left in progress is uncertain.
//!
//! usage: relay_equivalence <repack folder with Runtime/python and BugReport/relay.py>
use std::path::{Path, PathBuf};
use std::process::Command;
use std::sync::{Arc, Mutex};
use coa_core::launcher::relay::{Failure, Relay, Service};
const REPORTS: [(&str, &str); 5] = [
("1-00000000000000a1", "COABUG1\r\nQuest broken\r\nThe NPC is gone.\r\n"),
("9-00000000000000b2", "COABUG1\nRate limited\nBody text\n"),
("3-00000000000000c3", "COABUG1\nRejected\nBody\n"),
("4-00000000000000d4", "COABUG1\nxy\nTitle too short\n"),
("5-00000000000000e5", "COABUG1\nUnknown outcome\nBody\n"),
];
/// The answers per title, in the vocabulary of both relays.
fn answer(title: &str) -> std::result::Result<u64, Failure> {
match title {
"Quest broken" => Ok(101),
"Rate limited" => Err(Failure::Limited(60)),
"Rejected" => Err(Failure::Invalid),
_ => Err(Failure::Uncertain),
}
}
const PYTHON: &str = r#"
import importlib.util, sys, json
from pathlib import Path
spec = importlib.util.spec_from_file_location("relay", sys.argv[1]); relay = importlib.util.module_from_spec(spec); spec.loader.exec_module(relay)
spool = Path(sys.argv[2]); calls = []
class Fake:
def create(self, title, body):
calls.append(title)
if title == "Quest broken": return 101
if title == "Rate limited": raise relay.DeliveryError("limited", 60)
if title == "Rejected": raise relay.DeliveryError("invalid")
raise relay.DeliveryError("uncertain")
t = [float(sys.argv[3])]
def clock():
t[0] += 3
return t[0]
r = relay.Relay(spool, Fake(), clock=clock)
for path in sorted(spool.glob("*.report")):
r.process(path)
r.close()
print(json.dumps(calls))
"#;
struct Scripted(Arc<Mutex<Vec<String>>>);
impl Service for Scripted {
fn create(&self, title: &str, _: &str) -> std::result::Result<u64, Failure> {
self.0.lock().unwrap().push(title.into());
answer(title)
}
}
fn spool(dir: &Path) -> PathBuf {
std::fs::create_dir_all(dir).unwrap();
for (key, text) in REPORTS {
std::fs::write(dir.join(format!("{key}.report")), text).unwrap();
}
dir.into()
}
fn python(repack: &Path, spool: &Path, start: f64) -> Vec<String> {
let out = Command::new(repack.join("Runtime/python/python.exe"))
.args(["-I", "-B", "-c", PYTHON])
.arg(repack.join("BugReport/relay.py"))
.arg(spool)
.arg(start.to_string())
.output()
.unwrap();
assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
serde_json::from_slice(&out.stdout).unwrap()
}
/// The clock of both relays: `start`, then 3 seconds later at every reading.
fn rust(spool: &Path, start: f64) -> Vec<String> {
let calls = Arc::new(Mutex::new(Vec::new()));
let t = Mutex::new(start);
let clock = move || {
let mut v = t.lock().unwrap();
*v += 3.0;
*v
};
let relay = Relay::with_clock(spool, Scripted(calls.clone()), Box::new(clock)).unwrap();
relay.pass().unwrap();
drop(relay);
let c = calls.lock().unwrap().clone();
c
}
/// `.status` files and journal rows (without the post time).
fn snapshot(spool: &Path) -> (Vec<(String, String)>, Vec<String>) {
let mut statuses: Vec<(String, String)> = std::fs::read_dir(spool)
.unwrap()
.flatten()
.filter(|e| e.path().extension().is_some_and(|x| x == "status"))
.map(|e| (e.file_name().to_string_lossy().into_owned(), std::fs::read_to_string(e.path()).unwrap()))
.collect();
statuses.sort();
let db = rusqlite::Connection::open(spool.join("relay.sqlite3")).unwrap();
let mut q = db.prepare("SELECT key, digest, marker, state, number, next_try FROM deliveries ORDER BY key").unwrap();
let rows = q
.query_map([], |r| {
Ok(format!(
"{}|{}|{}|{}|{:?}|{}",
r.get::<_, String>(0)?,
r.get::<_, String>(1)?,
r.get::<_, String>(2)?,
r.get::<_, String>(3)?,
r.get::<_, Option<i64>>(4)?,
r.get::<_, f64>(5)?
))
})
.unwrap()
.map(Result::unwrap)
.collect();
(statuses, rows)
}
fn main() {
let repack = PathBuf::from(std::env::args().nth(1).expect("repack folder"));
let work = tempfile::tempdir().unwrap();
// 1
let (a, b) = (spool(&work.path().join("python")), spool(&work.path().join("rust")));
let py_calls = python(&repack, &a, 1000.0);
let rs_calls = rust(&b, 1000.0);
println!("python posted {py_calls:?}\nrust posted {rs_calls:?}");
assert_eq!(py_calls, rs_calls, "the same reports are posted");
let (pa, pb) = (snapshot(&a), snapshot(&b));
for s in &pa.0 {
println!(" {} = {}", s.0, s.1.trim());
}
assert_eq!(pa, pb, "the same statuses and journal");
// 2: each continues the other's journal. Before the retry times nothing is sent again; after them only the
// rate-limited report is (created, rejected and uncertain ones never are).
assert!(python(&repack, &b, 1000.0).is_empty(), "Python does not resend what Rust handled");
assert!(rust(&a, 1000.0).is_empty(), "Rust does not resend what Python handled");
// Later passes: the queued reports go out, a refused or uncertain one never again.
for start in [5000.0, 6000.0, 7000.0] {
let (p, r) = (python(&repack, &b, start), rust(&a, start));
println!("at {start}: python on rust's journal posted {p:?}, rust on python's posted {r:?}");
assert_eq!(p, r, "the same retries");
assert!(!p.iter().any(|t| t == "Quest broken" || t == "Unknown outcome"), "created and uncertain are final");
}
assert_eq!(snapshot(&a), snapshot(&b), "the same after a retry by the other relay");
for dir in [&a, &b] {
let db = rusqlite::Connection::open(dir.join("relay.sqlite3")).unwrap();
db.execute("UPDATE deliveries SET state='posting' WHERE key='9-00000000000000b2'", []).unwrap();
}
python(&repack, &b, 9000.0);
rust(&a, 9000.0);
for dir in [&a, &b] {
let db = rusqlite::Connection::open(dir.join("relay.sqlite3")).unwrap();
let state: String = db.query_row("SELECT state FROM deliveries WHERE key='9-00000000000000b2'", [], |r| r.get(0)).unwrap();
assert_eq!(state, "uncertain", "an interrupted post is not retried ({})", dir.display());
}
assert_eq!(snapshot(&a), snapshot(&b), "still the same after the crossover");
println!("PASS: relay journals, statuses and posts are the same in Python and Rust");
}
@@ -0,0 +1,103 @@
//! SQUID database provisioning in Rust gives exactly what Scripts/squid_playerbots.py gives, on a DISPOSABLE repack:
//! the same journals (coa_squid_migrations, coa_squid_pending) in every schema, the same acore_playerbots tables
//! with the same row counts, the same playerbots.conf. Each side starts from the same state (SQUID never
//! provisioned), and a second run of each must change nothing.
//!
//! usage: squid_equivalence <fixture ending in -fixture> <coa-launcher.exe>
use std::path::Path;
use std::process::Command;
use coa_core::launcher::{services, squid};
fn sql(root: &Path, q: &str) -> String {
services::mysql(root, Some(q), None).unwrap_or_else(|e| panic!("{q}: {e}"))
}
/// What provisioning leaves behind, comparable between runs.
fn snapshot(root: &Path) -> String {
let mut out = Vec::new();
for schema in ["acore_characters", "acore_world", "acore_playerbots"] {
let tables = sql(root, &format!("SELECT TABLE_NAME FROM information_schema.TABLES WHERE TABLE_SCHEMA='{schema}' ORDER BY TABLE_NAME;"));
for t in tables.lines() {
if schema != "acore_playerbots" && !t.starts_with("coa_squid") {
continue;
}
let n = sql(root, &format!("SELECT COUNT(*) FROM `{schema}`.`{t}`;"));
out.push(format!("{schema}.{t} rows={n}"));
if t == "coa_squid_migrations" || t == "coa_squid_pending" {
for row in sql(root, &format!("SELECT path, sha256 FROM `{schema}`.`{t}` ORDER BY path;")).lines() {
out.push(format!(" {row}"));
}
}
}
}
let conf = std::fs::read_to_string(root.join("Core/configs/modules/playerbots.conf")).unwrap();
out.push(format!("playerbots.conf:\n{}", conf.replace("\r\n", "\n")));
out.join("\n")
}
fn reset(root: &Path, conf: &[u8]) {
sql(root, "DROP DATABASE IF EXISTS acore_playerbots;");
for schema in ["acore_characters", "acore_world"] {
sql(root, &format!("DROP TABLE IF EXISTS `{schema}`.coa_squid_migrations, `{schema}`.coa_squid_pending;"));
}
std::fs::write(root.join("Core/configs/modules/playerbots.conf"), conf).unwrap();
}
fn python(root: &Path) {
let harness = root.join(".state/squid_harness.py");
std::fs::write(
&harness,
"import sys, pathlib\nroot = pathlib.Path(sys.argv[1])\nsys.path.insert(0, str(root / 'Scripts'))\nsys.argv = ['manage.py']\nimport manage\nfrom squid_playerbots import prepare_playerbots\nprepare_playerbots(manage.ROOT, manage.settings(), manage.mysql)\n",
)
.unwrap();
let out = Command::new(root.join("Runtime/python/python.exe")).arg("-B").arg(&harness).arg(root).output().unwrap();
assert!(out.status.success(), "python: {}{}", String::from_utf8_lossy(&out.stdout), String::from_utf8_lossy(&out.stderr));
print!("{}", String::from_utf8_lossy(&out.stdout));
}
fn rust(root: &Path) {
let cfg = coa_core::launcher::Settings::load(root, 0).unwrap();
squid::prepare_playerbots(root, cfg.mysql_port, &|q| services::mysql(root, Some(q), None), &|m| println!("{m}")).unwrap();
}
fn main() {
let a: Vec<String> = std::env::args().skip(1).collect();
let root = Path::new(&a[0]);
let exe = Path::new(&a[1]);
assert!(a[0].ends_with("-fixture"));
let modules = root.join("Core/configs/modules");
// SQUID on, Companions off
let companions = std::fs::read_to_string(modules.join("mod_coa_playerbots.conf")).unwrap();
std::fs::write(modules.join("mod_coa_playerbots.conf"), companions.replace("CoaBots.Enable = 1", "CoaBots.Enable = 0")).unwrap();
let squid_conf = std::fs::read_to_string(modules.join("playerbots.conf")).unwrap().replace("AiPlayerbot.Enabled = 0", "AiPlayerbot.Enabled = 1");
let r = root.to_string_lossy().into_owned();
let started = Command::new(exe).args(["--root", &r, "start-mysql"]).output().unwrap();
assert!(started.status.success(), "{}", String::from_utf8_lossy(&started.stderr));
reset(root, squid_conf.as_bytes());
let t = std::time::Instant::now();
python(root);
println!("python provisioned in {:?}", t.elapsed());
let by_python = snapshot(root);
python(root);
assert_eq!(snapshot(root), by_python, "a second Python run changed something");
reset(root, squid_conf.as_bytes());
let t = std::time::Instant::now();
rust(root);
println!("rust provisioned in {:?}", t.elapsed());
let by_rust = snapshot(root);
rust(root);
assert_eq!(snapshot(root), by_rust, "a second Rust run changed something");
if by_python != by_rust {
std::fs::write(root.join(".state/squid-python.txt"), &by_python).unwrap();
std::fs::write(root.join(".state/squid-rust.txt"), &by_rust).unwrap();
panic!("Rust and Python differ: see .state/squid-python.txt and squid-rust.txt");
}
println!("{} lines of journal/table/config state are identical", by_rust.lines().count());
let stopped = Command::new(exe).args(["--root", &r, "stop-all"]).output().unwrap();
assert!(stopped.status.success());
println!("SQUID EQUIVALENCE PASS");
}
+306 -124
View File
@@ -5,7 +5,7 @@
//! into the player's WoW client directory.
use std::fs::{self, File};
use std::io::{self, Read, Write};
use std::io::{self, Read};
use std::path::{Path, PathBuf};
use serde::{Deserialize, Serialize};
@@ -153,7 +153,10 @@ pub fn sync_bot_races_config(root: &Path, allow_custom_races: bool) -> Result<()
let clean = value.trim().trim_matches(['"', '\'']);
let owned = String::from_utf8_lossy(&bytes)
.contains("CoA Custom: races new random bots never get")
&& matches!(clean, EXCLUDED_BOT_RACES_RECOMMENDED | EXCLUDED_BOT_RACES_EXPERIMENTAL);
&& matches!(
clean,
EXCLUDED_BOT_RACES_RECOMMENDED | EXCLUDED_BOT_RACES_EXPERIMENTAL
);
if !owned {
continue;
}
@@ -662,134 +665,147 @@ fn stage_root_asset(staging: &Path, relative: &str, reader: &mut impl Read) -> R
Ok(relative.to_string())
}
fn verify_archive(path: &Path, filename: &str) -> Result<()> {
let expected = match filename {
"CoA-Custom-1.9.2-Client-1.zip" => {
"a9dd51ed2d90fb048d549602f40f5429d56e2df0df5606a38781b358fa369568"
}
"CoA-Custom-1.9.2-Client-2.zip" => {
"ab084a55509ccbcc2977a06dd0c01fa879973a1892baaacaeb3ff52f3dfc750e"
}
"CoA-Custom-1.9.2-Client-3.zip" => {
"907e267f0ee7038807e626c3c1eca5e12db6c88b747137a23c5fb52eaa1a358e"
}
"CoA-Custom-1.9.2-Client-4.zip" => {
"e0bd87172af989fa50a8e2b08ba4321c72b6265047482f051a1db3b80d55bcaa"
}
"CoA-Custom-1.9.2-Client-5.zip" => {
"73364ad1b58c6342641a848a3b20a835472834f600416606be1470386774ca78"
}
fn archive_job(filename: &str, url: &str, cache: &Path) -> Result<crate::download::Job> {
let (size, sha256) = match filename {
"CoA-Custom-1.9.2-Client-1.zip" => (
1_513_021_586,
"a9dd51ed2d90fb048d549602f40f5429d56e2df0df5606a38781b358fa369568",
),
"CoA-Custom-1.9.2-Client-2.zip" => (
1_198_283_005,
"ab084a55509ccbcc2977a06dd0c01fa879973a1892baaacaeb3ff52f3dfc750e",
),
"CoA-Custom-1.9.2-Client-3.zip" => (
1_678_829_573,
"907e267f0ee7038807e626c3c1eca5e12db6c88b747137a23c5fb52eaa1a358e",
),
"CoA-Custom-1.9.2-Client-4.zip" => (
502_385_128,
"e0bd87172af989fa50a8e2b08ba4321c72b6265047482f051a1db3b80d55bcaa",
),
"CoA-Custom-1.9.2-Client-5.zip" => (
168_079_711,
"73364ad1b58c6342641a848a3b20a835472834f600416606be1470386774ca78",
),
_ => return Err(Error::Invalid("Unknown custom races archive.".into())),
};
if fsx::sha256_file(path)? != expected {
Ok(crate::download::Job {
url: url.into(),
dest: cache.join(filename),
sha256: sha256.into(),
size,
})
}
fn archive_matches(path: &Path, job: &crate::download::Job) -> bool {
path.metadata()
.is_ok_and(|m| m.is_file() && m.len() == job.size)
&& fsx::sha256_file(path).is_ok_and(|hash| hash.eq_ignore_ascii_case(&job.sha256))
}
#[cfg(test)]
fn verify_archive(path: &Path, filename: &str) -> Result<()> {
let job = archive_job(filename, "", Path::new(""))?;
if !archive_matches(path, &job) {
return Err(Error::Invalid(format!(
"Custom races archive {filename} failed verification. Remove it and try again."
"Custom races archive {filename} failed verification."
)));
}
Ok(())
}
/// Locate an archive locally in Downloads or cache, or download it from GitHub.
/// User-owned Downloads files are read-only candidates. Only the Manager's cache is repaired.
fn resolve_archive_with(
transport: &dyn crate::download::Transport,
job: &crate::download::Job,
downloads: Option<&Path>,
cancel: &Cancel,
progress: &dyn Fn(crate::download::Progress),
) -> Result<PathBuf> {
if cancel.is_set() {
return Err(Error::Invalid("Download cancelled.".into()));
}
if let Some(downloads) = downloads {
let candidate = downloads.join(job.dest.file_name().unwrap_or_default());
if archive_matches(&candidate, job) {
tracing::info!(path = %candidate.display(), "using verified archive in Downloads");
progress(crate::download::Progress {
downloaded: job.size,
total: job.size,
bytes_per_sec: 0,
});
return Ok(candidate);
}
if candidate.exists() {
tracing::warn!(path = %candidate.display(), "ignoring incomplete or unverified archive in Downloads");
}
}
let cache = job
.dest
.parent()
.ok_or_else(|| Error::Invalid("Missing archive cache directory.".into()))?;
fs::create_dir_all(cache)?;
// Different installations share this cache; never append to or replace another active download.
use fs4::fs_std::FileExt;
let lock = fs::OpenOptions::new()
.read(true)
.write(true)
.create(true)
.truncate(false)
.open(suffix(&job.dest, "lock"))?;
if !lock.try_lock_exclusive()? {
return Err(Error::Invalid("Another custom races download is using this archive. Wait for it to finish, then retry.".into()));
}
if job.dest.is_file() {
if archive_matches(&job.dest, job) {
progress(crate::download::Progress {
downloaded: job.size,
total: job.size,
bytes_per_sec: 0,
});
return Ok(job.dest.clone());
}
tracing::warn!(path = %job.dest.display(), "removing unverified Manager archive cache; downloading again");
fs::remove_file(&job.dest)?;
}
// The shared downloader resumes .part files and verifies the complete archive before promotion.
// A stale/corrupt prefix may only be detectable after resume: retry once from scratch in that case.
match crate::download::fetch_with(transport, job, cancel, progress) {
Err(Error::HashMismatch { .. }) if !cancel.is_set() => {
tracing::warn!(path = %job.dest.display(), "archive verification failed; retrying a clean download");
crate::download::fetch_with(transport, job, cancel, progress)?;
}
result => result?,
}
Ok(job.dest.clone())
}
/// Locate a verified archive or resume downloading it into the Manager's cache.
fn resolve_or_download_archive(
filename: &str,
url: &str,
client: &reqwest::blocking::Client,
transport: &dyn crate::download::Transport,
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)
// Report before hashing existing files: otherwise checking a large archive looks like no operation.
report(&format!("Checking {filename}..."), base_percent);
let cache = std::env::temp_dir().join("coa-client-races");
let downloads = std::env::var_os("USERPROFILE").map(|p| PathBuf::from(p).join("Downloads"));
let job = archive_job(filename, url, &cache)?;
resolve_archive_with(transport, &job, downloads.as_deref(), cancel, &|p| {
let ratio = p.downloaded as f32 / p.total.max(1) as f32;
report(
&format!(
"Downloading {filename} ({:.1} MB)...",
p.downloaded as f64 / 1_048_576.0
),
base_percent + ratio.clamp(0.0, 1.0) * percent_slice,
);
})
}
/// Download (if needed) and extract custom races client assets into the target WoW client.
@@ -818,11 +834,7 @@ pub fn install_client_patches(
fs::create_dir_all(&data_dir)?;
// 2. Resolve/download archives (0.05 .. 0.50)
let http = reqwest::blocking::Client::builder()
.user_agent(concat!("CoA-Server-Manager/", env!("CARGO_PKG_VERSION")))
.timeout(std::time::Duration::from_secs(600))
.build()
.map_err(|e| Error::Invalid(format!("Cannot prepare downloader: {e}")))?;
let http = crate::download::HttpTransport::with_total_timeout(600)?;
let mut resolved_archives = Vec::new();
let n_archives = ARCHIVES.len() as f32;
@@ -1113,7 +1125,9 @@ mod tests {
serde_json::from_str(include_str!("custom_races_hashes_1_9_1.json")).unwrap();
let files = patch_files(temp.path()).unwrap();
assert_eq!(files.len(), old.len());
assert!(files.iter().all(|file| old.get(&file.path) == Some(&file.sha256)));
assert!(files
.iter()
.all(|file| old.get(&file.path) == Some(&file.sha256)));
assert!(!files.iter().any(|file| file.path.contains("CoAQuestSafe")));
}
@@ -1571,11 +1585,179 @@ mod tests {
);
}
struct ArchiveTransport {
body: Vec<u8>,
ranges: std::sync::Mutex<Vec<u64>>,
}
impl crate::download::Transport for ArchiveTransport {
fn get(&self, _: &str, from: u64) -> std::result::Result<crate::download::Reply, String> {
self.ranges.lock().unwrap().push(from);
Ok(crate::download::Reply {
status: if from == 0 { 200 } else { 206 },
content_range: (from > 0)
.then(|| format!("bytes {from}-{}/{}", self.body.len() - 1, self.body.len())),
body: Box::new(io::Cursor::new(self.body[from as usize..].to_vec())),
})
}
}
fn archive_fixture(root: &Path) -> (crate::download::Job, ArchiveTransport) {
use sha2::{Digest, Sha256};
let body = b"verified archive bytes for recovery tests".to_vec();
let job = crate::download::Job {
url: "https://example.invalid/patch.zip".into(),
dest: root.join("cache/patch.zip"),
sha256: hex::encode(Sha256::digest(&body)),
size: body.len() as u64,
};
fs::create_dir_all(job.dest.parent().unwrap()).unwrap();
(
job,
ArchiveTransport {
body,
ranges: Default::default(),
},
)
}
#[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());
fn download_uses_verified_user_archive_without_network() {
let temp = tempfile::tempdir().unwrap();
let (job, transport) = archive_fixture(temp.path());
let downloads = temp.path().join("Downloads");
fs::create_dir(&downloads).unwrap();
let archive = downloads.join("patch.zip");
fs::write(&archive, &transport.body).unwrap();
let path = resolve_archive_with(
&transport,
&job,
Some(&downloads),
&Cancel::default(),
&|_| {},
)
.unwrap();
assert_eq!(path, archive);
assert!(transport.ranges.lock().unwrap().is_empty());
assert!(!job.dest.exists());
}
#[test]
fn download_skips_bad_user_archive_and_repairs_bad_cache() {
let temp = tempfile::tempdir().unwrap();
let (job, transport) = archive_fixture(temp.path());
let downloads = temp.path().join("Downloads");
fs::create_dir(&downloads).unwrap();
let bad = vec![b'x'; transport.body.len()];
fs::write(downloads.join("patch.zip"), &bad).unwrap();
fs::write(downloads.join("patch.zip.part"), b"user browser download").unwrap();
fs::write(&job.dest, &bad).unwrap();
let path = resolve_archive_with(
&transport,
&job,
Some(&downloads),
&Cancel::default(),
&|_| {},
)
.unwrap();
assert_eq!(path, job.dest);
assert_eq!(fs::read(&path).unwrap(), transport.body);
assert_eq!(fs::read(downloads.join("patch.zip")).unwrap(), bad);
assert_eq!(
fs::read(downloads.join("patch.zip.part")).unwrap(),
b"user browser download"
);
assert_eq!(*transport.ranges.lock().unwrap(), vec![0]);
}
#[test]
fn download_resumes_leftover_part_and_verifies_complete_archive() {
let temp = tempfile::tempdir().unwrap();
let (job, transport) = archive_fixture(temp.path());
let part = suffix(&job.dest, "part");
fs::write(&part, &transport.body[..9]).unwrap();
resolve_archive_with(&transport, &job, None, &Cancel::default(), &|_| {}).unwrap();
assert_eq!(*transport.ranges.lock().unwrap(), vec![9]);
assert_eq!(fs::read(&job.dest).unwrap(), transport.body);
assert!(!part.exists());
}
#[test]
fn download_reuses_good_cache_even_when_user_archive_is_incomplete() {
let temp = tempfile::tempdir().unwrap();
let (job, transport) = archive_fixture(temp.path());
let downloads = temp.path().join("Downloads");
fs::create_dir(&downloads).unwrap();
fs::write(downloads.join("patch.zip"), b"incomplete").unwrap();
fs::write(&job.dest, &transport.body).unwrap();
let path = resolve_archive_with(
&transport,
&job,
Some(&downloads),
&Cancel::default(),
&|_| {},
)
.unwrap();
assert_eq!(path, job.dest);
assert!(transport.ranges.lock().unwrap().is_empty());
assert_eq!(
fs::read(downloads.join("patch.zip")).unwrap(),
b"incomplete"
);
}
#[test]
fn download_restarts_once_when_resumed_prefix_is_corrupt() {
let temp = tempfile::tempdir().unwrap();
let (job, transport) = archive_fixture(temp.path());
fs::write(suffix(&job.dest, "part"), b"bad").unwrap();
resolve_archive_with(&transport, &job, None, &Cancel::default(), &|_| {}).unwrap();
assert_eq!(*transport.ranges.lock().unwrap(), vec![3, 0]);
assert_eq!(fs::read(&job.dest).unwrap(), transport.body);
}
#[test]
fn download_promotes_completed_part_without_redownloading() {
let temp = tempfile::tempdir().unwrap();
let (job, transport) = archive_fixture(temp.path());
fs::write(suffix(&job.dest, "part"), &transport.body).unwrap();
resolve_archive_with(&transport, &job, None, &Cancel::default(), &|_| {}).unwrap();
assert!(transport.ranges.lock().unwrap().is_empty());
assert_eq!(fs::read(&job.dest).unwrap(), transport.body);
}
#[test]
fn download_stops_after_one_clean_retry_if_server_bytes_are_invalid() {
let temp = tempfile::tempdir().unwrap();
let (job, mut transport) = archive_fixture(temp.path());
transport.body.fill(b'x');
let result = resolve_archive_with(&transport, &job, None, &Cancel::default(), &|_| {});
assert!(matches!(result, Err(Error::HashMismatch { .. })));
assert_eq!(*transport.ranges.lock().unwrap(), vec![0, 0]);
assert!(!job.dest.exists());
assert!(!suffix(&job.dest, "part").exists());
}
#[test]
fn download_does_not_modify_an_archive_owned_by_another_download() {
use fs4::fs_std::FileExt;
let temp = tempfile::tempdir().unwrap();
let (job, transport) = archive_fixture(temp.path());
let lock = fs::OpenOptions::new()
.read(true)
.write(true)
.create(true)
.truncate(false)
.open(suffix(&job.dest, "lock"))
.unwrap();
lock.try_lock_exclusive().unwrap();
fs::write(suffix(&job.dest, "part"), b"active download").unwrap();
assert!(resolve_archive_with(&transport, &job, None, &Cancel::default(), &|_| {}).is_err());
assert_eq!(
fs::read(suffix(&job.dest, "part")).unwrap(),
b"active download"
);
assert!(transport.ranges.lock().unwrap().is_empty());
}
#[test]
+54 -304
View File
@@ -1,11 +1,10 @@
//! Start/stop of a repack-shaped installation by delegating to the repack's own supervisor
//! (`Runtime\python\python.exe Scripts\manage.py <verb>`), which already implements config rendering, the
//! bug-report relay, RA graceful shutdown and readiness. Observation stays native (see `process`).
//! Start/stop of a repack-shaped installation through the repack launcher in this crate
//! ([`crate::launcher`]): config rendering, the services, the world supervisor, graceful shutdown and readiness.
//! It writes the same `.state` records as the repack's `Scripts/manage.py`, so the repack's own launcher and
//! this Manager can be used on the same folder. Observation stays native (see `process`).
use std::io::Read;
use std::path::{Path, PathBuf};
use std::process::{Command, Stdio};
use std::time::{Duration, Instant};
use std::path::Path;
use std::sync::Mutex;
use serde::Serialize;
@@ -22,22 +21,13 @@ pub enum Verb {
}
impl Verb {
fn arg(self) -> &'static str {
fn action(self) -> crate::launcher::ops::Action {
use crate::launcher::ops::Action;
match self {
Verb::StartAll => "start-all",
Verb::StartMysql => "start-mysql",
Verb::StartWorld => "start-world",
Verb::StopAll => "stop-all",
}
}
fn timeout(self, _root: &Path) -> Duration {
match self {
// Includes database startup, optional bot provisioning and the shared 25-minute
// world/console wait in launcher_bridge.py, even for older installed scripts.
Verb::StartAll | Verb::StartWorld => Duration::from_secs(3600),
Verb::StartMysql => Duration::from_secs(360),
Verb::StopAll => Duration::from_secs(240),
Verb::StartAll => Action::StartAll,
Verb::StartMysql => Action::StartMysql,
Verb::StartWorld => Action::StartWorld,
Verb::StopAll => Action::StopAll,
}
}
}
@@ -52,41 +42,14 @@ pub struct DriverOutcome {
pub output: String,
}
/// Map the launcher's own messages onto stable error codes. Unknown text stays `Unknown` (details remain visible).
pub fn translate(output: &str) -> ErrorCode {
let o = output.to_lowercase();
if o.contains("is already used") {
ErrorCode::PortInUse
} else if o.contains("another start/stop action is in progress")
|| o.contains("shutdown is still finishing")
{
ErrorCode::OperationInProgress
} else if o.contains("packaged database is missing")
|| o.contains("extract the complete repack")
{
ErrorCode::ServerFilesIncomplete
} else if o.contains("stopped during startup")
|| o.contains("is still starting")
|| o.contains("world startup failed")
{
ErrorCode::StartupFailed
} else if o.contains("invalid port") || o.contains("unresolved placeholder") {
ErrorCode::InvalidConfigValue
} else {
ErrorCode::Unknown
}
}
fn launcher(root: &Path) -> Result<(PathBuf, PathBuf)> {
let python = root.join("Runtime/python/python.exe");
let script = root.join("Scripts/manage.py");
if !python.is_file() || !script.is_file() {
fn has_launcher_settings(root: &Path) -> Result<()> {
if !root.join("Settings/repack.json").is_file() {
return Err(Error::Invalid(
"This server has no CoA Repack launcher; start/stop is not available for it yet."
.into(),
));
}
Ok((python, script))
Ok(())
}
/// Run a launcher verb to completion (blocking; call from a worker thread).
@@ -205,104 +168,51 @@ fn run_inner_mode(
if matches!(verb, Verb::StartAll | Verb::StartWorld) {
crate::modules::ensure_bot_exclusivity(&root)?;
}
let (python, script) = launcher(&root)?;
has_launcher_settings(&root)?;
prepare_headless_world(&root, verb)?;
let original = std::fs::read_to_string(&script)?;
let patched = patch_launcher_imports(&original)?;
if original != patched {
fsx::atomic_write(&script, patched.as_bytes())?;
if let Ok(dir) = crate::registry::metadata_dir_for(&root) {
if let Ok((_, mut meta)) = crate::registry::MetaDir::open(&dir) {
if meta.original_hashes.get("Scripts/manage.py")
== Some(&fsx::sha256_bytes(original.as_bytes()))
{
meta.original_hashes.insert(
"Scripts/manage.py".into(),
fsx::sha256_bytes(patched.as_bytes()),
);
fsx::atomic_write_json(&dir.join("install.json"), &meta)?;
}
}
}
}
discard_damaged_launcher_state(&root);
if matches!(verb, Verb::StopAll | Verb::StartMysql | Verb::StartAll) {
recover_mysql_launcher_state(&root, verb != Verb::StopAll)?;
}
if force {
recover_world_for_forced_stop(&root)?;
}
let mut cmd = Command::new(&python);
cmd.arg("-B")
.arg("-c")
.arg(LAUNCH_SCRIPT)
.arg(&script)
.arg(if force { "force-stop-all" } else { verb.arg() })
.current_dir(&root)
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::piped());
#[cfg(windows)]
{
use std::os::windows::process::CommandExt;
cmd.creation_flags(0x0800_0000); // CREATE_NO_WINDOW
}
tracing::info!(?verb, root = %root.display(), "driver: starting launcher verb");
let mut child = cmd.spawn()?;
let mut stdout = child.stdout.take().expect("piped");
let mut stderr = child.stderr.take().expect("piped");
let out_t = std::thread::spawn(move || {
let mut s = String::new();
let _ = stdout.read_to_string(&mut s);
s
});
let err_t = std::thread::spawn(move || {
let mut s = String::new();
let _ = stderr.read_to_string(&mut s);
s
});
let deadline = Instant::now() + verb.timeout(&root);
let status = loop {
if let Some(st) = child.try_wait()? {
break Some(st);
}
if Instant::now() > deadline {
// Never kill the servers themselves: only abandon the launcher process we spawned.
let _ = child.kill();
break None;
}
std::thread::sleep(Duration::from_millis(200));
};
let mut output = out_t.join().unwrap_or_default();
output.push_str(&err_t.join().unwrap_or_default());
let mut output = output.trim().to_string();
if status.is_none() {
output.push_str(&format!(
"\nLauncher {} exceeded its {} second deadline; check the server logs.",
verb.arg(),
verb.timeout(&root).as_secs()
));
}
let (ok, exit_code) = match status {
Some(st) => (st.success(), st.code()),
None => (false, None),
};
let code = if ok {
None
let action = if force {
crate::launcher::ops::Action::ForceStopAll
} else {
// Log evidence beats the launcher's generic "stopped during startup" message.
let base = if status.is_none() {
ErrorCode::StartupFailed
} else {
translate(&output)
};
match base {
ErrorCode::StartupFailed | ErrorCode::Unknown => {
Some(crate::health::diagnose_installation(&root).unwrap_or(base))
verb.action()
};
tracing::info!(?verb, root = %root.display(), "driver: starting launcher action");
let lines = Mutex::new(Vec::<String>::new());
let progress = |line: &str| {
tracing::info!(?verb, "launcher: {line}");
lines.lock().unwrap_or_else(|e| e.into_inner()).push(line.to_string());
};
let result = crate::launcher::Settings::load(&root, 0).and_then(|mut cfg| {
if validating_update {
// Isolated startup must use the port from its temporary auth config.
cfg.env_remove.push("AC_REALM_SERVER_PORT".into());
}
crate::launcher::ops::run(&root, &cfg, 0, action, None, &progress)
});
let mut output = lines.into_inner().unwrap_or_else(|e| e.into_inner()).join("\n");
let ok = result.is_ok();
let code = match &result {
Ok(()) => None,
Err(error) => {
if !output.is_empty() {
output.push('\n');
}
output.push_str(&format!("ERROR: {error}"));
// Log evidence beats a generic "stopped during startup".
match error.code() {
ErrorCode::StartupFailed | ErrorCode::Unknown => Some(
crate::health::diagnose_installation(&root).unwrap_or(error.code()),
),
other => Some(other),
}
other => Some(other),
}
};
let exit_code = Some(if ok { 0 } else { 1 });
if code == Some(ErrorCode::PortInUse) {
let observed = crate::process::observe(&root, &crate::layout::read_ports(&root));
for service in [&observed.mysql, &observed.auth, &observed.world]
@@ -370,35 +280,6 @@ fn prepare_headless_world(root: &Path, verb: Verb) -> Result<()> {
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
}
/// A lost launcher record must not hide this installation's running MySQL from
/// graceful shutdown. Adopt only the exact executable owning its configured port.
fn recover_mysql_launcher_state(root: &Path, prefer_listener: bool) -> Result<()> {
@@ -449,60 +330,6 @@ fn recover_mysql_launcher_state(root: &Path, prefer_listener: bool) -> Result<()
Ok(())
}
const LAUNCH_SCRIPT: &str = include_str!("launcher_bridge.py");
pub(crate) fn patch_launcher_imports(text: &str) -> Result<String> {
let line = "sys.path.insert(0, str(Path(__file__).resolve().parent))";
if !text.contains("from squid_playerbots import") || text.contains(line) {
return Ok(text.into());
}
let root = "ROOT = Path(__file__).resolve().parents[1]";
if !text.contains(root) || !text.lines().any(|line| line.trim() == "import sys") {
return Err(Error::Invalid(
"The server launcher cannot load its integration scripts. Repair its program files."
.into(),
));
}
Ok(text.replacen(root, &format!("{root}\n{line}"), 1))
}
pub(crate) fn launcher_matches(signed: &str, actual: &[u8]) -> bool {
if signed.as_bytes() == actual {
return true;
}
if patch_launcher_imports(signed).is_ok_and(|s| s.as_bytes() == actual) {
return true;
}
crate::realms::patch_launcher(signed).is_ok_and(|s| {
s.as_bytes() == actual || 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
@@ -604,7 +431,7 @@ mod tests {
text.contains("launcher request failed before completion")
&& text.contains("in progress")
);
assert!(!text.contains("starting launcher verb"));
assert!(!text.contains("starting launcher action"));
}
#[test]
@@ -661,78 +488,10 @@ mod tests {
}
#[test]
fn slow_world_startup_has_time_with_either_bot_system_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(3600)
);
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(3600)
);
assert_eq!(
Verb::StartMysql.timeout(folder.path()),
Duration::from_secs(360)
);
}
#[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
);
assert_eq!(
translate("Another start/stop action is in progress."),
ErrorCode::OperationInProgress
);
assert_eq!(
translate("The packaged database is missing. Extract the complete repack."),
ErrorCode::ServerFilesIncomplete
);
assert_eq!(
translate("world stopped during startup. Check its log."),
ErrorCode::StartupFailed
);
assert_eq!(translate("Exit code -1073741819"), ErrorCode::Unknown);
fn launcher_failures_carry_their_error_code() {
let e = Error::Service(ErrorCode::PortInUse, "Port 8085 is already used (PID 4).".into());
assert_eq!(e.code(), ErrorCode::PortInUse);
assert_eq!(e.to_string(), "Port 8085 is already used (PID 4).");
}
#[test]
@@ -775,13 +534,4 @@ mod tests {
assert!(!reason.contains("private"));
assert!(!reason.contains("Something went wrong"));
}
#[test]
fn launcher_import_fix_is_idempotent_and_retains_other_code() {
let text = "import sys\nROOT = Path(__file__).resolve().parents[1]\nfrom squid_playerbots import validate_bots\ncustom = 42\n";
let fixed = patch_launcher_imports(text).unwrap();
assert!(fixed.contains("sys.path.insert(0, str(Path(__file__).resolve().parent))"));
assert!(fixed.ends_with("custom = 42\n"));
assert_eq!(patch_launcher_imports(&fixed).unwrap(), fixed);
}
}
+4
View File
@@ -24,6 +24,9 @@ pub enum Error {
UnknownInstallation(String),
#[error("{0}")]
Invalid(String),
/// A server start or stop failed for a reason the UI can explain (the repack launcher's own errors).
#[error("{1}")]
Service(ErrorCode, String),
#[error("package not published: {0}")]
PackageNotPublished(String),
#[error("download server unreachable: {0}")]
@@ -199,6 +202,7 @@ impl Error {
Error::PackageNotPublished(_) => ErrorCode::PackageNotPublished,
Error::NetworkUnreachable(_) => ErrorCode::NetworkUnreachable,
Error::BotModulesConflict => ErrorCode::BotModulesConflict,
Error::Service(code, _) => *code,
Error::CompanionTemplatesMissing => ErrorCode::CompanionTemplatesMissing,
Error::CompanionCommandUnsupported => ErrorCode::CompanionCommandUnsupported,
_ => ErrorCode::Unknown,
+24
View File
@@ -0,0 +1,24 @@
//! The repack launcher in Rust: what `Scripts/manage.py` does, without Python.
//!
//! Formats on disk stay exactly those of `manage.py`, so the two can be used on the same server during the move
//! (an old `.bat` and a new Manager, or the other way round):
//!
//! * `.state/<service>.json` process records `{pid, exe, created}` (see [`crate::process::ProcessIdentity`]);
//! * `.state/control.lock` one start/stop action at a time: byte 0 locked, as `msvcrt.locking` does;
//! * `.state/control-owner.json`, `.state/configuration.json`, `.state/debug-logs.json`;
//! * the rendered configs (`Core/configs/*.conf`, `mysql/my.ini`, `mysql/admin-client.ini`) byte for byte.
//!
//! State files are written with a flush to disk before they replace the old ones (`manage.py` did not, and a
//! power cut could leave a zero-filled record that stopped every later start).
pub mod ops;
pub mod relay;
pub mod render;
pub mod services;
pub mod settings;
pub mod spawn;
pub mod squid;
pub mod state;
pub mod world;
pub use settings::Settings;
+88
View File
@@ -0,0 +1,88 @@
//! One start/stop action of a repack, with the control lock held (`manage.py main()`): the entry point of both
//! `coa-launcher.exe` and the Manager.
use std::path::Path;
use std::time::Duration;
use crate::error::Result;
use crate::launcher::services::{self, Progress};
use crate::launcher::world::{self, Supervisor};
use crate::launcher::{render, settings::Settings, squid, state};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Action {
StartAll,
StartMysql,
StartAuth,
StartWorld,
StopAll,
/// Stop the world without its console first (unsaved progress is lost), then everything else.
ForceStopAll,
Prepare,
}
impl Action {
/// The command name, as the `.bat` files and `manage.py` call it.
pub fn name(self) -> &'static str {
match self {
Action::StartAll => "start-all",
Action::StartMysql => "start-mysql",
Action::StartAuth => "start-auth",
Action::StartWorld => "start-world",
Action::StopAll => "stop-all",
Action::ForceStopAll => "force-stop-all",
Action::Prepare => "prepare",
}
}
pub fn parse(name: &str) -> Option<Action> {
[
Action::StartAll,
Action::StartMysql,
Action::StartAuth,
Action::StartWorld,
Action::StopAll,
Action::ForceStopAll,
Action::Prepare,
]
.into_iter()
.find(|a| a.name() == name)
}
}
/// Run `action`. A started world is supervised by `supervisor`, or by what the repack ships when it is `None`.
pub fn run(root: &Path, cfg: &Settings, offset: i32, action: Action, supervisor: Option<&Supervisor>, progress: Progress) -> Result<()> {
let _lock = state::ControlLock::acquire(root, action.name(), Duration::from_secs(30), progress)?;
match action {
// Shutdown uses the existing client and console settings: the templates may be exactly what a recovery
// needs to replace, so nothing is rendered.
Action::StopAll => return services::stop_all(root, cfg, progress),
Action::ForceStopAll => return services::force_stop_all(root, cfg, progress),
_ => {}
}
if matches!(action, Action::StartAll | Action::StartWorld) {
squid::validate_bots(root)?;
}
render::prepare(root, cfg)?;
if action == Action::Prepare {
return Ok(());
}
if matches!(action, Action::StartAll | Action::StartMysql) {
services::start_mysql(root, cfg, progress)?;
}
if matches!(action, Action::StartAll | Action::StartAuth) {
services::start_auth(root, cfg, progress)?;
}
if matches!(action, Action::StartAll | Action::StartWorld) {
let shipped;
let supervisor = match supervisor {
Some(s) => s,
None => {
shipped = Supervisor::of(root)?;
&shipped
}
};
world::start_world(root, cfg, offset, supervisor, progress)?;
}
Ok(())
}
+493
View File
@@ -0,0 +1,493 @@
//! The bug-report relay (`BugReport/relay.py` and `manage.py relay-worker`): delivers the reports the world
//! writes to `BugReport/reports/*.report` through the CoA report service.
//!
//! On disk everything stays as the Python relay keeps it, so either can take over a spool: the `<key>.status`
//! files the world reads back, the delivery journal `relay.sqlite3` (tables `deliveries` and `settings`), and
//! `relay.lock` (byte 0 locked while a worker runs). A delivery interrupted while it was posting becomes
//! `uncertain` and is never sent again (the service's duplicate filter may have been reset in the meantime).
use std::path::{Path, PathBuf};
use std::time::{Duration, SystemTime, UNIX_EPOCH};
use rusqlite::{params, Connection, OptionalExtension};
use sha2::{Digest, Sha256};
use crate::error::{Error, Result};
use crate::launcher::state;
const REPOSITORY: &str = "jealous-sound/azerothcore-wotlk-coa";
pub const SERVICE_URL: &str = "https://coa-bug-report.up.railway.app";
/// Distribution credential for this narrow intake API (the same as relay.py's); not a GitHub token.
pub const DEFAULT_API_KEY: &str = "coa_zRatxUHShOn-HEkoreKGME6sd3DdMG7eKTTKlj2JCK4";
const MAX_FILE: u64 = 16000;
const MAX_RESPONSE: usize = 64 * 1024;
/// `[1-9][0-9]{0,9}-[0-9a-f]{16,48}`: the name of a report file (without `.report`).
pub fn valid_key(key: &str) -> bool {
let Some((id, hex)) = key.split_once('-') else { return false };
(1..=10).contains(&id.len())
&& !id.starts_with('0')
&& id.bytes().all(|b| b.is_ascii_digit())
&& (16..=48).contains(&hex.len())
&& hex.bytes().all(|b| b.is_ascii_digit() || (b'a'..=b'f').contains(&b))
}
/// Why a delivery did not create an issue. Only fixed local codes: never service bodies, credentials or report
/// content.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Failure {
/// 202 pending: the service is still creating it.
Pending(u64),
/// 429: try again later.
Limited(u64),
/// The report itself was refused.
Invalid,
/// The service refused this relay (redirect, auth, missing endpoint, GitHub access).
Blocked(u64),
/// The outcome is unknown (network, timeout, unexpected answer).
Uncertain,
}
/// Where reports go.
pub trait Service {
fn create(&self, title: &str, body: &str) -> std::result::Result<u64, Failure>;
}
/// The CoA report service over HTTPS.
pub struct ReportService {
api: String,
key: String,
client: reqwest::blocking::Client,
}
impl ReportService {
pub fn new(base_url: &str, api_key: &str) -> Result<ReportService> {
if api_key.is_empty() || !api_key.is_ascii() || api_key.chars().any(char::is_whitespace) {
return Err(Error::Invalid("Configure a valid report-service intake key.".into()));
}
let client = reqwest::blocking::Client::builder()
.redirect(reqwest::redirect::Policy::none())
.timeout(Duration::from_secs(30))
// One report every few seconds at most: a fresh connection each time, never a stale pooled one.
.pool_max_idle_per_host(0)
.user_agent("CoA-InGame-BugReport/1")
.build()
.map_err(|e| Error::Invalid(format!("The report client could not start: {e}")))?;
Ok(ReportService { api: format!("{base_url}/v1/reports"), key: api_key.into(), client })
}
}
/// `Retry-After` in seconds, kept within 1 s .. 1 day; `default` when absent or not a number.
fn retry_delay(retry_after: Option<&str>, default: u64) -> u64 {
retry_after.and_then(|v| v.trim().parse::<i64>().ok()).map_or(default, |v| v.clamp(1, 86400) as u64)
}
/// A JSON object of at most 64 KiB, or nothing.
fn json_object(raw: Option<&[u8]>) -> Option<serde_json::Map<String, serde_json::Value>> {
let raw = raw?;
if raw.len() > MAX_RESPONSE {
return None;
}
match serde_json::from_slice(raw).ok()? {
serde_json::Value::Object(map) => Some(map),
_ => None,
}
}
fn issue_number(data: &serde_json::Map<String, serde_json::Value>) -> std::result::Result<u64, Failure> {
let number = data.get("issue_number").and_then(|n| if n.is_u64() { n.as_u64() } else { None });
match number {
Some(n)
if data.get("status").and_then(|s| s.as_str()) == Some("created")
&& (1..=4294967295).contains(&n)
&& data.get("issue_url").and_then(|u| u.as_str())
== Some(format!("https://github.com/{REPOSITORY}/issues/{n}").as_str()) =>
{
Ok(n)
}
_ => Err(Failure::Uncertain),
}
}
/// What a service answer means (relay.py's `create`): the status, its `Retry-After` and its body (`None` when it
/// could not be read or was longer than 64 KiB).
pub fn classify(status: u16, retry_after: Option<&str>, body: Option<&[u8]>) -> std::result::Result<u64, Failure> {
let field = |data: &serde_json::Map<String, serde_json::Value>, k: &str| data.get(k).and_then(|v| v.as_str()).map(str::to_owned);
match status {
200..=202 => {
let data = json_object(body).ok_or(Failure::Uncertain)?;
match status {
202 if field(&data, "status").as_deref() == Some("pending") => Err(Failure::Pending(retry_delay(retry_after, 2))),
202 => Err(Failure::Uncertain),
_ => issue_number(&data),
}
}
429 => Err(Failure::Limited(retry_delay(retry_after, 300))),
400 | 413 | 415 | 422 => Err(Failure::Invalid),
301 | 302 | 303 | 307 | 308 | 401 | 403 | 404 | 405 => Err(Failure::Blocked(300)),
503 => {
let data = json_object(body).unwrap_or_default();
if field(&data, "status").as_deref() == Some("failed") && field(&data, "error").as_deref() == Some("github_access_denied") {
Err(Failure::Blocked(retry_delay(retry_after, 300)))
} else {
Err(Failure::Uncertain)
}
}
_ => Err(Failure::Uncertain),
}
}
impl Service for ReportService {
fn create(&self, title: &str, body: &str) -> std::result::Result<u64, Failure> {
use std::io::Read;
let sent = self
.client
.post(&self.api)
.header("Authorization", format!("Bearer {}", self.key))
.header("Accept", "application/json")
.header("Content-Type", "application/json")
.body(serde_json::json!({ "title": title, "body": body }).to_string())
.send();
let response = sent.map_err(|_| Failure::Uncertain)?;
let status = response.status().as_u16();
let retry_after = response.headers().get("Retry-After").and_then(|v| v.to_str().ok()).map(str::to_owned);
let mut raw = Vec::new();
let read = response.take(MAX_RESPONSE as u64 + 1).read_to_end(&mut raw).is_ok() && raw.len() <= MAX_RESPONSE;
classify(status, retry_after.as_deref(), read.then_some(raw.as_slice()))
}
}
/// A report: `COABUG1\n<title>\n<body>`, checked as the world writes it.
pub struct Report {
pub digest: String,
pub marker: String,
pub title: String,
pub body: String,
}
pub fn read_report(path: &Path) -> Result<Report> {
let bad = || Error::Invalid("Invalid report file".into());
let key = path.file_stem().and_then(|s| s.to_str()).ok_or_else(bad)?;
let meta = std::fs::symlink_metadata(path)?;
if !valid_key(key) || meta.file_type().is_symlink() || meta.len() > MAX_FILE {
return Err(bad());
}
let raw = std::fs::read(path)?;
let text = String::from_utf8(raw.clone()).map_err(|_| bad())?.replace("\r\n", "\n");
let rest = text.strip_prefix("COABUG1\n").ok_or_else(|| Error::Invalid("Unsupported report format".into()))?;
let invalid = || Error::Invalid("Invalid report content".into());
let (title, body) = rest.split_once('\n').ok_or_else(invalid)?;
if !(3..=200).contains(&title.len())
|| body.trim().is_empty()
|| title.chars().any(|c| (c as u32) < 32)
|| body.chars().any(|c| (c as u32) < 32 && !matches!(c, '\r' | '\n' | '\t'))
{
return Err(invalid());
}
let digest = hex(&Sha256::digest(&raw));
let id = hex(&Sha256::digest(format!("{key}:{digest}").as_bytes()));
Ok(Report { digest, marker: format!("<!-- coa-report:{id} -->"), title: title.into(), body: body.into() })
}
fn hex(bytes: &[u8]) -> String {
bytes.iter().map(|b| format!("{b:02x}")).collect()
}
/// `<key>.status`: what the world shows the player (`queued`, `created|<issue>`, `failed`, ...).
pub fn write_status(spool: &Path, key: &str, state: &str, number: Option<u64>) -> Result<()> {
let value = match (state, number) {
("created", Some(n)) => format!("created|{n}"),
("created", None) => "created|None".into(),
_ => state.to_string(),
};
let data = format!("{value}\n");
let destination = spool.join(format!("{key}.status"));
if std::fs::read(&destination).is_ok_and(|d| d == data.as_bytes()) {
return Ok(());
}
crate::fsx::atomic_write(&destination, data.as_bytes())
}
fn now() -> f64 {
SystemTime::now().duration_since(UNIX_EPOCH).map(|d| d.as_secs_f64()).unwrap_or(0.0)
}
/// The delivery journal of one spool.
pub struct Relay<S: Service> {
spool: PathBuf,
service: S,
db: Connection,
clock: Box<dyn Fn() -> f64 + Send>,
}
impl<S: Service> Relay<S> {
pub fn open(spool: &Path, service: S) -> Result<Relay<S>> {
Self::with_clock(spool, service, Box::new(now))
}
pub fn with_clock(spool: &Path, service: S, clock: Box<dyn Fn() -> f64 + Send>) -> Result<Relay<S>> {
let db = Connection::open(spool.join("relay.sqlite3")).map_err(sql)?;
db.execute_batch(
"PRAGMA synchronous=FULL;
CREATE TABLE IF NOT EXISTS deliveries (
key TEXT PRIMARY KEY, digest TEXT NOT NULL, marker TEXT NOT NULL, state TEXT NOT NULL,
number INTEGER, attempted REAL NOT NULL DEFAULT 0, next_try REAL NOT NULL DEFAULT 0
);
CREATE TABLE IF NOT EXISTS settings (key TEXT PRIMARY KEY, value REAL NOT NULL);
UPDATE deliveries SET state='uncertain' WHERE state='posting';",
)
.map_err(sql)?;
Ok(Relay { spool: spool.into(), service, db, clock })
}
fn set_state(&self, key: &str, state: &str, number: Option<u64>, delay: u64) -> Result<()> {
self.db
.execute(
"UPDATE deliveries SET state=?1, number=?2, next_try=?3 WHERE key=?4",
params![state, number.map(|n| n as i64), (self.clock)() + delay as f64, key],
)
.map_err(sql)?;
write_status(&self.spool, key, state, number)
}
fn set_network_gate(&self, delay: u64) -> Result<()> {
self.db
.execute("INSERT OR REPLACE INTO settings VALUES('next_network',?1)", params![(self.clock)() + delay as f64])
.map_err(sql)?;
Ok(())
}
/// Handle one report file; returns its delivery state.
pub fn process(&self, path: &Path) -> Result<String> {
let Some(key) = path.file_stem().and_then(|s| s.to_str()).filter(|k| valid_key(k)) else {
return Ok("ignored".into());
};
let report = match read_report(path) {
Ok(r) => r,
Err(_) => {
write_status(&self.spool, key, "failed", None)?;
return Ok("failed".into());
}
};
self.db
.execute(
"INSERT OR IGNORE INTO deliveries(key,digest,marker,state) VALUES(?1,?2,?3,'queued')",
params![key, report.digest, report.marker],
)
.map_err(sql)?;
let (digest, row_state, number, next_try): (String, String, Option<i64>, f64) = self
.db
.query_row("SELECT digest, state, number, next_try FROM deliveries WHERE key=?1", params![key], |r| {
Ok((r.get(0)?, r.get(1)?, r.get(2)?, r.get(3)?))
})
.map_err(sql)?;
let number = number.map(|n| n as u64);
if digest != report.digest {
// Never replace an existing delivery or publish edited content under the same ID.
write_status(&self.spool, key, "failed", None)?;
return Ok("changed".into());
}
if matches!(row_state.as_str(), "created" | "failed" | "uncertain") {
write_status(&self.spool, key, &row_state, number)?;
return Ok(row_state);
}
if next_try > (self.clock)() {
write_status(&self.spool, key, &row_state, None)?;
return Ok(row_state);
}
let gate: Option<f64> = self
.db
.query_row("SELECT value FROM settings WHERE key='next_network'", [], |r| r.get(0))
.optional()
.map_err(sql)?;
if gate.is_some_and(|g| g > (self.clock)()) {
write_status(&self.spool, key, &row_state, None)?;
return Ok(row_state);
}
self.set_network_gate(5)?;
// A crash after this point needs review: the service's duplicate cache can reset on deploy.
self.db
.execute("UPDATE deliveries SET state='posting', attempted=?1 WHERE key=?2", params![(self.clock)(), key])
.map_err(sql)?;
match self.service.create(&report.title, &report.body) {
Ok(n) => {
self.set_state(key, "created", Some(n), 0)?;
Ok("created".into())
}
Err(failure) => {
let (state, delay) = match failure {
Failure::Limited(d) | Failure::Pending(d) => ("queued", d),
Failure::Blocked(d) => ("blocked", d),
Failure::Invalid => ("failed", 300),
Failure::Uncertain => ("uncertain", 300),
};
self.set_state(key, state, None, delay)?;
if let Failure::Limited(d) | Failure::Blocked(d) = failure {
self.set_network_gate(d)?;
}
Ok(state.into())
}
}
}
/// One pass over the spool, in name order.
pub fn pass(&self) -> Result<()> {
let mut reports: Vec<PathBuf> = std::fs::read_dir(&self.spool)?
.flatten()
.map(|e| e.path())
.filter(|p| p.extension().is_some_and(|x| x == "report"))
.collect();
reports.sort();
for path in reports {
self.process(&path)?;
}
Ok(())
}
}
fn sql(e: rusqlite::Error) -> Error {
Error::Invalid(format!("The bug-report journal failed ({e})."))
}
/// `relay-worker`: deliver reports until the supervisor asks the relay to stop (`.state/stop-relay`).
pub fn worker(root: &Path) -> Result<()> {
let spool = root.join("BugReport/reports");
std::fs::create_dir_all(&spool)?;
let _lock = state::FileLock::try_acquire(&spool.join("relay.lock"))?
.ok_or_else(|| Error::Invalid("Another bug-report relay is already using this spool.".into()))?;
let key = std::env::var("COA_BUGREPORT_API_KEY").unwrap_or_else(|_| DEFAULT_API_KEY.into());
let relay = Relay::open(&spool, ReportService::new(SERVICE_URL, &key)?)?;
state::record(root, "relay-ready", std::process::id())?;
println!("Bug-report relay ready. Waiting for in-game reports.");
let stop = state::dir(root).join("stop-relay");
while !stop.exists() {
relay.pass()?;
for _ in 0..10 {
if stop.exists() {
return Ok(());
}
std::thread::sleep(Duration::from_millis(500));
}
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::{Arc, Mutex};
type Answers = Arc<Mutex<Vec<std::result::Result<u64, Failure>>>>;
struct Fake(Answers, Arc<Mutex<u32>>);
impl Service for Fake {
fn create(&self, _: &str, _: &str) -> std::result::Result<u64, Failure> {
*self.1.lock().unwrap() += 1;
self.0.lock().unwrap().remove(0)
}
}
fn report(spool: &Path, key: &str, text: &str) -> PathBuf {
let p = spool.join(format!("{key}.report"));
std::fs::write(&p, text).unwrap();
p
}
#[test]
fn keys_follow_the_world_format() {
assert!(valid_key("1-0123456789abcdef"));
assert!(valid_key("4294967295-0123456789abcdef0123456789abcdef0123456789abcdef"));
for bad in ["0-0123456789abcdef", "1-0123456789abcde", "1-0123456789ABCDEF", "12345678901-0123456789abcdef", "x"] {
assert!(!valid_key(bad), "{bad}");
}
}
#[test]
fn service_answers_map_like_relay_py() {
let ok = format!(r#"{{"status":"created","issue_number":12,"issue_url":"https://github.com/{REPOSITORY}/issues/12"}}"#);
let cases: Vec<(u16, Option<&str>, Option<&[u8]>, std::result::Result<u64, Failure>)> = vec![
(201, None, Some(ok.as_bytes()), Ok(12)),
(200, None, Some(ok.as_bytes()), Ok(12)),
(201, None, Some(br#"{"status":"created","issue_number":12,"issue_url":"https://evil/12"}"#), Err(Failure::Uncertain)),
(201, None, Some(br#"{"status":"created","issue_number":0,"issue_url":"x"}"#), Err(Failure::Uncertain)),
(201, None, Some(b"[1]"), Err(Failure::Uncertain)),
(201, None, None, Err(Failure::Uncertain)),
(202, Some("7"), Some(br#"{"status":"pending"}"#), Err(Failure::Pending(7))),
(202, None, Some(br#"{"status":"pending"}"#), Err(Failure::Pending(2))),
(202, None, Some(br#"{"status":"other"}"#), Err(Failure::Uncertain)),
(429, Some("999999"), None, Err(Failure::Limited(86400))),
(429, Some("0"), None, Err(Failure::Limited(1))),
(429, Some("soon"), None, Err(Failure::Limited(300))),
(422, None, None, Err(Failure::Invalid)),
(302, None, None, Err(Failure::Blocked(300))),
(401, None, None, Err(Failure::Blocked(300))),
(503, Some("30"), Some(br#"{"status":"failed","error":"github_access_denied"}"#), Err(Failure::Blocked(30))),
(503, None, Some(b"{}"), Err(Failure::Uncertain)),
(500, None, None, Err(Failure::Uncertain)),
];
for (i, (status, retry, body, expected)) in cases.into_iter().enumerate() {
assert_eq!(classify(status, retry, body), expected, "case {i}");
}
assert!(json_object(Some(&vec![b' '; MAX_RESPONSE + 1])).is_none(), "oversized answers are refused");
assert!(ReportService::new(SERVICE_URL, "has space").is_err());
assert!(ReportService::new(SERVICE_URL, "coa_key").is_ok());
}
#[test]
fn a_report_is_checked_and_identified_like_relay_py() {
let d = tempfile::tempdir().unwrap();
let p = report(d.path(), "7-0123456789abcdef", "COABUG1\r\nBroken quest\r\nThe NPC is missing.\r\n");
let r = read_report(&p).unwrap();
assert_eq!(r.title, "Broken quest");
assert_eq!(r.body, "The NPC is missing.\n");
assert_eq!(r.digest, hex(&Sha256::digest(std::fs::read(&p).unwrap())));
assert!(r.marker.starts_with("<!-- coa-report:") && r.marker.len() == 16 + 64 + 4);
for bad in ["COABUG2\nTitle\nBody", "COABUG1\nab\nBody", "COABUG1\nTitle\n \n", "COABUG1\nTi\u{7}tle\nBody", "COABUG1\nTitle"] {
std::fs::write(&p, bad).unwrap();
assert!(read_report(&p).is_err(), "{bad:?}");
}
}
#[test]
fn deliveries_follow_the_journal() {
let d = tempfile::tempdir().unwrap();
let spool = d.path();
let t = Arc::new(Mutex::new(1000.0f64));
let calls = Arc::new(Mutex::new(0));
let answers: Answers = Arc::new(Mutex::new(vec![Err(Failure::Limited(60)), Ok(42)]));
let clock = t.clone();
let relay = Relay::with_clock(spool, Fake(answers, calls.clone()), Box::new(move || *clock.lock().unwrap())).unwrap();
let p = report(spool, "7-0123456789abcdef", "COABUG1\nBroken quest\nThe NPC is missing.\n");
let status = || std::fs::read_to_string(spool.join("7-0123456789abcdef.status")).unwrap();
assert_eq!(relay.process(&p).unwrap(), "queued", "429 keeps it queued");
assert_eq!(status(), "queued\n");
assert_eq!(relay.process(&p).unwrap(), "queued", "not before its retry time");
assert_eq!(*calls.lock().unwrap(), 1);
*t.lock().unwrap() += 61.0;
assert_eq!(relay.process(&p).unwrap(), "created");
assert_eq!(status(), "created|42\n");
assert_eq!(relay.process(&p).unwrap(), "created", "never sent twice");
assert_eq!(*calls.lock().unwrap(), 2);
std::fs::write(&p, "COABUG1\nBroken quest\nEdited.\n").unwrap();
assert_eq!(relay.process(&p).unwrap(), "changed");
relay
.db
.execute("INSERT INTO deliveries(key,digest,marker,state) VALUES('8-0123456789abcdef','x','m','posting')", [])
.unwrap();
drop(relay);
let reopened = Relay::open(spool, Fake(Arc::new(Mutex::new(vec![])), calls.clone())).unwrap();
let state: String =
reopened.db.query_row("SELECT state FROM deliveries WHERE key='8-0123456789abcdef'", [], |r| r.get(0)).unwrap();
assert_eq!(state, "uncertain", "an interrupted post is never retried");
}
#[test]
fn a_second_worker_cannot_take_the_spool() {
let d = tempfile::tempdir().unwrap();
let first = state::FileLock::try_acquire(&d.path().join("relay.lock")).unwrap();
assert!(first.is_some());
assert!(state::FileLock::try_acquire(&d.path().join("relay.lock")).unwrap().is_none());
drop(first);
assert!(state::FileLock::try_acquire(&d.path().join("relay.lock")).unwrap().is_some());
}
}
+271
View File
@@ -0,0 +1,271 @@
//! `prepare`: the configuration files a repack runs with, rendered from `Settings/*.template` and
//! `Settings/repack.json` (`manage.py prepare()`), byte for byte the same.
use std::path::{Path, PathBuf};
use crate::error::{Error, Result};
use crate::launcher::{settings::Settings, state};
/// Services whose running process blocks moving the folder or changing ports.
const SERVICES: [&str; 5] = ["mysql", "auth", "world", "supervisor", "relay"];
/// The root as the servers see it: forward slashes, and the short (8.3) form when the real one has non-Latin
/// letters, which MySQL and the servers do not read reliably from their config files.
pub fn native_root(root: &Path) -> Result<String> {
let mut value = root.to_string_lossy().into_owned();
if !value.is_ascii() {
if let Some(short) = sys::short_path(root) {
value = short;
}
}
if !value.is_ascii() {
return Err(Error::Invalid(
"Extract the repack to a path with Latin letters, such as C:\\Games\\CoA-Repack.".into(),
));
}
Ok(value.replace('\\', "/"))
}
/// Text as Python's text mode reads it: strict UTF-8, Windows and old Mac line ends turned into "\n".
fn read_text(path: &Path) -> Result<String> {
let bytes = std::fs::read(path)?;
let text = String::from_utf8(bytes).map_err(|_| Error::Invalid(format!("{} is not UTF-8 text.", path.display())))?;
Ok(text.replace("\r\n", "\n").replace('\r', "\n"))
}
/// Text written as Python's text mode writes it on Windows: "\n" becomes "\r\n".
fn windows_text(text: &str) -> Vec<u8> {
if cfg!(windows) {
text.replace('\n', "\r\n").into_bytes()
} else {
text.as_bytes().to_vec()
}
}
fn placeholders(line: &str) -> Vec<String> {
let mut out = Vec::new();
let bytes = line.as_bytes();
let mut i = 0;
while i < bytes.len() {
if bytes[i] == b'@' {
let mut j = i + 1;
while j < bytes.len() && (bytes[j].is_ascii_alphabetic() || bytes[j] == b'_') {
j += 1;
}
if j < bytes.len() && j > i + 1 && bytes[j] == b'@' {
out.push(line[i..=j].to_string());
i = j + 1;
continue;
}
}
i += 1;
}
out
}
fn credentials(root: &Path) -> Result<(String, String)> {
let v: serde_json::Value = crate::fsx::read_json(&root.join("Settings/database.json"))?;
let good = |k: &str| {
v.get(k)
.and_then(|x| x.as_str())
.filter(|s| s.len() == 48 && s.bytes().all(|b| b.is_ascii_digit() || (b'a'..=b'f').contains(&b)))
.map(str::to_string)
};
match (good("rootPassword"), good("appPassword")) {
(Some(r), Some(a)) => Ok((r, a)),
_ => Err(Error::Invalid("Invalid packaged database configuration.".into())),
}
}
/// Render every file the repack's services read. Refuses while a service runs and the folder or the ports
/// changed since the last render.
pub fn prepare(root: &Path, config: &Settings) -> Result<Vec<PathBuf>> {
let base = native_root(root)?;
let signature = serde_json::json!({
"root": root.to_string_lossy(),
"ports": serde_json::Value::Object(config.port_map()),
});
let previous = state::dir(root).join("configuration.json");
if previous.exists() {
let recorded: Option<serde_json::Value> = crate::fsx::read_json(&previous).ok();
if recorded.as_ref() != Some(&signature) && SERVICES.iter().any(|s| state::running(root, s).is_some()) {
return Err(Error::Invalid("Stop this repack before moving its folder or changing its ports.".into()));
}
}
let (root_password, app_password) = credentials(root)?;
for folder in ["Core/configs/modules", "Core/Logs", "BugReport/reports", "BugReport/Logs", "mysql/logs", ".state"] {
std::fs::create_dir_all(root.join(folder))?;
}
let mysql_port = config.mysql_port;
let mut values: Vec<(&str, String)> = vec![
("DATA", format!("{base}/Data")),
("LOGS", format!("{base}/Core/Logs")),
("ASCENSION_DBC", format!("{base}/Data/dbc/Ascension")),
("MYSQL_EXE", format!("{base}/mysql/bin/mysql.exe")),
("AUTH_PORT", config.auth_port.to_string()),
("WORLD_PORT", config.world_port.to_string()),
("RA_PORT", config.ra_port.to_string()),
];
for (key, db) in [
("LoginDatabaseInfo", "acore_auth"),
("WorldDatabaseInfo", config.realm.world_db),
("CharacterDatabaseInfo", config.realm.characters_db),
] {
values.push((key, format!("127.0.0.1;{mysql_port};acore;{app_password};{db}")));
}
let mut written = Vec::new();
for (name, target) in [
("authserver.conf", "Core/configs/authserver.conf"),
("worldserver.conf", "Core/configs/worldserver.conf"),
("mod_ascension_compat.conf", "Core/configs/modules/mod_ascension_compat.conf"),
] {
let mut text = read_text(&root.join("Settings").join(format!("{name}.template")))?;
for (key, value) in &values {
text = text.replace(&format!("@{key}@"), value);
}
let mut unresolved: Vec<String> = text
.split('\n')
.filter(|l| !l.trim().is_empty() && !l.trim_start().starts_with('#'))
.flat_map(placeholders)
.collect();
unresolved.sort();
unresolved.dedup();
if !unresolved.is_empty() {
return Err(Error::Service(
crate::error::ErrorCode::InvalidConfigValue,
format!("An unresolved placeholder remains in Settings/{name}.template: {}", unresolved.join(", ")),
));
}
// these three keep "\n" (Python wrote them with newline="\n")
std::fs::write(root.join(target), text.as_bytes())?;
written.push(root.join(target));
}
let files: [(&str, String); 3] = [
(
"Core/configs/modules/coa_bugreport.conf",
format!(
"# Managed by the repack launcher. Enabled whenever worldserver starts.\nCoABugReport.Enable = 1\nCoABugReport.SpoolDirectory = \"{base}/BugReport/reports\"\nCoABugReport.CooldownSeconds = 120\n"
),
),
(
"mysql/my.ini",
format!(
"[mysqld]\nbasedir=\"{base}/mysql\"\ndatadir=\"{base}/mysql/data\"\nport={mysql_port}\nbind-address=127.0.0.1\nmysqlx=0\ncharacter-set-server=utf8mb4\ncollation-server=utf8mb4_unicode_ci\nmax_allowed_packet=128M\ninnodb_buffer_pool_size=256M\nskip-log-bin\nlog-error=\"{base}/mysql/logs/mysql-error.log\"\npid-file=\"{base}/mysql/mysql.pid\"\n"
),
),
(
"mysql/admin-client.ini",
format!(
"[client]\nuser=root\npassword={root_password}\nhost=127.0.0.1\nport={mysql_port}\nprotocol=tcp\ndefault-character-set=utf8mb4\n"
),
),
];
for (rel, text) in files {
std::fs::write(root.join(rel), windows_text(&text))?;
written.push(root.join(rel));
}
state::write_json(&previous, &signature)?;
Ok(written)
}
#[cfg(windows)]
mod sys {
use std::os::windows::ffi::OsStrExt;
use std::path::Path;
use windows_sys::Win32::Storage::FileSystem::GetShortPathNameW;
pub fn short_path(path: &Path) -> Option<String> {
let wide: Vec<u16> = path.as_os_str().encode_wide().chain(Some(0)).collect();
let mut buf = vec![0u16; 32768];
let n = unsafe { GetShortPathNameW(wide.as_ptr(), buf.as_mut_ptr(), buf.len() as u32) };
(n > 0 && (n as usize) < buf.len()).then(|| String::from_utf16_lossy(&buf[..n as usize]))
}
}
#[cfg(not(windows))]
mod sys {
pub fn short_path(_: &std::path::Path) -> Option<String> {
None
}
}
#[cfg(test)]
mod tests {
use super::*;
pub(crate) fn fixture(root: &Path) {
let w = |rel: &str, text: &[u8]| {
let p = root.join(rel);
std::fs::create_dir_all(p.parent().unwrap()).unwrap();
std::fs::write(p, text).unwrap();
};
w("Settings/repack.json", br#"{"authPort": 3724, "mysqlPort": 3307, "raPassword": "e0c39beaa5c14128", "raPort": 3443, "raUsername": "COAMANAGER", "worldPort": 8085}"#);
w("Settings/database.json", format!(r#"{{"rootPassword": "{}", "appPassword": "{}"}}"#, "a".repeat(48), "0123456789abcdef".repeat(3)).as_bytes());
w("Settings/authserver.conf.template", b"[authserver]\r\nLoginDatabaseInfo = \"@LoginDatabaseInfo@\"\r\nRealmServerPort = @AUTH_PORT@\r\nLogsDir = \"@LOGS@\"\r\n# @NOT_A_VALUE@ in a comment is fine\r\n");
w("Settings/worldserver.conf.template", "[worldserver]\nDataDir = \"@DATA@\"\nWorldServerPort = @WORLD_PORT@\nRa.Port = @RA_PORT@\nWorldDatabaseInfo = \"@WorldDatabaseInfo@\"\nCharacterDatabaseInfo = \"@CharacterDatabaseInfo@\"\nMySQLExecutable = \"@MYSQL_EXE@\"\nMotd = \"Ünïcode stays\"\n".as_bytes());
w("Settings/mod_ascension_compat.conf.template", b"Ascension.DbcDir = \"@ASCENSION_DBC@\"\rOld.Mac = 1\r");
}
#[test]
fn placeholders_left_outside_comments_are_refused() {
let d = tempfile::tempdir().unwrap();
fixture(d.path());
std::fs::write(d.path().join("Settings/worldserver.conf.template"), "A = @UNKNOWN@\n").unwrap();
let cfg = Settings::load(d.path(), 0).unwrap();
let err = prepare(d.path(), &cfg).unwrap_err().to_string();
assert!(err.contains("worldserver.conf.template: @UNKNOWN@"), "{err}");
}
#[test]
fn a_bad_password_file_is_refused() {
let d = tempfile::tempdir().unwrap();
fixture(d.path());
std::fs::write(d.path().join("Settings/database.json"), r#"{"rootPassword":"short","appPassword":"x"}"#).unwrap();
let cfg = Settings::load(d.path(), 0).unwrap();
assert!(prepare(d.path(), &cfg).unwrap_err().to_string().contains("Invalid packaged database configuration"));
}
/// Byte-for-byte the same files as the Python launcher. COA_MANAGE_PY = a manage.py to compare with (taken from
/// coa-server-build); skipped without it.
#[test]
fn renders_exactly_what_manage_py_renders() {
let Ok(manage) = std::env::var("COA_MANAGE_PY") else { return };
let python = std::env::var("COA_PYTHON").unwrap_or_else(|_| "python".into());
let rust = tempfile::tempdir().unwrap();
let py = tempfile::tempdir().unwrap();
for d in [rust.path(), py.path()] {
fixture(d);
}
std::fs::create_dir_all(py.path().join("Scripts")).unwrap();
std::fs::copy(&manage, py.path().join("Scripts/manage.py")).unwrap();
// manage.py imports squid_playerbots lazily; prepare does not need it.
let out = std::process::Command::new(&python)
.args(["-I", "-B"])
.arg(py.path().join("Scripts/manage.py"))
.arg("prepare")
.output()
.unwrap();
assert!(out.status.success(), "{}{}", String::from_utf8_lossy(&out.stdout), String::from_utf8_lossy(&out.stderr));
let cfg = Settings::load(rust.path(), 0).unwrap();
let written = prepare(rust.path(), &cfg).unwrap();
let root_text = |p: &Path, base: &Path| {
let n = native_root(base).unwrap();
String::from_utf8(std::fs::read(p).unwrap()).unwrap().replace(&n, "<ROOT>")
};
for file in &written {
let rel = file.strip_prefix(rust.path()).unwrap();
assert_eq!(
root_text(file, rust.path()),
root_text(&py.path().join(rel), py.path()),
"{} differs",
rel.display()
);
}
let sig = |base: &Path| -> serde_json::Value {
let mut v: serde_json::Value = crate::fsx::read_json(&base.join(".state/configuration.json")).unwrap();
v["root"] = serde_json::Value::Null;
v
};
assert_eq!(sig(rust.path()), sig(py.path()));
}
}
+571
View File
@@ -0,0 +1,571 @@
//! Starting, checking and stopping the services of one repack: MySQL, authserver, worldserver
//! (`manage.py start_mysql`, `start_auth`, `stop_all` and their helpers), with the same rules.
use std::net::{SocketAddr, TcpStream};
use std::path::{Path, PathBuf};
use std::process::{Command, Stdio};
use std::time::{Duration, Instant};
use crate::error::{Error, ErrorCode, Result};
use crate::launcher::{settings::Settings, state};
use crate::process::ProcessIdentity;
pub type Progress<'a> = &'a dyn Fn(&str);
const CREATE_NO_WINDOW: u32 = 0x0800_0000;
const CREATE_NEW_PROCESS_GROUP: u32 = 0x0000_0200;
fn hidden(cmd: &mut Command) -> &mut Command {
#[cfg(windows)]
{
use std::os::windows::process::CommandExt;
cmd.creation_flags(CREATE_NO_WINDOW | CREATE_NEW_PROCESS_GROUP);
}
cmd
}
/// Start `exe` with its output appended to `log`, and record it as `name`. `env_remove` are variables of this
/// process the service must not see.
pub fn spawn(root: &Path, name: &str, exe: &Path, args: &[&str], cwd: &Path, log: &Path, env_remove: &[String]) -> Result<ProcessIdentity> {
let child = crate::launcher::spawn::start(exe, args, cwd, log, env_remove)?;
state::record(root, name, child.pid)
}
// ---------------------------------------------------------------------------------------------------------------
// Ports
// ---------------------------------------------------------------------------------------------------------------
/// Wait (up to 30 s) until `port` can be bound by a new server. A port with a listening owner is refused at
/// once; a port Windows still holds for a stopped process (a PID-zero row) is waited for. The test bind is
/// exclusive (`SO_EXCLUSIVEADDRUSE`), never a shared one.
pub fn ensure_free(port: u16, progress: Progress) -> Result<()> {
let deadline = Instant::now() + Duration::from_secs(30);
let mut announced = false;
loop {
let mut owners: Vec<u32> = sys::tcp_rows_v4()
.into_iter()
.filter(|r| r.state == sys::LISTEN && r.local_port == port)
.map(|r| r.pid)
.collect();
owners.sort_unstable();
owners.dedup();
if owners.iter().any(|p| *p != 0) {
let list: Vec<String> = owners.iter().map(u32::to_string).collect();
return Err(Error::Service(
ErrorCode::PortInUse,
format!("Port {port} is already used (PID {}). Stop the other server or change Settings/repack.json.", list.join(", ")),
));
}
match sys::exclusive_bind(port) {
Ok(()) => return Ok(()),
Err(code) if code == 10013 || code == 10048 => {
if Instant::now() >= deadline {
return Err(Error::Invalid(format!(
"Port {port} remains unavailable after 30 seconds (Windows bind error {code}). No process was stopped. Retry after the previous database shutdown has finished, or check the Windows port reservation."
)));
}
if !announced {
progress(&format!("Waiting for Windows to release port {port}..."));
announced = true;
}
std::thread::sleep(Duration::from_millis(250));
}
Err(code) => return Err(Error::Invalid(format!("Port {port} cannot be checked (Windows error {code})."))),
}
}
}
/// Is the recorded process of `name` serving `port`? Its listener row is the evidence; when a system does not
/// show the owner of a listener, the server side of a fresh loopback connection is (never for MySQL, whose
/// listener has always been visible and which should not get stray connections).
pub fn ready(root: &Path, name: &str, port: u16) -> bool {
let Some(record) = state::running(root, name) else { return false };
let listening = sys::tcp_rows_v4().iter().any(|r| r.state == sys::LISTEN && r.local_port == port && r.pid == record.pid);
if listening {
return crate::process::is_alive(&record);
}
if name == "mysql" {
return false;
}
accepted_by(port, record.pid) && crate::process::is_alive(&record)
}
/// Connect to 127.0.0.1:`port` and check that exactly one established server-side row, owned by `pid`, answers
/// that connection.
fn accepted_by(port: u16, pid: u32) -> bool {
let addr: SocketAddr = ([127, 0, 0, 1], port).into();
let Ok(client) = TcpStream::connect_timeout(&addr, Duration::from_millis(500)) else { return false };
let Ok(mine) = client.local_addr().map(|a| a.port()) else { return false };
let me = std::process::id();
let rows: Vec<sys::TcpRow> = sys::tcp_rows_v4()
.into_iter()
.chain(sys::tcp_rows_v6())
.filter(|r| r.remote_port == mine && r.remote_loopback && !(r.local_port == mine && r.pid == me))
.collect();
rows.len() == 1 && rows[0].state == sys::ESTABLISHED && rows[0].pid == pid
}
pub fn wait_ready(root: &Path, name: &str, port: u16, seconds: u64) -> Result<()> {
let until = Instant::now() + Duration::from_secs(seconds);
while Instant::now() < until {
if ready(root, name, port) {
return Ok(());
}
if state::running(root, name).is_none() {
return Err(Error::Service(ErrorCode::StartupFailed, format!("{name} stopped during startup. Check its log.")));
}
std::thread::sleep(Duration::from_millis(500));
}
Err(Error::Service(
ErrorCode::StartupFailed,
format!("{name} is still starting: its expected TCP listener on port {port} was not found; check its log."),
))
}
// ---------------------------------------------------------------------------------------------------------------
// MySQL client
// ---------------------------------------------------------------------------------------------------------------
/// Run SQL (or a `mysqladmin` command) with the repack's own client and administrator login.
pub fn mysql(root: &Path, sql: Option<&str>, admin: Option<&str>) -> Result<String> {
let exe = root.join(if admin.is_some() { "mysql/bin/mysqladmin.exe" } else { "mysql/bin/mysql.exe" });
let defaults = format!("--defaults-file={}", root.join("mysql/admin-client.ini").display());
let mut cmd = Command::new(exe);
hidden(&mut cmd).arg(defaults);
match admin {
Some(a) => cmd.arg(a),
None => cmd.args(["--batch", "--skip-column-names"]),
};
let payload = sql.map(|s| s.as_bytes().to_vec());
let timeout = if payload.as_ref().is_some_and(|p| p.len() > 1024 * 1024) { 900 } else { 90 };
cmd.stdin(if payload.is_some() { Stdio::piped() } else { Stdio::null() }).stdout(Stdio::piped()).stderr(Stdio::piped());
let mut child = cmd.spawn()?;
if let (Some(data), Some(mut stdin)) = (payload, child.stdin.take()) {
std::thread::spawn(move || {
use std::io::Write;
let _ = stdin.write_all(&data);
});
}
// Both outputs are read while the client runs: a full pipe would stop it (and look like a timeout).
let read = |pipe: Option<Box<dyn std::io::Read + Send>>| {
std::thread::spawn(move || {
let mut buf = Vec::new();
if let Some(mut p) = pipe {
let _ = p.read_to_end(&mut buf);
}
buf
})
};
let out_reader = read(child.stdout.take().map(|p| Box::new(p) as Box<dyn std::io::Read + Send>));
let err_reader = read(child.stderr.take().map(|p| Box::new(p) as Box<dyn std::io::Read + Send>));
let started = Instant::now();
let failed = |stderr: &[u8]| {
let text = String::from_utf8_lossy(stderr);
let detail = text.lines().rev().find(|l| !l.trim().is_empty()).unwrap_or("").trim().to_string();
let mut message = "The repack database command failed; check mysql/logs/mysql-error.log.".to_string();
if !detail.is_empty() {
message.push_str(&format!(" ({detail})"));
}
Error::Invalid(message)
};
let status = loop {
if let Some(status) = child.try_wait()? {
break status;
}
if started.elapsed() > Duration::from_secs(timeout) {
let _ = child.kill();
let _ = child.wait();
let _ = out_reader.join();
return Err(failed(b"timed out"));
}
std::thread::sleep(Duration::from_millis(50));
};
let stdout = out_reader.join().unwrap_or_default();
let stderr = err_reader.join().unwrap_or_default();
if !status.success() {
return Err(failed(&stderr));
}
Ok(String::from_utf8_lossy(&stdout).trim().to_string())
}
// ---------------------------------------------------------------------------------------------------------------
// Start and stop
// ---------------------------------------------------------------------------------------------------------------
pub fn start_mysql(root: &Path, cfg: &Settings, progress: Progress) -> Result<()> {
if cfg.shared_database {
// An extra world uses the main folder's database; it must already run.
return mysql(root, None, Some("ping")).map(|_| ()).map_err(|e| {
Error::Service(ErrorCode::DatabaseNotRunning, format!("The main server's database is not running. {e}"))
});
}
if state::running(root, "mysql").is_some() {
wait_ready(root, "mysql", cfg.mysql_port, 300)?;
mysql(root, None, Some("ping"))?;
progress("MySQL is already running.");
return Ok(());
}
ensure_free(cfg.mysql_port, progress)?;
if !root.join("mysql/data/mysql").is_dir() {
return Err(Error::Service(ErrorCode::ServerFilesIncomplete, "The packaged database is missing. Extract the complete repack.".into()));
}
progress("Starting MySQL...");
let ini = format!("--defaults-file={}", root.join("mysql/my.ini").display());
spawn(root, "mysql", &root.join("mysql/bin/mysqld.exe"), &[&ini, "--no-monitor"], &root.join("mysql"), &root.join("mysql/logs/startup.log"), &cfg.env_remove)?;
wait_ready(root, "mysql", cfg.mysql_port, 300)?;
mysql(root, None, Some("ping"))?;
mysql(
root,
Some(&format!(
"UPDATE acore_auth.realmlist SET name='{}',address='127.0.0.1',localAddress='127.0.0.1',port={} WHERE id={};",
cfg.realm.name, cfg.world_port, cfg.realm.id
)),
None,
)?;
Ok(())
}
pub fn start_auth(root: &Path, cfg: &Settings, progress: Progress) -> Result<()> {
start_mysql(root, cfg, progress)?;
if state::running(root, "auth").is_some() {
wait_ready(root, "auth", cfg.auth_port, 60)?;
progress("Authserver is already running.");
return Ok(());
}
ensure_free(cfg.auth_port, progress)?;
// An interrupted world startup can leave flag 3, which authserver excludes.
mysql(root, Some(&format!("UPDATE acore_auth.realmlist SET flag=0 WHERE id={};", cfg.realm.id)), None)?;
progress("Starting authserver...");
spawn(root, "auth", &root.join("Core/authserver.exe"), &["-c", "configs/authserver.conf"], &root.join("Core"), &root.join("Core/Logs/auth-console.log"), &cfg.env_remove)?;
wait_ready(root, "auth", cfg.auth_port, 60)
}
/// Stop the recorded process, only if it is still that process.
pub fn terminate(record: &ProcessIdentity) -> Result<()> {
if !crate::process::is_alive(record) {
return Ok(());
}
sys::terminate(record)
}
pub fn wait_stopped(record: &ProcessIdentity, seconds: u64) -> bool {
let until = Instant::now() + Duration::from_secs(seconds);
while crate::process::is_alive(record) && Instant::now() < until {
std::thread::sleep(Duration::from_millis(250));
}
!crate::process::is_alive(record)
}
/// The recorded world, when it is this folder's own `Core/worldserver.exe` (never stop a process only because a
/// record names it).
fn owned_world(root: &Path) -> Result<Option<ProcessIdentity>> {
let Some(world) = state::running(root, "world") else { return Ok(None) };
let expected = root.join("Core/worldserver.exe");
let same = std::fs::canonicalize(&world.exe).ok().zip(std::fs::canonicalize(&expected).ok()).is_some_and(|(a, b)| a == b);
if !same {
return Err(Error::Invalid("World process ownership could not be verified; the database was left running.".into()));
}
Ok(Some(world))
}
/// Ask the world's console for a graceful shutdown. False when the console is not this world's or does not answer.
fn ask_shutdown(root: &Path, cfg: &Settings) -> bool {
ready(root, "world", cfg.ra_port)
&& crate::ra::Ra::connect_to(cfg.ra_port, &cfg.ra_username, &cfg.ra_password)
.and_then(|ra| ra.send_without_answer("server shutdown 1s 0"))
.is_ok()
}
/// Stop this folder's world without its console (unsaved progress since the last save is lost).
fn stop_world_process(world: &ProcessIdentity) -> Result<()> {
terminate(world).map_err(|_| Error::Invalid("Worldserver could not be stopped safely; its database was left running.".into()))?;
if !wait_stopped(world, 90) {
return Err(Error::Invalid("Worldserver is still stopping; its database was left running.".into()));
}
Ok(())
}
/// Stop the world at once, then everything else as [`stop_all`] does. Only when the user asked for it.
pub fn force_stop_all(root: &Path, cfg: &Settings, progress: Progress) -> Result<()> {
if let Some(world) = owned_world(root)? {
stop_world_process(&world)?;
progress("Force-stopped this server's verified world process; unsaved progress may be lost.");
}
stop_all(root, cfg, progress)
}
/// Stop everything of this repack, world first (gracefully through its console), its database last. An extra
/// world leaves the shared database alone.
pub fn stop_all(root: &Path, cfg: &Settings, progress: Progress) -> Result<()> {
if let Some(world) = owned_world(root)? {
if ask_shutdown(root, cfg) {
progress("Graceful world shutdown requested.");
} else {
progress("World console unavailable; stopping this repack's recorded world process.");
stop_world_process(&world)?;
}
// A console request can be lost (seen when a client disconnected at once). While the world still runs
// and its console still answers, it has not begun to stop: ask again. Asking twice is harmless.
let mut stopped = wait_stopped(&world, 15);
for _ in 0..2 {
if stopped {
break;
}
if ask_shutdown(root, cfg) {
progress("The world has not begun to stop; shutdown requested again.");
}
stopped = wait_stopped(&world, 15);
}
if !stopped && !wait_stopped(&world, 45) {
return Err(Error::Invalid("Worldserver is still stopping; its database has been left running.".into()));
}
}
if let Some(supervisor) = state::running(root, "supervisor") {
if !wait_stopped(&supervisor, 45) {
return Err(Error::Invalid("The report relay is still finishing a request. Try Stop All again shortly.".into()));
}
}
if let Some(relay) = state::running(root, "relay") {
std::fs::write(state::dir(root).join("stop-relay"), b"")?;
if !wait_stopped(&relay, 40) {
return Err(Error::Invalid("The report relay did not finish; it was left running for recovery.".into()));
}
}
if let Some(auth) = state::running(root, "auth") {
terminate(&auth)?;
if !wait_stopped(&auth, 10) {
return Err(Error::Invalid("Authserver did not stop.".into()));
}
}
if let Some(database) = state::running(root, "mysql").filter(|_| !cfg.shared_database) {
let shutdown = mysql(root, None, Some("shutdown"));
if !wait_stopped(&database, 60) {
shutdown?;
return Err(Error::Invalid("MySQL is still stopping; wait before copying the repack.".into()));
}
}
progress("All services from this repack are stopped. It is safe to move or copy this folder.");
Ok(())
}
/// Which services run (`manage.py status-json`).
pub fn status(root: &Path) -> serde_json::Value {
let mut out = serde_json::Map::new();
for name in ["mysql", "auth", "world", "relay"] {
out.insert(name.into(), state::running(root, name).is_some().into());
}
let debug: bool = crate::fsx::read_json::<serde_json::Value>(&state::dir(root).join("debug-logs.json"))
.ok()
.and_then(|v| v.get("enabled").and_then(|e| e.as_bool()))
.unwrap_or(false);
out.insert("debugLogs".into(), debug.into());
serde_json::Value::Object(out)
}
pub fn log_path(root: &Path, name: &str) -> PathBuf {
match name {
"mysql" => root.join("mysql/logs/startup.log"),
"auth" => root.join("Core/Logs/auth-console.log"),
"world" => root.join("Core/Logs/world-console.log"),
"supervisor" => root.join("Core/Logs/supervisor.log"),
_ => root.join("BugReport/Logs/relay.log"),
}
}
// ---------------------------------------------------------------------------------------------------------------
// Windows
// ---------------------------------------------------------------------------------------------------------------
#[cfg(windows)]
mod sys {
use crate::error::{Error, Result};
use crate::process::ProcessIdentity;
use windows_sys::Win32::Foundation::CloseHandle;
use windows_sys::Win32::NetworkManagement::IpHelper::GetExtendedTcpTable;
use windows_sys::Win32::Networking::WinSock::{setsockopt, SOL_SOCKET, SO_EXCLUSIVEADDRUSE};
use windows_sys::Win32::System::Threading::{OpenProcess, TerminateProcess, PROCESS_QUERY_LIMITED_INFORMATION, PROCESS_TERMINATE};
pub const LISTEN: u32 = 2;
pub const ESTABLISHED: u32 = 5;
pub struct TcpRow {
pub state: u32,
pub local_port: u16,
pub remote_port: u16,
pub remote_loopback: bool,
pub pid: u32,
}
fn table(af: u32) -> Vec<u8> {
const TCP_TABLE_OWNER_PID_ALL: i32 = 5;
let mut size = 0u32;
let mut buf: Vec<u8> = Vec::new();
for _ in 0..4 {
let code = unsafe {
GetExtendedTcpTable(
if buf.is_empty() { std::ptr::null_mut() } else { buf.as_mut_ptr().cast() },
&mut size,
0,
af,
TCP_TABLE_OWNER_PID_ALL,
0,
)
};
match code {
0 if !buf.is_empty() => return buf,
0 | 122 => buf = vec![0u8; size as usize + 4096],
_ => return Vec::new(),
}
}
Vec::new()
}
fn u32_at(b: &[u8], o: usize) -> u32 {
u32::from_le_bytes(b[o..o + 4].try_into().unwrap())
}
pub fn tcp_rows_v4() -> Vec<TcpRow> {
let b = table(2);
let mut out = Vec::new();
if b.len() < 4 {
return out;
}
for i in 0..u32_at(&b, 0) as usize {
let o = 4 + 24 * i;
if o + 24 > b.len() {
break;
}
let remote = u32_at(&b, o + 12).to_le_bytes();
out.push(TcpRow {
state: u32_at(&b, o),
local_port: u16::from_be((u32_at(&b, o + 8) & 0xFFFF) as u16),
remote_port: u16::from_be((u32_at(&b, o + 16) & 0xFFFF) as u16),
remote_loopback: remote == [127, 0, 0, 1],
pid: u32_at(&b, o + 20),
});
}
out
}
pub fn tcp_rows_v6() -> Vec<TcpRow> {
let b = table(23);
let mut out = Vec::new();
if b.len() < 4 {
return out;
}
// MIB_TCP6ROW_OWNER_PID: local addr 16, scope 4, local port 4, remote addr 16, scope 4, remote port 4, state 4, pid 4
for i in 0..u32_at(&b, 0) as usize {
let o = 4 + 56 * i;
if o + 56 > b.len() {
break;
}
let remote = &b[o + 24..o + 40];
let mapped_loopback = remote[..10].iter().all(|x| *x == 0) && remote[10] == 0xff && remote[11] == 0xff && remote[12..] == [127, 0, 0, 1];
out.push(TcpRow {
state: u32_at(&b, o + 48),
local_port: u16::from_be((u32_at(&b, o + 20) & 0xFFFF) as u16),
remote_port: u16::from_be((u32_at(&b, o + 44) & 0xFFFF) as u16),
remote_loopback: mapped_loopback,
pid: u32_at(&b, o + 52),
});
}
out
}
/// Bind 0.0.0.0:port exclusively and release it. Err carries the Windows socket error.
pub fn exclusive_bind(port: u16) -> std::result::Result<(), i32> {
use socket2::{Domain, Socket, Type};
use std::os::windows::io::AsRawSocket;
let socket = Socket::new(Domain::IPV4, Type::STREAM, None).map_err(|e| e.raw_os_error().unwrap_or(-1))?;
let one: i32 = 1;
let set = unsafe {
setsockopt(socket.as_raw_socket() as _, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (&one as *const i32).cast(), 4)
};
if set != 0 {
return Err(std::io::Error::last_os_error().raw_os_error().unwrap_or(-1));
}
let addr: std::net::SocketAddr = ([0, 0, 0, 0], port).into();
socket.bind(&addr.into()).map_err(|e| e.raw_os_error().unwrap_or(-1))
}
pub fn terminate(record: &ProcessIdentity) -> Result<()> {
unsafe {
let h = OpenProcess(PROCESS_TERMINATE | PROCESS_QUERY_LIMITED_INFORMATION, 0, record.pid);
if h.is_null() {
return Err(Error::Invalid("Unable to stop the repack process.".into()));
}
let same = crate::process::is_alive(record);
let ok = same && TerminateProcess(h, 0) != 0;
CloseHandle(h);
if !ok {
return Err(Error::Invalid("The process changed while stopping it.".into()));
}
}
Ok(())
}
}
#[cfg(not(windows))]
mod sys {
use crate::error::{Error, Result};
use crate::process::ProcessIdentity;
pub const LISTEN: u32 = 2;
pub const ESTABLISHED: u32 = 5;
pub struct TcpRow {
pub state: u32,
pub local_port: u16,
pub remote_port: u16,
pub remote_loopback: bool,
pub pid: u32,
}
pub fn tcp_rows_v4() -> Vec<TcpRow> {
Vec::new()
}
pub fn tcp_rows_v6() -> Vec<TcpRow> {
Vec::new()
}
pub fn exclusive_bind(_: u16) -> std::result::Result<(), i32> {
Ok(())
}
pub fn terminate(_: &ProcessIdentity) -> Result<()> {
Err(Error::Invalid("not supported".into()))
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_port_with_a_listener_is_refused_and_a_free_one_passes() {
let held = std::net::TcpListener::bind("0.0.0.0:0").unwrap();
let port = held.local_addr().unwrap().port();
let err = ensure_free(port, &|_| {}).unwrap_err().to_string();
assert!(err.contains(&format!("Port {port} is already used (PID {}", std::process::id())), "{err}");
drop(held);
ensure_free(port, &|_| {}).unwrap();
}
#[test]
fn a_service_is_ready_only_on_its_own_port() {
let d = tempfile::tempdir().unwrap();
let held = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
let port = held.local_addr().unwrap().port();
assert!(!ready(d.path(), "auth", port), "no record yet");
state::record(d.path(), "auth", std::process::id()).unwrap();
assert!(ready(d.path(), "auth", port));
let other = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
drop(other);
assert!(!ready(d.path(), "auth", port + 1) || port + 1 == 0);
}
#[test]
fn status_reads_the_records() {
let d = tempfile::tempdir().unwrap();
state::record(d.path(), "mysql", std::process::id()).unwrap();
let s = status(d.path());
assert_eq!(s["mysql"], true);
assert_eq!(s["world"], false);
assert_eq!(s["debugLogs"], false);
}
}
+168
View File
@@ -0,0 +1,168 @@
//! `Settings/repack.json`: ports and the console login of one repack (`manage.py settings()`).
use std::path::Path;
use crate::error::{Error, Result};
pub const PORT_KEYS: [&str; 4] = ["mysqlPort", "authPort", "worldPort", "raPort"];
/// The realm a folder runs: its row in `acore_auth.realmlist` and its two game databases.
///
/// Without `Settings/realm-profile.json` this is what the repack launcher always did (realm 1 "AzerothCore" on
/// `acore_world`/`acore_characters`). With it, the active profile decides, as the Manager's realm patch of
/// `manage.py` did.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Realm {
pub id: u32,
pub name: &'static str,
pub world_db: &'static str,
pub characters_db: &'static str,
}
impl Realm {
pub fn load(root: &Path) -> Result<Realm> {
let path = root.join("Settings/realm-profile.json");
if !path.exists() {
return Ok(Realm { id: 1, name: "AzerothCore", world_db: "acore_world", characters_db: "acore_characters" });
}
let v: serde_json::Value = crate::fsx::read_json(&path)?;
Ok(match v.get("active").and_then(|a| a.as_str()).unwrap_or("coa") {
"wildcard" => Realm { id: 2, name: "Wildcard", world_db: "acore_world_wildcard", characters_db: "acore_characters_wildcard" },
"reborn" => Realm { id: 3, name: "Warcraft Reborn", world_db: "acore_world_reborn", characters_db: "acore_characters_reborn" },
_ => Realm { id: 1, name: "Conquest of Azeroth", world_db: "acore_world", characters_db: "acore_characters" },
})
}
}
/// An extra world of a server (`<server>/.realms/<name>`): it shares the main folder's database and never
/// starts or stops it.
pub fn is_extra_world(root: &Path) -> bool {
root.parent().and_then(|p| p.file_name()).is_some_and(|n| n == ".realms")
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Settings {
pub mysql_port: u16,
pub auth_port: u16,
pub world_port: u16,
pub ra_port: u16,
pub ra_username: String,
pub ra_password: String,
pub realm: Realm,
/// The database belongs to the main folder of this server (an extra world): it is only checked, never
/// started.
pub shared_database: bool,
/// Environment variables the started services must not see (for example a port override of the caller).
pub env_remove: Vec<String>,
/// The whole document, for keys this code does not know (kept when it is written back).
pub raw: serde_json::Map<String, serde_json::Value>,
}
impl Settings {
/// Read `Settings/repack.json`, with every port moved by `offset` (a second world of the same server runs on
/// shifted ports). The same checks as `manage.py`: integer ports in 1025..65535 after the offset, all
/// different.
pub fn load(root: &Path, offset: i32) -> Result<Settings> {
let bytes = std::fs::read(root.join("Settings/repack.json"))?;
let text = String::from_utf8_lossy(&bytes);
let text = text.strip_prefix('\u{feff}').unwrap_or(&text);
let raw: serde_json::Map<String, serde_json::Value> =
serde_json::from_str(text).map_err(|e| Error::Invalid(format!("Settings/repack.json: {e}")))?;
let mut ports = [0u16; 4];
for (i, key) in PORT_KEYS.iter().enumerate() {
// Python's `type(value) is not int` refuses booleans and floats alike.
let value = raw.get(*key).and_then(|v| v.as_i64()).filter(|_| raw[*key].is_i64() || raw[*key].is_u64());
let shifted = value.map(|v| v + i64::from(offset));
match shifted {
Some(p) if p > 1024 && p < 65536 => ports[i] = p as u16,
_ => return Err(Error::Service(crate::error::ErrorCode::InvalidConfigValue, "Invalid port in Settings/repack.json".into())),
}
}
let mut unique = ports.to_vec();
unique.sort_unstable();
unique.dedup();
if unique.len() != 4 {
return Err(Error::Invalid("Each service needs a different port.".into()));
}
let text_of = |k: &str| raw.get(k).and_then(|v| v.as_str()).unwrap_or_default().to_string();
Ok(Settings {
mysql_port: ports[0],
auth_port: ports[1],
world_port: ports[2],
ra_port: ports[3],
ra_username: text_of("raUsername"),
ra_password: text_of("raPassword"),
realm: Realm::load(root)?,
shared_database: is_extra_world(root),
env_remove: Vec::new(),
raw,
})
}
/// `{"mysqlPort": .., "authPort": .., "worldPort": .., "raPort": ..}` as `manage.py` records it in
/// `.state/configuration.json` (the keys of repack.json ending in "Port", in the file's order).
pub fn port_map(&self) -> serde_json::Map<String, serde_json::Value> {
let shifted = [self.mysql_port, self.auth_port, self.world_port, self.ra_port];
let mut out = serde_json::Map::new();
for key in self.raw.keys().filter(|k| k.ends_with("Port")) {
let value = PORT_KEYS
.iter()
.position(|p| p == key)
.map(|i| serde_json::Value::from(shifted[i]))
.unwrap_or_else(|| self.raw[key].clone());
out.insert(key.clone(), value);
}
out
}
}
#[cfg(test)]
mod tests {
use super::*;
fn write(dir: &Path, text: &str) {
std::fs::create_dir_all(dir.join("Settings")).unwrap();
std::fs::write(dir.join("Settings/repack.json"), text).unwrap();
}
#[test]
fn ports_are_checked_like_the_python_launcher() {
let d = tempfile::tempdir().unwrap();
write(d.path(), r#"{"mysqlPort":3307,"authPort":3724,"worldPort":8085,"raPort":3443,"raUsername":"U","raPassword":"P"}"#);
let s = Settings::load(d.path(), 0).unwrap();
assert_eq!((s.mysql_port, s.auth_port, s.world_port, s.ra_port), (3307, 3724, 8085, 3443));
assert_eq!(s.ra_username, "U");
let shifted = Settings::load(d.path(), 10).unwrap();
assert_eq!(shifted.world_port, 8095);
assert_eq!(shifted.port_map()["worldPort"], serde_json::json!(8095));
for bad in [
r#"{"mysqlPort":1024,"authPort":3724,"worldPort":8085,"raPort":3443}"#,
r#"{"mysqlPort":"3307","authPort":3724,"worldPort":8085,"raPort":3443}"#,
r#"{"mysqlPort":3307.0,"authPort":3724,"worldPort":8085,"raPort":3443}"#,
r#"{"mysqlPort":true,"authPort":3724,"worldPort":8085,"raPort":3443}"#,
r#"{"mysqlPort":3307,"authPort":3307,"worldPort":8085,"raPort":3443}"#,
r#"{"authPort":3724,"worldPort":8085,"raPort":3443}"#,
] {
write(d.path(), bad);
assert!(Settings::load(d.path(), 0).is_err(), "{bad}");
}
write(d.path(), "\u{feff}{\"mysqlPort\":3307,\"authPort\":3724,\"worldPort\":8085,\"raPort\":65535}");
assert!(Settings::load(d.path(), 1).is_err(), "65536 after the offset");
assert!(Settings::load(d.path(), 0).is_ok(), "a byte order mark is accepted");
}
#[test]
fn the_realm_follows_the_active_profile() {
let d = tempfile::tempdir().unwrap();
assert_eq!(Realm::load(d.path()).unwrap().name, "AzerothCore");
std::fs::create_dir_all(d.path().join("Settings")).unwrap();
for (active, id, db) in [("coa", 1, "acore_world"), ("wildcard", 2, "acore_world_wildcard"), ("reborn", 3, "acore_world_reborn")] {
std::fs::write(d.path().join("Settings/realm-profile.json"), format!("{{\"active\":\"{active}\"}}")).unwrap();
let r = Realm::load(d.path()).unwrap();
assert_eq!((r.id, r.world_db), (id, db));
}
assert!(is_extra_world(&d.path().join(".realms/secondary")));
assert!(!is_extra_world(d.path()));
}
}
Binary file not shown.
+398
View File
@@ -0,0 +1,398 @@
//! SQUID Playerbots on a repack (`Scripts/squid_playerbots.py`): the bot modules must not both run, how long a
//! SQUID world may take to start, and its database, provisioned before the world starts.
//!
//! The SQL journals are the ones the Python script keeps, unchanged: `coa_squid_migrations(path, sha256)` and
//! `coa_squid_pending(path, sha256)` in every target schema, and the SQUID installer's `coa_bots_installed`.
use std::collections::{BTreeMap, BTreeSet};
use std::path::{Path, PathBuf};
use sha1::Digest as _;
use crate::error::{Error, Result};
/// `key = value` lines of a module config (comments and quotes dropped), as `options()` reads them.
pub fn options(path: &Path) -> BTreeMap<String, String> {
let mut out = BTreeMap::new();
let Ok(bytes) = std::fs::read(path) else { return out };
let text = String::from_utf8_lossy(&bytes);
let text = text.strip_prefix('\u{feff}').unwrap_or(&text);
for line in text.lines() {
let line = line.trim_start();
let Some((key, rest)) = line.split_once('=') else { continue };
let key = key.trim_end();
if key.is_empty() || key.starts_with('#') || key.contains(char::is_whitespace) {
continue;
}
let value = rest.split('#').next().unwrap_or("").trim();
out.insert(key.to_string(), value.trim_matches('"').to_string());
}
out
}
/// A secondary world shares the primary's package files.
pub fn package_root(root: &Path) -> PathBuf {
let secondary = root.file_name().is_some_and(|n| n == "secondary")
&& root.parent().and_then(|p| p.file_name()).is_some_and(|n| n == ".realms");
if secondary {
root.parent().and_then(Path::parent).map(Path::to_path_buf).unwrap_or_else(|| root.to_path_buf())
} else {
root.to_path_buf()
}
}
pub fn module_options(root: &Path, name: &str) -> (PathBuf, BTreeMap<String, String>) {
let folder = root.join("Core/configs/modules");
let active = folder.join(name);
let mut path = if active.exists() { active } else { folder.join(format!("{name}.dist")) };
if !path.exists() && name == "playerbots.conf" {
path = package_root(root).join("Core/configs/modules/playerbots.conf.dist");
}
let values = options(&path);
(path, values)
}
/// Invalid booleans count as the modules' compiled default: enabled.
pub fn enabled(values: &BTreeMap<String, String>, key: &str) -> bool {
!matches!(values.get(key).map(|v| v.to_ascii_lowercase()).as_deref(), Some("0" | "false" | "no" | "off"))
}
pub fn validate_bots(root: &Path) -> Result<()> {
let (a, av) = module_options(root, "mod_coa_playerbots.conf");
let (b, bv) = module_options(root, "playerbots.conf");
if a.exists() && b.exists() && enabled(&av, "CoaBots.Enable") && enabled(&bv, "AiPlayerbot.Enabled") {
return Err(Error::Invalid(
"CoA Companions and SQUID Playerbots cannot both be enabled. Disable one bot module in Modules or its config.".into(),
));
}
Ok(())
}
/// Seconds a world may take to open its port: SQUID loads its bots first.
pub fn startup_timeout(root: &Path) -> u64 {
let (path, values) = module_options(root, "playerbots.conf");
if path.exists() && enabled(&values, "AiPlayerbot.Enabled") {
1500
} else {
180
}
}
/// Replace (or append) `key = value` lines; the file is written with "\n" line ends.
pub fn set_options(path: &Path, values: &[(&str, String)]) -> Result<()> {
let bytes = std::fs::read(path)?;
let text = String::from_utf8_lossy(&bytes);
let mut text = text.strip_prefix('\u{feff}').unwrap_or(&text).replace("\r\n", "\n");
for (key, value) in values {
let line = format!("{key} = {value}");
let mut found = false;
let lines: Vec<String> = text
.split('\n')
.map(|l| {
let t = l.trim_start();
let matches = t.strip_prefix(key).is_some_and(|rest| rest.trim_start().starts_with('='));
if matches {
found = true;
line.clone()
} else {
l.to_string()
}
})
.collect();
text = lines.join("\n");
if !found {
text.push('\n');
text.push_str(&line);
text.push('\n');
}
}
crate::fsx::atomic_write(path, text.as_bytes())
}
fn valid_relative(rel: &str) -> bool {
!rel.is_empty() && rel.bytes().all(|b| b.is_ascii_alphanumeric() || matches!(b, b'_' | b'.' | b'/' | b'-'))
}
/// Table names a base file creates (`CREATE TABLE [IF NOT EXISTS] name`).
fn created_tables(sql: &str) -> BTreeSet<String> {
let mut out = BTreeSet::new();
let upper = sql.to_ascii_uppercase();
let mut from = 0;
while let Some(i) = upper[from..].find("CREATE") {
let start = from + i + "CREATE".len();
from = start;
let rest = &sql[start..];
let mut words = rest.split_whitespace();
if !words.next().is_some_and(|w| w.eq_ignore_ascii_case("TABLE")) {
continue;
}
let mut name = words.next().unwrap_or("");
if name.eq_ignore_ascii_case("IF") {
let _ = words.next(); // NOT
let _ = words.next(); // EXISTS
name = words.next().unwrap_or("");
}
let name: String = name.trim_start_matches('`').chars().take_while(|c| c.is_ascii_alphanumeric() || *c == '_').collect();
if !name.is_empty() {
out.insert(name);
}
}
out
}
fn sha256_hex(bytes: &[u8]) -> String {
crate::fsx::sha256_bytes(bytes)
}
fn sha1_hex(bytes: &[u8]) -> String {
let mut h = sha1::Sha1::new();
h.update(bytes);
h.finalize().iter().map(|b| format!("{b:02x}")).collect()
}
fn rows(text: &str) -> Vec<(String, String)> {
text.lines().filter_map(|r| r.split_once('\t')).map(|(a, b)| (a.to_string(), b.to_string())).collect()
}
/// Provision an enabled SQUID without replaying imported base tables (`prepare_playerbots`). `mysql(sql)` runs
/// SQL with the repack's administrator login and returns its output.
pub fn prepare_playerbots(root: &Path, mysql_port: u16, mysql: &dyn Fn(&str) -> Result<String>, progress: &dyn Fn(&str)) -> Result<()> {
let (mut path, values) = module_options(root, "playerbots.conf");
if !path.exists() || !enabled(&values, "AiPlayerbot.Enabled") {
return Ok(());
}
validate_bots(root)?;
let sql_root = package_root(root).join("Extras/SquidPlayerbots/sql");
if !sql_root.join("playerbots/base").is_dir() {
return Err(Error::Invalid("SQUID Playerbots database files are missing. Repair the server installation.".into()));
}
let world = options(&root.join("Core/configs/worldserver.conf"));
let mut schemas: Vec<(&str, String)> = Vec::new();
for (kind, key) in [("characters", "CharacterDatabaseInfo"), ("world", "WorldDatabaseInfo")] {
let schema = world.get(key).and_then(|v| v.rsplit(';').next()).unwrap_or("").to_string();
let ok = matches!(schema.as_str(), "acore_world" | "acore_characters" | "acore_world_wildcard" | "acore_characters_wildcard");
if !ok {
return Err(Error::Invalid("Unsupported world/characters database for SQUID Playerbots.".into()));
}
schemas.push((kind, schema));
}
schemas.push(("playerbots", "acore_playerbots".into()));
let list = |schema: &str| -> Result<BTreeSet<String>> {
Ok(mysql(&format!("SELECT TABLE_NAME FROM information_schema.TABLES WHERE TABLE_SCHEMA='{schema}';"))?
.lines()
.map(str::to_string)
.collect())
};
let existing_playerbots = list("acore_playerbots")?;
let bookkeeping = ["updates", "updates_include", "version_db_playerbots", "coa_squid_migrations", "coa_bots_installed", "coa_squid_pending"];
let data_tables: Vec<&String> = existing_playerbots.iter().filter(|t| !bookkeeping.contains(&t.as_str())).collect();
let mut installer_history = BTreeSet::new();
if existing_playerbots.contains("coa_bots_installed") {
for name in mysql("SELECT file FROM `acore_playerbots`.coa_bots_installed;")?.lines() {
let mut n = name.replace('\\', "/");
while n.contains("//") {
n = n.replace("//", "/");
}
let n = n.trim_matches('/').to_string();
if n.to_ascii_lowercase().ends_with(".sql") {
installer_history.insert(n);
}
}
}
let mut tables: BTreeMap<&str, BTreeSet<String>> = BTreeMap::new();
let mut histories: BTreeMap<&str, BTreeMap<String, String>> = BTreeMap::new();
let mut ledgers: BTreeMap<&str, BTreeMap<String, String>> = BTreeMap::new();
for (kind, schema) in &schemas {
let t = if *kind == "playerbots" { existing_playerbots.clone() } else { list(schema)? };
if t.contains("coa_squid_pending") {
let pending = mysql(&format!("SELECT path FROM `{schema}`.coa_squid_pending;"))?;
let pending = pending.trim();
if !pending.is_empty() {
return Err(Error::Invalid(format!(
"A SQUID base import was interrupted. Restore the database backup or repair the incomplete import before continuing; no SQL was applied: {pending}"
)));
}
}
let mut history = BTreeMap::new();
if t.contains("updates") {
for (name, digest) in rows(&mysql(&format!("SELECT name,hash FROM `{schema}`.updates;"))?) {
history.insert(name, digest.to_ascii_lowercase());
}
}
let mut ledger = BTreeMap::new();
if t.contains("coa_squid_migrations") {
for (name, digest) in rows(&mysql(&format!("SELECT path,sha256 FROM `{schema}`.coa_squid_migrations;"))?) {
ledger.insert(name, digest);
}
}
tables.insert(kind, t);
histories.insert(kind, history);
ledgers.insert(kind, ledger);
}
if !data_tables.is_empty() && installer_history.is_empty() && histories["playerbots"].is_empty() && ledgers["playerbots"].is_empty() {
for table in data_tables {
let quoted = table.replace('`', "``");
if mysql(&format!("SELECT EXISTS(SELECT 1 FROM `acore_playerbots`.`{quoted}` LIMIT 1);"))?.trim() == "1" {
return Err(Error::Invalid(
"Existing SQUID data has no recorded installation history. Repair the imported database history before continuing; no SQL was applied.".into(),
));
}
}
}
mysql("CREATE DATABASE IF NOT EXISTS acore_playerbots CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;")?;
for host in ["localhost", "127.0.0.1"] {
mysql(&format!("GRANT ALL PRIVILEGES ON acore_playerbots.* TO 'acore'@'{host}';"))?;
}
let (_, password) = crate::db::credentials(root)?;
if password.len() != 48 || !password.bytes().all(|b| b.is_ascii_digit() || (b'a'..=b'f').contains(&b)) {
return Err(Error::Invalid("Invalid packaged database configuration.".into()));
}
if path.file_name().is_some_and(|n| n.to_string_lossy().ends_with(".dist")) {
let active = root.join("Core/configs/modules/playerbots.conf");
std::fs::create_dir_all(active.parent().unwrap())?;
std::fs::write(&active, std::fs::read(&path)?)?;
path = active;
}
set_options(
&path,
&[
("PlayerbotsDatabaseInfo", format!("\"127.0.0.1;{mysql_port};acore;{password};acore_playerbots\"")),
("Playerbots.Updates.EnableDatabases", "0".into()),
],
)?;
for (kind, schema) in &schemas {
mysql(&format!("CREATE TABLE IF NOT EXISTS `{schema}`.coa_squid_migrations (path VARCHAR(240) PRIMARY KEY, sha256 CHAR(64) NOT NULL);"))?;
mysql(&format!("CREATE TABLE IF NOT EXISTS `{schema}`.coa_squid_pending (path VARCHAR(240) PRIMARY KEY, sha256 CHAR(64) NOT NULL);"))?;
let history = &histories[kind];
let recorded = ledgers[kind].clone();
for stage in ["base", "updates", "custom"] {
let mut sources: Vec<PathBuf> = std::fs::read_dir(sql_root.join(kind).join(stage))
.map(|rd| rd.flatten().map(|e| e.path()).filter(|p| p.extension().is_some_and(|e| e == "sql")).collect())
.unwrap_or_default();
sources.sort();
for source in sources {
let relative = source.strip_prefix(&sql_root).unwrap_or(&source).to_string_lossy().replace('\\', "/");
if !valid_relative(&relative) {
return Err(Error::Invalid("Invalid SQUID SQL filename.".into()));
}
let bytes = std::fs::read(&source)?;
let digest = sha256_hex(&bytes);
if let Some(previous) = recorded.get(&relative) {
if *previous != digest {
return Err(Error::Invalid(format!("A previously applied SQUID database migration changed: {relative}")));
}
if stage != "base" {
continue;
}
}
let ledger_sql = if recorded.contains_key(&relative) {
String::new()
} else {
format!("INSERT INTO `{schema}`.coa_squid_migrations VALUES ('{relative}','{digest}');")
};
let text = String::from_utf8_lossy(&bytes);
let text = text.strip_prefix('\u{feff}').unwrap_or(&text).to_string();
if stage == "base" {
let definitions = created_tables(&text);
let present: BTreeSet<String> = definitions.intersection(&tables[kind]).cloned().collect();
if !present.is_empty() && present != definitions {
return Err(Error::Invalid(format!("SQUID base file has only some of its tables. Repair the incomplete database before continuing: {relative}")));
}
if definitions.is_empty() {
return Err(Error::Invalid(format!("SQUID base file has no recognizable table definitions; repair is required: {relative}")));
}
if present == definitions {
if !ledger_sql.is_empty() {
mysql(&ledger_sql)?;
}
continue;
}
mysql(&format!("INSERT INTO `{schema}`.coa_squid_pending VALUES ('{relative}','{digest}'); COMMIT;"))?;
let complete = format!("DELETE FROM `{schema}`.coa_squid_pending WHERE path='{relative}' AND sha256='{digest}'; COMMIT;");
progress(&format!("Importing SQUID {relative} into {schema} ({} bytes); large imports may take several minutes...", bytes.len()));
mysql(&format!("USE `{schema}`;\n{text}\n{ledger_sql}\n{complete}")).map_err(|_| {
Error::Invalid(format!(
"SQUID import failed: {relative} in {schema}. The world server was not started. The incomplete import is recorded; restore a database backup or repair that import before retrying."
))
})?;
progress(&format!("Imported SQUID {relative}."));
if let Some(t) = tables.get_mut(kind) {
t.extend(definitions);
}
continue;
}
if installer_history.iter().any(|n| *n == relative || n.ends_with(&format!("/{relative}"))) {
mysql(&ledger_sql)?;
continue;
}
let file_name = source.file_name().unwrap_or_default().to_string_lossy().into_owned();
if let Some(upstream) = history.get(&file_name) {
let lf = String::from_utf8_lossy(&bytes).replace("\r\n", "\n");
let accepted = [sha1_hex(&bytes), sha1_hex(lf.as_bytes())];
if !upstream.is_empty() && !accepted.contains(upstream) {
return Err(Error::Invalid(format!("SQUID update history does not match the shipped SQL: {relative}")));
}
mysql(&ledger_sql)?;
continue;
}
mysql(&format!("USE `{schema}`;\n{text}\n{ledger_sql}"))?;
}
}
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn config_lines_are_read_like_the_python_script() {
let d = tempfile::tempdir().unwrap();
let p = d.path().join("playerbots.conf");
std::fs::write(&p, "\u{feff}# comment = 1\nAiPlayerbot.Enabled = 0 # off\n Key.Two=\"quoted\"\nnot a line\nEmpty =\n").unwrap();
let o = options(&p);
assert_eq!(o.get("AiPlayerbot.Enabled").map(String::as_str), Some("0"));
assert_eq!(o.get("Key.Two").map(String::as_str), Some("quoted"));
assert_eq!(o.get("Empty").map(String::as_str), Some(""));
assert!(!o.contains_key("#"));
assert!(!enabled(&o, "AiPlayerbot.Enabled"));
assert!(enabled(&o, "Missing"));
}
#[test]
fn both_bot_modules_on_is_refused_and_squid_gets_a_long_startup() {
let d = tempfile::tempdir().unwrap();
let m = d.path().join("Core/configs/modules");
std::fs::create_dir_all(&m).unwrap();
std::fs::write(m.join("mod_coa_playerbots.conf"), "CoaBots.Enable = 1\n").unwrap();
std::fs::write(m.join("playerbots.conf.dist"), "AiPlayerbot.Enabled = 1\n").unwrap();
assert!(validate_bots(d.path()).is_err());
assert_eq!(startup_timeout(d.path()), 1500);
std::fs::write(m.join("playerbots.conf"), "AiPlayerbot.Enabled = 0\n").unwrap();
validate_bots(d.path()).unwrap();
assert_eq!(startup_timeout(d.path()), 180);
}
#[test]
fn options_are_replaced_or_appended() {
let d = tempfile::tempdir().unwrap();
let p = d.path().join("playerbots.conf");
std::fs::write(&p, "A = 1\r\n Playerbots.Updates.EnableDatabases = 1\r\n").unwrap();
set_options(&p, &[("Playerbots.Updates.EnableDatabases", "0".into()), ("PlayerbotsDatabaseInfo", "\"x\"".into())]).unwrap();
assert_eq!(std::fs::read_to_string(&p).unwrap(), "A = 1\nPlayerbots.Updates.EnableDatabases = 0\n\nPlayerbotsDatabaseInfo = \"x\"\n");
}
#[test]
fn base_tables_are_found() {
let t = created_tables("CREATE TABLE IF NOT EXISTS `ai_playerbot_names` (\n id int);\ncreate table playerbots_random_bots(x int);\n-- CREATE INDEX i ON t(x);");
assert_eq!(t, ["ai_playerbot_names".to_string(), "playerbots_random_bots".to_string()].into_iter().collect());
}
#[test]
fn a_secondary_world_uses_the_primary_package() {
assert_eq!(package_root(Path::new("C:/S/.realms/secondary")), Path::new("C:/S"));
assert_eq!(package_root(Path::new("C:/S")), Path::new("C:/S"));
}
}
+198
View File
@@ -0,0 +1,198 @@
//! `.state/`: which processes belong to this repack, and the one-action-at-a-time lock.
use std::fs::{File, OpenOptions};
use std::io::{Seek, SeekFrom, Write};
use std::path::{Path, PathBuf};
use std::time::{Duration, Instant};
use crate::error::{Error, Result};
use crate::fsx;
use crate::process::{self, ProcessIdentity};
pub fn dir(root: &Path) -> PathBuf {
root.join(".state")
}
/// Written like `manage.py atomic_json`: two-space JSON and a newline, now flushed to disk before it replaces
/// the old file.
pub fn write_json(path: &Path, value: &impl serde::Serialize) -> Result<()> {
let mut text = serde_json::to_string_pretty(value)?;
text.push('\n');
fsx::atomic_write(path, text.as_bytes())
}
/// The recorded process of `name` when it is still that process (same executable and start time). A missing,
/// empty or damaged record is no process: `manage.py` failed on those, and every later start with it.
pub fn running(root: &Path, name: &str) -> Option<ProcessIdentity> {
let record = process::read_state_record(root, name)?;
process::is_alive(&record).then_some(record)
}
/// Record the process `pid` as `name`. Fails when it has already exited.
pub fn record(root: &Path, name: &str, pid: u32) -> Result<ProcessIdentity> {
let identity = process::identity(pid)
.ok_or_else(|| Error::Invalid(format!("{name} exited during startup; check its log.")))?;
write_json(&dir(root).join(format!("{name}.json")), &identity)?;
Ok(identity)
}
/// Held while one start/stop action runs. Byte 0 of `.state/control.lock` is locked, exactly the region
/// `msvcrt.locking(fd, LK_NBLCK, 1)` locks in `manage.py`, so a Python launcher and this one exclude each other.
pub struct ControlLock {
file: File,
owner: PathBuf,
}
impl ControlLock {
/// Wait up to `wait` for the lock. `action` is recorded for whoever waits next ("start-all", ...).
pub fn acquire(root: &Path, action: &str, wait: Duration, progress: &dyn Fn(&str)) -> Result<ControlLock> {
let state = dir(root);
std::fs::create_dir_all(&state)?;
let mut file = OpenOptions::new().read(true).append(true).create(true).open(state.join("control.lock"))?;
if file.seek(SeekFrom::End(0))? == 0 {
file.write_all(b"0")?;
file.flush()?;
}
let owner = state.join("control-owner.json");
let deadline = Instant::now() + wait;
let mut announced = false;
loop {
if sys::try_lock(&file)? {
break;
}
let detail = match fsx::read_json::<serde_json::Value>(&owner) {
Ok(v) if v.get("pid").is_some() && v.get("action").is_some() => {
format!(" PID {}, action {}.", v["pid"], v["action"].as_str().unwrap_or(""))
}
_ => " Owner information is unavailable.".into(),
};
if Instant::now() >= deadline {
return Err(Error::Service(crate::error::ErrorCode::OperationInProgress, format!("Another start/stop action is in progress.{detail}")));
}
if !announced {
progress(&format!("Waiting for the current server action.{detail}"));
announced = true;
}
std::thread::sleep(Duration::from_millis(250));
}
let started = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_secs_f64())
.unwrap_or(0.0);
let lock = ControlLock { file, owner };
write_json(
&lock.owner,
&serde_json::json!({ "pid": std::process::id(), "action": action, "started": started }),
)?;
Ok(lock)
}
}
/// Byte 0 of a file locked while held (`msvcrt.locking`), for example the bug-report relay's `relay.lock`.
pub struct FileLock {
file: File,
}
impl FileLock {
/// Take the lock, or `None` when another process (or handle) holds it.
pub fn try_acquire(path: &Path) -> Result<Option<FileLock>> {
let mut file = OpenOptions::new().read(true).append(true).create(true).open(path)?;
if file.seek(SeekFrom::End(0))? == 0 {
file.write_all(b"0")?;
file.flush()?;
}
Ok(sys::try_lock(&file)?.then_some(FileLock { file }))
}
}
impl Drop for FileLock {
fn drop(&mut self) {
sys::unlock(&self.file);
}
}
impl Drop for ControlLock {
fn drop(&mut self) {
let _ = std::fs::remove_file(&self.owner);
sys::unlock(&self.file);
}
}
#[cfg(windows)]
mod sys {
use std::fs::File;
use std::os::windows::io::AsRawHandle;
use windows_sys::Win32::Storage::FileSystem::{LockFile, UnlockFile};
/// `LockFile` on byte 0, length 1: the call `msvcrt.locking` makes. Non-blocking.
pub fn try_lock(file: &File) -> std::io::Result<bool> {
let ok = unsafe { LockFile(file.as_raw_handle() as _, 0, 0, 1, 0) };
if ok != 0 {
return Ok(true);
}
let err = std::io::Error::last_os_error();
// ERROR_LOCK_VIOLATION (33): someone else holds it.
if err.raw_os_error() == Some(33) {
Ok(false)
} else {
Err(err)
}
}
pub fn unlock(file: &File) {
unsafe {
UnlockFile(file.as_raw_handle() as _, 0, 0, 1, 0);
}
}
}
#[cfg(not(windows))]
mod sys {
use std::fs::File;
pub fn try_lock(_: &File) -> std::io::Result<bool> {
Ok(true)
}
pub fn unlock(_: &File) {}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_damaged_record_is_no_process() {
let d = tempfile::tempdir().unwrap();
std::fs::create_dir_all(dir(d.path())).unwrap();
std::fs::write(dir(d.path()).join("mysql.json"), [0u8; 116]).unwrap();
assert!(running(d.path(), "mysql").is_none());
std::fs::write(dir(d.path()).join("auth.json"), b"").unwrap();
assert!(running(d.path(), "auth").is_none());
}
#[test]
fn this_process_is_recorded_and_found_running() {
let d = tempfile::tempdir().unwrap();
let me = record(d.path(), "probe", std::process::id()).unwrap();
assert_eq!(running(d.path(), "probe"), Some(me));
let text = std::fs::read_to_string(dir(d.path()).join("probe.json")).unwrap();
assert!(text.starts_with("{\n \"pid\": ") && text.ends_with("}\n"), "{text}");
}
#[test]
fn one_action_at_a_time() {
let d = tempfile::tempdir().unwrap();
let first = ControlLock::acquire(d.path(), "start-all", Duration::from_secs(1), &|_| {}).unwrap();
let owner: serde_json::Value = fsx::read_json(&dir(d.path()).join("control-owner.json")).unwrap();
assert_eq!(owner["action"], "start-all");
let said = std::sync::Mutex::new(Vec::new());
let second = ControlLock::acquire(d.path(), "stop-all", Duration::from_millis(600), &|m| said.lock().unwrap().push(m.to_string()));
if cfg!(windows) {
let err = second.err().expect("the second action waits and gives up").to_string();
assert!(err.contains("Another start/stop action is in progress") && err.contains("start-all"), "{err}");
assert_eq!(said.lock().unwrap().len(), 1);
}
drop(first);
assert!(!dir(d.path()).join("control-owner.json").exists());
ControlLock::acquire(d.path(), "stop-all", Duration::from_secs(1), &|_| {}).unwrap();
}
}
+300
View File
@@ -0,0 +1,300 @@
//! The world server and the bug-report relay beside it (`manage.py start_world`, `watch_world`, `wait_relay`),
//! and the detailed-logging switch (`debug_logs`).
//!
//! A world is started through a supervisor process that outlives the caller: it starts `worldserver.exe`, keeps
//! the relay running while the world runs, and stops the relay when the world ends. The supervisor is
//! `coa-launcher.exe watch-world`, or `manage.py watch-world` on a repack that does not ship it yet (both write
//! the same records). The relay itself is still the Python `BugReport/relay.py`, run through the repack's
//! Python, until it is ported too.
use std::path::{Path, PathBuf};
use std::time::{Duration, Instant};
use crate::error::{Error, ErrorCode, Result};
use crate::launcher::services::{self, ensure_free, mysql, spawn, start_mysql, wait_ready, Progress};
use crate::launcher::spawn::Proc;
use crate::launcher::{settings::Settings, squid, state};
fn stop_relay_flag(root: &Path) -> std::path::PathBuf {
state::dir(root).join("stop-relay")
}
/// The relay is up and has finished starting (it records itself as `relay-ready` once it serves).
pub fn wait_relay(root: &Path) -> Result<()> {
let until = Instant::now() + Duration::from_secs(20);
while Instant::now() < until {
if let (Some(relay), Some(ready)) = (state::running(root, "relay"), state::running(root, "relay-ready")) {
if relay == ready {
return Ok(());
}
}
std::thread::sleep(Duration::from_millis(250));
}
Err(Error::Invalid("Bug-report relay is not ready; check BugReport/Logs/relay.log.".into()))
}
/// The process that runs `watch-world` for a started world.
#[derive(Debug, Clone)]
pub enum Supervisor {
/// `coa-launcher.exe` (this crate's launcher).
Launcher(PathBuf),
/// The repack's Python with `Scripts/manage.py`.
Python { python: PathBuf, script: PathBuf },
}
impl Supervisor {
/// The supervisor a repack ships: `Scripts/coa-launcher.exe` when present, otherwise its Python launcher.
pub fn of(root: &Path) -> Result<Supervisor> {
let exe = root.join("Scripts/coa-launcher.exe");
if exe.is_file() {
return Ok(Supervisor::Launcher(exe));
}
let python = squid::package_root(root).join("Runtime/python/python.exe");
let script = root.join("Scripts/manage.py");
if python.is_file() && script.is_file() {
return Ok(Supervisor::Python { python, script });
}
Err(Error::Service(
ErrorCode::ServerFilesIncomplete,
"This server has no world supervisor (Scripts/coa-launcher.exe or Scripts/manage.py). Repair its program files.".into(),
))
}
}
/// How long a world may take to open both of its listeners, together: slow worlds (many bots, a cold disk) are
/// common, and the limit must not depend on the bot module.
const WORLD_STARTUP_SECONDS: u64 = 1500;
/// Wait until the world's console answers a command (it can listen before it accepts logins).
fn wait_console(root: &Path, cfg: &Settings, until: Instant) -> Result<()> {
let mut last = String::new();
while Instant::now() < until {
if state::running(root, "world").is_none() {
return Err(Error::Service(
ErrorCode::StartupFailed,
"World startup failed: worldserver stopped before its console accepted commands.".into(),
));
}
match crate::ra::Ra::connect_to(cfg.ra_port, &cfg.ra_username, &cfg.ra_password).and_then(|mut ra| ra.run("server info")) {
Ok(_) => return Ok(()),
Err(e) => last = e.to_string(),
}
std::thread::sleep(Duration::from_millis(500));
}
Err(Error::Service(ErrorCode::StartupFailed, format!("World startup failed: its console is still starting. {last}")))
}
fn seconds_until(until: Instant) -> u64 {
until.saturating_duration_since(Instant::now()).as_secs()
}
/// Start the world (and its database, unless it is shared), and wait until its console accepts commands.
pub fn start_world(root: &Path, cfg: &Settings, offset: i32, supervisor: &Supervisor, progress: Progress) -> Result<()> {
start_mysql(root, cfg, progress)?;
squid::validate_bots(root)?;
let until = Instant::now() + Duration::from_secs(squid::startup_timeout(root).max(WORLD_STARTUP_SECONDS));
if state::running(root, "world").is_some() {
if state::running(root, "supervisor").is_none() {
return Err(Error::Service(
ErrorCode::WorldserverAlreadyRunning,
"Worldserver has no repack supervisor. Use Stop_All_Server.bat before restarting it.".into(),
));
}
wait_ready(root, "world", cfg.world_port, seconds_until(until))?;
wait_relay(root)?;
wait_console(root, cfg, until)?;
progress("Worldserver and bug-report relay are already running.");
return Ok(());
}
ensure_free(cfg.world_port, progress)?;
ensure_free(cfg.ra_port, progress)?;
if state::running(root, "supervisor").is_some() || state::running(root, "relay").is_some() {
return Err(Error::Service(
ErrorCode::OperationInProgress,
"The previous world/relay shutdown is still finishing. Try again shortly.".into(),
));
}
squid::prepare_playerbots(root, cfg.mysql_port, &|sql| mysql(root, Some(sql), None), progress)?;
progress("Starting worldserver and its bug-report relay...");
let _ = std::fs::remove_file(stop_relay_flag(root));
let offset_text = offset.to_string();
let root_text = root.to_string_lossy().into_owned();
let log = root.join("Core/Logs/supervisor.log");
match supervisor {
Supervisor::Launcher(exe) => {
spawn(root, "supervisor", exe, &["--root", &root_text, "--port-offset", &offset_text, "watch-world"], root, &log, &cfg.env_remove)?
}
Supervisor::Python { python, script } => {
let script = script.to_string_lossy().into_owned();
spawn(root, "supervisor", python, &["-B", &script, "--port-offset", &offset_text, "watch-world"], root, &log, &cfg.env_remove)?
}
};
let first = Instant::now() + Duration::from_secs(20);
while state::running(root, "world").is_none() && Instant::now() < first {
if state::running(root, "supervisor").is_none() {
return Err(Error::Service(ErrorCode::StartupFailed, "World startup failed; check Core/Logs/supervisor.log.".into()));
}
std::thread::sleep(Duration::from_millis(250));
}
wait_ready(root, "world", cfg.world_port, seconds_until(until))?;
wait_ready(root, "world", cfg.ra_port, seconds_until(until))?;
wait_relay(root)?;
wait_console(root, cfg, until)?;
progress("Worldserver and automatic bug reporting are ready.");
Ok(())
}
fn spawn_child(root: &Path, name: &str, exe: &Path, args: &[&str], cwd: &Path, log: &Path) -> Result<Proc> {
// The supervisor was started with the environment its services should have.
let child = crate::launcher::spawn::start(exe, args, cwd, log, &[])?;
state::record(root, name, child.pid)?;
Ok(child)
}
/// The relay worker: `coa-launcher relay-worker` when the supervisor is the launcher (`launcher`), otherwise the
/// repack's Python running `Scripts/manage.py relay-worker` (BugReport/relay.py).
fn spawn_relay(root: &Path, launcher: Option<&Path>) -> Result<Proc> {
let log = root.join("BugReport/Logs/relay.log");
if let Some(exe) = launcher {
let root_text = root.to_string_lossy().into_owned();
return spawn_child(root, "relay", exe, &["--root", &root_text, "relay-worker"], root, &log);
}
let python = squid::package_root(root).join("Runtime/python/python.exe");
let manage = root.join("Scripts/manage.py");
if !python.is_file() || !manage.is_file() {
return Err(Error::Invalid("The bug-report relay needs the repack's Python and Scripts/manage.py.".into()));
}
let manage = manage.to_string_lossy().into_owned();
spawn_child(root, "relay", &python, &["-B", &manage, "relay-worker"], root, &root.join("BugReport/Logs/relay.log"))
}
/// The supervisor (`watch-world`): run the world, keep the relay alive while it runs, stop the relay after it.
/// `launcher` is the launcher executable that runs the relay (`None`: the Python relay).
pub fn watch_world(root: &Path, launcher: Option<&Path>, log: Progress) -> Result<()> {
squid::validate_bots(root)?;
let world = spawn_child(root, "world", &root.join("Core/worldserver.exe"), &["-c", "configs/worldserver.conf"], &root.join("Core"), &root.join("Core/Logs/world-console.log"))?;
let mut relay: Option<Proc> = None;
while world.try_wait().is_none() {
let dead = relay.as_ref().is_none_or(|r| r.try_wait().is_some());
if dead {
match spawn_relay(root, launcher) {
Ok(r) => relay = Some(r),
Err(e) => {
log(&format!("Report relay could not start ({e}); retrying."));
std::thread::sleep(Duration::from_secs(5));
continue;
}
}
}
std::thread::sleep(Duration::from_secs(2));
}
std::fs::write(stop_relay_flag(root), b"")?;
if let Some(r) = relay {
let until = Instant::now() + Duration::from_secs(40);
while r.try_wait().is_none() && Instant::now() < until {
std::thread::sleep(Duration::from_millis(250));
}
if r.try_wait().is_none() {
// An interrupted POST stays uncertain in the relay's journal; it is not resent.
if let Some(record) = state::running(root, "relay") {
services::terminate(&record)?;
}
}
}
Ok(())
}
// ---------------------------------------------------------------------------------------------------------------
// Detailed logging (Debug_Logs_On.bat / Debug_Logs_Off.bat)
// ---------------------------------------------------------------------------------------------------------------
const DEBUG_TEMPLATES: [&str; 2] = ["worldserver.conf.template", "authserver.conf.template"];
/// One template line with every logger forced to Trace and the console/server appenders to the most detail.
fn debug_line(line: &str) -> String {
let body = line.strip_prefix('#').unwrap_or(line).trim_start();
for appender in ["Appender.Console", "Appender.Server"] {
if let Some(rest) = body.strip_prefix(appender).and_then(|r| r.strip_prefix('=')) {
let parts: Vec<&str> = rest.splitn(4, ',').collect();
if parts.len() == 4 && parts[..3].iter().all(|p| !p.is_empty() && p.bytes().all(|b| b.is_ascii_digit())) {
return format!("{appender}={},6,7,{}", parts[0], parts[3]);
}
}
}
if let Some(rest) = body.strip_prefix("Logger.") {
if let Some((name, value)) = rest.split_once('=') {
if !name.is_empty() && name.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'_' || b == b'.') {
if let Some((level, tail)) = value.split_once(',') {
if !level.is_empty() && level.bytes().all(|b| b.is_ascii_digit()) {
return format!("Logger.{name}=6,{tail}");
}
}
}
}
}
let t = line.trim_end();
if let Some(v) = t.strip_prefix("Log.Async.Enable") {
let v = v.trim_start();
if let Some(n) = v.strip_prefix('=') {
let n = n.trim();
if !n.is_empty() && n.bytes().all(|b| b.is_ascii_digit()) {
return "Log.Async.Enable = 1".into();
}
}
}
line.to_string()
}
/// Turn detailed logging on or off (the templates; services apply it at their next start). Returns the changed
/// templates.
pub fn debug_logs(root: &Path, enable: bool) -> Result<Vec<String>> {
let mut changed = Vec::new();
for name in DEBUG_TEMPLATES {
let path = root.join("Settings").join(name);
let original = root.join("Settings").join(format!("{name}.original"));
if !original.exists() {
std::fs::write(&original, std::fs::read(&path)?)?;
}
let new_bytes = if enable {
let text = String::from_utf8(std::fs::read(&original)?).map_err(|_| Error::Invalid(format!("{name} is not UTF-8.")))?;
let newline = if text.contains("\r\n") { "\r\n" } else { "\n" };
let mut out = text.lines().map(debug_line).collect::<Vec<_>>().join(newline);
if text.ends_with('\n') {
out.push_str(newline);
}
out.into_bytes()
} else {
std::fs::read(&original)?
};
if std::fs::read(&path)? != new_bytes {
std::fs::write(&path, &new_bytes)?;
changed.push(name.to_string());
}
}
state::write_json(&state::dir(root).join("debug-logs.json"), &serde_json::json!({ "enabled": enable }))?;
Ok(changed)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn detailed_logging_rewrites_loggers_and_restores_the_original() {
let d = tempfile::tempdir().unwrap();
std::fs::create_dir_all(d.path().join("Settings")).unwrap();
let world = "Appender.Console=1,3,0\r\nAppender.Server=2,2,0,Server.log,w\r\n#Logger.module=4,Console Server\r\nLogger.root=5,Console Server\r\nLog.Async.Enable = 0\r\nOther = 1\r\n";
std::fs::write(d.path().join("Settings/worldserver.conf.template"), world).unwrap();
std::fs::write(d.path().join("Settings/authserver.conf.template"), "Logger.root=2,Console\n").unwrap();
let changed = debug_logs(d.path(), true).unwrap();
assert_eq!(changed.len(), 2);
assert_eq!(
std::fs::read_to_string(d.path().join("Settings/worldserver.conf.template")).unwrap(),
"Appender.Console=1,3,0\r\nAppender.Server=2,6,7,Server.log,w\r\nLogger.module=6,Console Server\r\nLogger.root=6,Console Server\r\nLog.Async.Enable = 1\r\nOther = 1\r\n"
);
assert_eq!(debug_logs(d.path(), true).unwrap().len(), 0, "already on");
debug_logs(d.path(), false).unwrap();
assert_eq!(std::fs::read_to_string(d.path().join("Settings/worldserver.conf.template")).unwrap(), world);
assert_eq!(services::status(d.path())["debugLogs"], false);
}
}
-85
View File
@@ -1,85 +0,0 @@
import runpy
import sys
import time
from pathlib import Path
script = sys.argv[1]
sys.path.insert(0, str(Path(script).resolve().parent))
sys.argv = sys.argv[1:]
launcher = runpy.run_path(script, run_name="coa_manager_launcher")
original_wait = launcher["wait_ready"]
world_deadline = None
def wait_ready(name, port, seconds=180):
global world_deadline
if name == "mysql":
seconds = max(seconds, 300)
elif name == "world":
# Both game and console listeners belong to one startup, including on old repacks.
# Ordinary CoA worlds can load slowly too; this must not depend on SQUID.
if world_deadline is None:
world_deadline = time.monotonic() + max(seconds, 1500)
seconds = max(0, world_deadline - time.monotonic())
return original_wait(name, port, seconds)
launcher["start_mysql"].__globals__["wait_ready"] = wait_ready
if sys.argv[1] in ("stop-all", "force-stop-all"):
shutdown = launcher["stop_all"].__globals__
class UnsafeShutdown(Exception):
pass
def stop_owned_world(world):
expected = Path(script).resolve().parents[1] / "Core" / "worldserver.exe"
if Path(world.get("exe", "")) != expected or not shutdown["same_process"](world):
raise UnsafeShutdown("World process ownership could not be verified; the database was left running.")
try:
shutdown["terminate"](world)
except (OSError, RuntimeError) as error:
raise UnsafeShutdown("Worldserver could not be stopped safely; its database was left running.") from error
if not shutdown["wait_stopped"](world, 90):
raise UnsafeShutdown("Worldserver is still stopping; its database was left running.")
if "ra" in shutdown:
original_ra = shutdown["ra"]
def shutdown_command(command, config):
try:
return original_ra(command, config)
except (OSError, RuntimeError):
if not command.startswith("server shutdown "):
raise
world = shutdown["process"]("world")
if not world:
return "Worldserver has already stopped."
stop_owned_world(world)
return "Stopped this server's recorded world process without its unavailable console."
shutdown["ra"] = shutdown_command
config = launcher["settings"]()
with launcher["control_lock"]():
if sys.argv[1] == "force-stop-all":
world = shutdown["process"]("world")
if world:
stop_owned_world(world)
print("Force-stopped this server's verified world process; unsaved progress may be lost.", flush=True)
launcher["stop_all"](config)
else:
launcher["main"]()
if sys.argv[1] in ("start-all", "start-world"):
config = launcher["settings"]()
deadline = world_deadline if world_deadline is not None else time.monotonic() + 1500
last_error = None
while time.monotonic() < deadline:
if not launcher["process"]("world"):
raise RuntimeError("World startup failed: worldserver stopped before its console accepted commands.")
try:
launcher["ra"]("server info", config)
print("World console is accepting commands.", flush=True)
break
except (OSError, RuntimeError) as error:
last_error = error
time.sleep(0.5)
else:
raise RuntimeError(f"World startup failed: its console is still starting. {last_error}")
+222
View File
@@ -0,0 +1,222 @@
//! `Scripts/manage.py` as Managers up to 0.9.10 edited it.
//!
//! Those Managers ran the repack's Python launcher themselves and changed its text: an import fix for their bridge
//! and a realm-profile patch (database and realm row of the active realm). This Manager starts servers with
//! [`crate::launcher`] and never edits the file; it only has to recognise those edits, so that an update or a file
//! check treats a file one of them changed as unmodified. Nothing here writes a file.
use crate::error::{Error, Result};
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";
fn launcher_insert() -> String {
LAUNCHER_REALM_INSERT
.replace("profiles-v1", "profiles-v2")
.replace(
"return 2 if",
"return 3 if coa_realm() == 'reborn' else 2 if",
)
.replace(
"return 'Wildcard' if",
"return 'Warcraft Reborn' if coa_realm() == 'reborn' else 'Wildcard' if",
)
}
fn launcher_replacements() -> Vec<(&'static str, String)> {
LAUNCHER_REALM_REPLACEMENTS.iter().map(|(from, to)| (*from, to
.replace("\"acore_world_wildcard\" if", "\"acore_world_reborn\" if coa_realm() == 'reborn' else \"acore_world_wildcard\" if")
.replace("\"acore_characters_wildcard\" if", "\"acore_characters_reborn\" if coa_realm() == 'reborn' else \"acore_characters_wildcard\" if"))).collect()
}
/// The realm-profile patch older Managers wrote.
pub(crate) fn patch_launcher(source: &str) -> Result<String> {
if source.contains("# coa-manager-realm-profiles-v2") {
return Ok(source.into());
}
if source.contains("# coa-manager-realm-profiles-v1") {
let original = unpatch_launcher(source)
.ok_or_else(|| Error::Invalid("Unrecognised realm launcher patch.".into()))?;
return patch_launcher(&original);
}
let mut out = source.to_string();
for (from, to) in launcher_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);
}
// 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!("{}{marker}", launcher_insert())))
}
/// Reverse only our exact realm transformation; callers must verify the recovered original hash.
pub(crate) fn unpatch_launcher(source: &str) -> Option<String> {
let (insert, replacements) = if source.contains(&launcher_insert()) {
(launcher_insert(), launcher_replacements())
} else if source.contains(LAUNCHER_REALM_INSERT) {
(
LAUNCHER_REALM_INSERT.into(),
LAUNCHER_REALM_REPLACEMENTS
.iter()
.map(|(a, b)| (*a, b.to_string()))
.collect(),
)
} else {
return None;
};
let mut original = source.replacen(&insert, "", 1);
for (from, to) in &replacements {
original = original.replace(to, from);
}
let mut check = original.clone();
for (from, to) in &replacements {
check = check.replace(from, to);
}
check = check.replace(
"if __name__ == \"__main__\":",
&format!("{insert}if __name__ == \"__main__\":"),
);
(check == source).then_some(original)
}
/// The import fix older Managers wrote (needed to run manage.py through their bridge).
pub(crate) fn patch_launcher_imports(text: &str) -> Result<String> {
let line = "sys.path.insert(0, str(Path(__file__).resolve().parent))";
if !text.contains("from squid_playerbots import") || text.contains(line) {
return Ok(text.into());
}
let root = "ROOT = Path(__file__).resolve().parents[1]";
if !text.contains(root) || !text.lines().any(|line| line.trim() == "import sys") {
return Err(Error::Invalid(
"The server launcher cannot load its integration scripts. Repair its program files."
.into(),
));
}
Ok(text.replacen(root, &format!("{root}\n{line}"), 1))
}
pub(crate) fn launcher_matches(signed: &str, actual: &[u8]) -> bool {
if signed.as_bytes() == actual {
return true;
}
if patch_launcher_imports(signed).is_ok_and(|s| s.as_bytes() == actual) {
return true;
}
patch_launcher(signed).is_ok_and(|s| {
s.as_bytes() == actual || 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()),
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
}
#[cfg(test)]
mod tests {
use super::*;
use crate::fsx;
use std::collections::BTreeMap;
use std::fs;
#[test]
fn old_launcher_upgrades_and_both_patch_versions_are_reversible() {
let original = "(\"WorldDatabaseInfo\", \"acore_world\")\n(\"CharacterDatabaseInfo\", \"acore_characters\")\nSET name='AzerothCore',address=\nWHERE id=1;\nmysql(\"UPDATE acore_auth.realmlist SET flag=0\nif __name__ == \"__main__\":\n";
let mut old = original.to_string();
for (from, to) in LAUNCHER_REALM_REPLACEMENTS {
old = old.replace(from, to);
}
old = old.replace(
"if __name__ == \"__main__\":",
&format!("{LAUNCHER_REALM_INSERT}if __name__ == \"__main__\":"),
);
assert_eq!(unpatch_launcher(&old).as_deref(), Some(original));
let new = patch_launcher(&old).unwrap();
assert!(new.contains("acore_world_reborn"));
assert!(new.contains("return 3 if coa_realm() == 'reborn'"));
assert!(new.contains("return 'Warcraft Reborn' if"));
assert_eq!(patch_launcher(&new).unwrap(), new);
assert_eq!(unpatch_launcher(&new).as_deref(), Some(original));
}
#[test]
fn unknown_launcher_is_refused_without_partial_patching() {
assert!(patch_launcher("print('custom launcher')").is_err());
}
#[test]
fn launcher_import_fix_is_idempotent_and_retains_other_code() {
let text = "import sys\nROOT = Path(__file__).resolve().parents[1]\nfrom squid_playerbots import validate_bots\ncustom = 42\n";
let fixed = patch_launcher_imports(text).unwrap();
assert!(fixed.contains("sys.path.insert(0, str(Path(__file__).resolve().parent))"));
assert!(fixed.ends_with("custom = 42\n"));
assert_eq!(patch_launcher_imports(&fixed).unwrap(), fixed);
}
#[test]
fn a_launcher_patched_by_an_older_manager_stays_pristine_but_external_edits_conflict() {
let d = tempfile::tempdir().unwrap();
let root = d.path().join("server");
let source = "(\"WorldDatabaseInfo\", \"acore_world\")\n(\"CharacterDatabaseInfo\", \"acore_characters\")\nSET name='AzerothCore',address=\nWHERE id=1;\nmysql(\"UPDATE acore_auth.realmlist SET flag=0\nif __name__ == \"__main__\":\n";
fsx::atomic_write(&root.join("Scripts/manage.py"), source.as_bytes()).unwrap();
// What an older Manager left: the realm patch applied and its hash recorded as the pristine one.
let patched = patch_launcher(source).unwrap();
fsx::atomic_write(&root.join("Scripts/manage.py"), patched.as_bytes()).unwrap();
let mut meta = crate::registry::InstallMeta::new(crate::registry::InstallKind::New, &root);
meta.original_hashes.insert("Scripts/manage.py".into(), fsx::sha256_bytes(patched.as_bytes()));
crate::registry::MetaDir::create(&root, &meta).unwrap();
assert!(crate::diag::verify_managed(&root, &meta).is_empty());
let manifest: crate::manifest::Manifest = serde_json::from_value(serde_json::json!({
"schema": 1, "kind": "update", "version": "2.0.0", "core": {"commit": null}, "builtAt": "fixture", "minManagerVersion": "0.1.0",
"files": [{"path":"Scripts/manage.py","sha256":fsx::sha256_bytes(b"next release"),"size":12,"owner":"core","policy":"replace"}]
})).unwrap();
assert_eq!(
crate::update::plan(&root, &meta, &manifest, &BTreeMap::new(), None).unwrap()[0].action,
crate::update::Action::Replace
);
let mut modified = fs::read(root.join("Scripts/manage.py")).unwrap();
modified.extend_from_slice(b"# custom edit\n");
fsx::atomic_write(&root.join("Scripts/manage.py"), &modified).unwrap();
assert_eq!(
crate::update::plan(&root, &meta, &manifest, &BTreeMap::new(), None).unwrap()[0].action,
crate::update::Action::Conflict
);
}
}
+2
View File
@@ -28,6 +28,7 @@ pub mod diag;
pub mod docker;
pub mod download;
pub mod driver;
pub mod legacy_launcher;
pub mod error;
pub mod firewall;
pub mod friends;
@@ -36,6 +37,7 @@ pub mod glue_config;
pub mod health;
pub mod install;
pub mod layout;
pub mod launcher;
pub mod logging;
pub mod server_logging;
pub mod manifest;
+12 -28
View File
@@ -176,7 +176,6 @@ fn set_tree(main: &Path, tree: Tree, enabled: bool) -> Result<realms::View> {
}
}
}
secondary_launcher(&fs::read_to_string(main.join("Scripts/manage.py"))?)?;
}
let status = process::observe(main, &crate::layout::read_ports(main));
if status.world.state != ServiceState::Stopped
@@ -349,25 +348,18 @@ fn prepare(main: &Path, tree: Tree) -> Result<PathBuf> {
..Default::default()
},
)?;
let source = fs::read_to_string(main.join("Scripts/manage.py"))?;
let source = secondary_launcher(&source)?;
fsx::atomic_write(&second.join("Scripts/manage.py"), source.as_bytes())?;
Ok(second)
}
fn secondary_launcher(source: &str) -> Result<String> {
let marker = "def start_world(config, offset):\n start_mysql(config)";
let source = source.replace("\r\n", "\n");
if !source.contains(marker) {
return Err(Error::Invalid(
"The launcher does not support a shared database world. Update the server first."
.into(),
));
// The world supervisor and the bug-report relay of the extra world (the launcher itself runs in the Manager
// and knows that this world shares the main database).
for script in ["Scripts/coa-launcher.exe", "Scripts/manage.py"] {
let target = second.join(script);
if main.join(script).is_file() {
fs::create_dir_all(second.join("Scripts"))?;
fsx::atomic_write(&target, &fs::read(main.join(script))?)?;
} else if target.exists() {
fs::remove_file(&target)?;
}
}
Ok(source.replace(
marker,
"def start_world(config, offset):\n mysql(admin=\"ping\")",
))
Ok(second)
}
fn start_tree(main: &Path, tree: Tree) -> Result<()> {
@@ -408,7 +400,7 @@ pub fn start(main: &Path) -> Result<()> {
fn stop_tree(main: &Path, tree: Tree) -> Result<()> {
let second = tree_root(main, tree);
if !second.join("Scripts/manage.py").exists() {
if !second.join("Settings/repack.json").exists() {
if tree_running(main, tree) {
return Err(Error::Invalid(format!(
"The running {}'s launcher is missing. The shared database was left running.",
@@ -505,12 +497,4 @@ mod tests {
assert!(err.contains(expected), "{err}");
assert!(!realms::state(t.path()).unwrap().with_reborn);
}
#[test]
fn secondary_never_starts_the_shared_database() {
let patched = secondary_launcher("def start_world(config, offset):\r\n start_mysql(config)\r\n wait_ready('world', 8086)\r\n").unwrap();
assert!(patched.contains("mysql(admin=\"ping\")"));
assert!(!patched.contains("start_mysql(config)"));
assert!(secondary_launcher("def start_world(): pass").is_err());
}
}
+23
View File
@@ -88,6 +88,29 @@ impl Ra {
self.command(c)
}
/// Send a command whose answer does not matter (`server shutdown`). The reply is still read (up to the next
/// prompt, the end of the connection, or a few seconds): closing a socket that holds unread data resets the
/// connection, and the server can then drop the command it has not processed yet.
pub fn send_without_answer(mut self, cmd: &str) -> Result<()> {
let c = crate::console::check_command(cmd)?;
self.stream.write_all(format!("{c}\r\n").as_bytes())?;
self.stream.flush()?;
self.stream.set_read_timeout(Some(Duration::from_secs(10)))?;
let mut seen = Vec::new();
let mut buf = [0u8; 4096];
while let Ok(n) = self.stream.read(&mut buf) {
if n == 0 {
break;
}
seen.extend_from_slice(&buf[..n]);
if seen.ends_with(b"AC>") || seen.len() > 1 << 20 {
break;
}
}
let _ = self.stream.shutdown(std::net::Shutdown::Both);
Ok(())
}
fn command(&mut self, cmd: &str) -> Result<String> {
debug_assert!(!cmd.contains(['\r', '\n']));
self.stream.write_all(format!("{cmd}\r\n").as_bytes())?;
-196
View File
@@ -534,8 +534,6 @@ pub fn ensure_created(root: &Path, mode: Mode) -> Result<()> {
"Update the server to a build with Warcraft Reborn support first.".into(),
));
}
// Verify launcher support before creating databases, as selecting a realm does.
prepare_launcher(root)?;
let before = configs(root)?;
create_realm(root, &mut s, mode, &before)
}
@@ -565,8 +563,6 @@ pub fn select(root: &Path, mode: Mode) -> Result<View> {
"Disable the realms that start together before switching realms.".into(),
));
}
// Verify launcher support before creating databases or changing the selected realm.
prepare_launcher(root)?;
let before = configs(root)?;
fsx::atomic_write_json(&snapshot(root, s.active), &before)?;
create_realm(root, &mut s, mode, &before)?;
@@ -608,125 +604,6 @@ pub fn select(root: &Path, mode: Mode) -> Result<View> {
view(root)
}
/// 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)?;
if patched != source {
fsx::atomic_write(&path, patched.as_bytes())?;
// A Manager-owned transformation is still pristine for subsequent updates and file checks.
if let Ok(dir) = crate::registry::metadata_dir_for(root) {
if let Ok((_, mut meta)) = crate::registry::MetaDir::open(&dir) {
if meta
.original_hashes
.get("Scripts/manage.py")
.is_some_and(|hash| hash == &fsx::sha256_bytes(source.as_bytes()))
{
meta.original_hashes.insert(
"Scripts/manage.py".into(),
fsx::sha256_bytes(patched.as_bytes()),
);
fsx::atomic_write_json(&dir.join("install.json"), &meta)?;
}
}
}
}
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";
fn launcher_insert() -> String {
LAUNCHER_REALM_INSERT
.replace("profiles-v1", "profiles-v2")
.replace(
"return 2 if",
"return 3 if coa_realm() == 'reborn' else 2 if",
)
.replace(
"return 'Wildcard' if",
"return 'Warcraft Reborn' if coa_realm() == 'reborn' else 'Wildcard' if",
)
}
fn launcher_replacements() -> Vec<(&'static str, String)> {
LAUNCHER_REALM_REPLACEMENTS.iter().map(|(from, to)| (*from, to
.replace("\"acore_world_wildcard\" if", "\"acore_world_reborn\" if coa_realm() == 'reborn' else \"acore_world_wildcard\" if")
.replace("\"acore_characters_wildcard\" if", "\"acore_characters_reborn\" if coa_realm() == 'reborn' else \"acore_characters_wildcard\" if"))).collect()
}
pub(crate) fn patch_launcher(source: &str) -> Result<String> {
if source.contains("# coa-manager-realm-profiles-v2") {
return Ok(source.into());
}
if source.contains("# coa-manager-realm-profiles-v1") {
let original = unpatch_launcher(source)
.ok_or_else(|| Error::Invalid("Unrecognised realm launcher patch.".into()))?;
return patch_launcher(&original);
}
let mut out = source.to_string();
for (from, to) in launcher_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);
}
// 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!("{}{marker}", launcher_insert())))
}
/// Reverse only our exact realm transformation; callers must verify the recovered original hash.
pub(crate) fn unpatch_launcher(source: &str) -> Option<String> {
let (insert, replacements) = if source.contains(&launcher_insert()) {
(launcher_insert(), launcher_replacements())
} else if source.contains(LAUNCHER_REALM_INSERT) {
(
LAUNCHER_REALM_INSERT.into(),
LAUNCHER_REALM_REPLACEMENTS
.iter()
.map(|(a, b)| (*a, b.to_string()))
.collect(),
)
} else {
return None;
};
let mut original = source.replacen(&insert, "", 1);
for (from, to) in &replacements {
original = original.replace(to, from);
}
let mut check = original.clone();
for (from, to) in &replacements {
check = check.replace(from, to);
}
check = check.replace(
"if __name__ == \"__main__\":",
&format!("{insert}if __name__ == \"__main__\":"),
);
(check == source).then_some(original)
}
/// The character-creation model the world server advertises for a realm. Every realm has its own database and its own
/// entry on Overview, so it advertises exactly one model: a list such as `"coa wcr"` would let players create
/// Warcraft Reborn characters in the Conquest of Azeroth realm.
@@ -770,7 +647,6 @@ pub fn before_start(root: &Path) -> Result<()> {
if !root.join(STATE).exists() {
return Ok(());
}
prepare_launcher(root)?;
if s.simultaneous && !view(root)?.supported {
return Err(Error::Invalid(
"The installed server build does not support simultaneous Wildcard startup.".into(),
@@ -1107,26 +983,6 @@ CoA.GameModeMask = 0
assert!(!v.supported);
}
#[test]
fn old_launcher_upgrades_and_both_patch_versions_are_reversible() {
let original = "(\"WorldDatabaseInfo\", \"acore_world\")\n(\"CharacterDatabaseInfo\", \"acore_characters\")\nSET name='AzerothCore',address=\nWHERE id=1;\nmysql(\"UPDATE acore_auth.realmlist SET flag=0\nif __name__ == \"__main__\":\n";
let mut old = original.to_string();
for (from, to) in LAUNCHER_REALM_REPLACEMENTS {
old = old.replace(from, to);
}
old = old.replace(
"if __name__ == \"__main__\":",
&format!("{LAUNCHER_REALM_INSERT}if __name__ == \"__main__\":"),
);
assert_eq!(unpatch_launcher(&old).as_deref(), Some(original));
let new = patch_launcher(&old).unwrap();
assert!(new.contains("acore_world_reborn"));
assert!(new.contains("return 3 if coa_realm() == 'reborn'"));
assert!(new.contains("return 'Warcraft Reborn' if"));
assert_eq!(patch_launcher(&new).unwrap(), new);
assert_eq!(unpatch_launcher(&new).as_deref(), Some(original));
}
#[test]
fn a_docker_server_is_checked_for_wildcard_support_in_its_own_binary() {
let d = tempfile::tempdir().unwrap();
@@ -1157,20 +1013,6 @@ CoA.GameModeMask = 0
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();
@@ -1270,42 +1112,4 @@ CoA.GameModeMask = 0
.is_err());
assert!(guard_module(t.path(), "content-scaling").is_ok());
}
#[test]
fn unknown_launcher_is_refused_without_partial_patching() {
assert!(patch_launcher("print('custom launcher')").is_err());
}
#[test]
fn managed_launcher_patch_remains_pristine_but_external_edits_conflict() {
let d = tempfile::tempdir().unwrap();
let root = d.path().join("server");
let source = "(\"WorldDatabaseInfo\", \"acore_world\")\n(\"CharacterDatabaseInfo\", \"acore_characters\")\nSET name='AzerothCore',address=\nWHERE id=1;\nmysql(\"UPDATE acore_auth.realmlist SET flag=0\nif __name__ == \"__main__\":\n";
fsx::atomic_write(&root.join("Scripts/manage.py"), source.as_bytes()).unwrap();
let mut meta = crate::registry::InstallMeta::new(crate::registry::InstallKind::New, &root);
meta.original_hashes.insert(
"Scripts/manage.py".into(),
fsx::sha256_bytes(source.as_bytes()),
);
let dir = crate::registry::MetaDir::create(&root, &meta).unwrap();
prepare_launcher(&root).unwrap();
let (_, meta) = crate::registry::MetaDir::open(&dir.root).unwrap();
assert!(crate::diag::verify_managed(&root, &meta).is_empty());
let manifest: crate::manifest::Manifest = serde_json::from_value(serde_json::json!({
"schema": 1, "kind": "update", "version": "2.0.0", "core": {"commit": null}, "builtAt": "fixture", "minManagerVersion": "0.1.0",
"files": [{"path":"Scripts/manage.py","sha256":fsx::sha256_bytes(b"next release"),"size":12,"owner":"core","policy":"replace"}]
})).unwrap();
assert_eq!(
crate::update::plan(&root, &meta, &manifest, &BTreeMap::new(), None).unwrap()[0].action,
crate::update::Action::Replace
);
let mut modified = fs::read(root.join("Scripts/manage.py")).unwrap();
modified.extend_from_slice(b"# custom edit\n");
fsx::atomic_write(&root.join("Scripts/manage.py"), &modified).unwrap();
prepare_launcher(&root).unwrap();
assert_eq!(
crate::update::plan(&root, &meta, &manifest, &BTreeMap::new(), None).unwrap()[0].action,
crate::update::Action::Conflict
);
}
}
+8 -8
View File
@@ -403,7 +403,7 @@ pub fn plan(
match (fs::read_to_string(tree.join(&f.path)), fs::read(&target)) {
(Ok(signed), Ok(actual)) => {
fsx::sha256_bytes(signed.as_bytes()) == f.sha256
&& crate::driver::launcher_matches(&signed, &actual)
&& crate::legacy_launcher::launcher_matches(&signed, &actual)
}
_ => false,
}
@@ -418,7 +418,7 @@ pub fn plan(
let manager_launcher = f.path == "Scripts/manage.py"
&& recorded.is_some_and(|hash| {
fs::read(&target).is_ok_and(|bytes| {
crate::driver::launcher_matches_recorded(hash, &bytes)
crate::legacy_launcher::launcher_matches_recorded(hash, &bytes)
})
});
if f.path == "Core/worldserver.exe"
@@ -614,7 +614,7 @@ fn launcher_already_integrated(
if meta.original_hashes.get(&file.path) != Some(&fsx::sha256_bytes(&actual)) {
return Ok(false);
}
Ok(crate::driver::launcher_matches_recorded(
Ok(crate::legacy_launcher::launcher_matches_recorded(
&file.sha256,
&actual,
))
@@ -968,7 +968,7 @@ fn finish(
fs::read_to_string(tree.join(&op.path)),
fs::read(root.join(&op.path)),
) {
(Ok(signed), Ok(actual)) if crate::driver::launcher_matches(&signed, &actual) => {
(Ok(signed), Ok(actual)) if crate::legacy_launcher::launcher_matches(&signed, &actual) => {
fsx::sha256_bytes(&actual)
}
_ => op.new_sha256.clone(),
@@ -1060,7 +1060,7 @@ pub fn retry_validation(
&& fs::read_to_string(dir.join("tree").join(&op.path))
.ok()
.filter(|s| fsx::sha256_bytes(s.as_bytes()) == file.sha256)
.is_some_and(|s| crate::driver::launcher_matches(&s, &bytes));
.is_some_and(|s| crate::legacy_launcher::launcher_matches(&s, &bytes));
if actual != file.sha256 && !launcher {
return Err(Error::Invalid(format!(
"{} changed since the update was applied; use repair or rollback.",
@@ -2347,9 +2347,9 @@ mod tests {
fn legacy_launcher_world(import_patch: bool) -> World {
let w = world(&[("Scripts/manage.py", b"new release launcher")], false);
let mut source = crate::realms::patch_launcher(LEGACY_LAUNCHER).unwrap();
let mut source = crate::legacy_launcher::patch_launcher(LEGACY_LAUNCHER).unwrap();
if import_patch {
source = crate::driver::patch_launcher_imports(&source).unwrap();
source = crate::legacy_launcher::patch_launcher_imports(&source).unwrap();
}
write(&w.root, "Scripts/manage.py", source.as_bytes());
let (_, mut meta) = MetaDir::open(&w.meta).unwrap();
@@ -2576,7 +2576,7 @@ mod tests {
let w = world(&[("Scripts/manage.py", source)], false);
run(&w, &Fake::ok(), BTreeMap::new(), None).unwrap();
let integrated =
crate::driver::patch_launcher_imports(std::str::from_utf8(source).unwrap()).unwrap();
crate::legacy_launcher::patch_launcher_imports(std::str::from_utf8(source).unwrap()).unwrap();
write(&w.root, "Scripts/manage.py", integrated.as_bytes());
let (_, mut meta) = MetaDir::open(&w.meta).unwrap();
meta.original_hashes.insert(
+15
View File
@@ -0,0 +1,15 @@
[package]
name = "coa-launcher"
description = "The CoA repack launcher (Start_All_Server.bat and friends) without Python"
version.workspace = true
edition.workspace = true
license.workspace = true
[[bin]]
name = "coa-launcher"
path = "src/main.rs"
[dependencies]
coa-core = { path = "../coa-core" }
serde_json = "1"
windows-sys = { version = "0.60", features = ["Win32_Foundation", "Win32_System_Console"] }
+222
View File
@@ -0,0 +1,222 @@
//! `coa-launcher.exe`: the repack launcher, the same commands as `Scripts/manage.py`.
//!
//! It lives in `<server>/Scripts/` next to manage.py (the server folder is its parent), or takes `--root <folder>`.
//! Errors are printed as `ERROR: <message>` on stderr with exit code 1, exactly like manage.py, because the
//! Manager reads them.
use std::io::{BufRead, Write};
use std::path::{Path, PathBuf};
use std::time::Duration;
use coa_core::launcher::ops::{self, Action};
use coa_core::launcher::{services, settings::Settings, state, world};
const ACTIONS: [&str; 18] = [
"start-all", "start-mysql", "start-auth", "start-world", "stop-all", "force-stop-all", "status", "status-json", "create-account",
"create-account-once", "console", "ra-once", "prepare", "watch-world", "relay-worker", "debug-logs-on",
"debug-logs-off", "debug-logs-status",
];
fn say(text: &str) {
println!("{text}");
let _ = std::io::stdout().flush();
}
fn usage() -> String {
format!("usage: coa-launcher [--root <server>] [--port-offset N] {{{}}}", ACTIONS.join(","))
}
struct Args {
root: PathBuf,
offset: i32,
action: String,
}
fn parse() -> Result<Args, String> {
let mut root: Option<PathBuf> = None;
let mut offset = 0;
let mut action = None;
let mut it = std::env::args().skip(1);
while let Some(a) = it.next() {
match a.as_str() {
"--root" => root = Some(PathBuf::from(it.next().ok_or_else(usage)?)),
"--port-offset" => offset = it.next().and_then(|v| v.parse().ok()).ok_or_else(usage)?,
_ if ACTIONS.contains(&a.as_str()) && action.is_none() => action = Some(a),
_ => return Err(usage()),
}
}
let root = match root {
Some(r) => r,
None => {
// <server>/Scripts/coa-launcher.exe -> <server>
let exe = std::env::current_exe().map_err(|e| e.to_string())?;
exe.parent().and_then(Path::parent).map(Path::to_path_buf).ok_or("cannot find the server folder")?
}
};
Ok(Args { root, offset, action: action.ok_or_else(usage)? })
}
fn read_line(prompt: &str) -> std::io::Result<String> {
print!("{prompt}");
std::io::stdout().flush()?;
let mut line = String::new();
std::io::stdin().lock().read_line(&mut line)?;
Ok(line.trim_end_matches(['\r', '\n']).to_string())
}
/// Read a line without showing it (passwords).
fn read_secret(prompt: &str) -> std::io::Result<String> {
#[cfg(windows)]
unsafe {
use windows_sys::Win32::System::Console::{GetConsoleMode, GetStdHandle, SetConsoleMode, ENABLE_ECHO_INPUT, STD_INPUT_HANDLE};
let h = GetStdHandle(STD_INPUT_HANDLE);
let mut mode = 0;
if GetConsoleMode(h, &mut mode) != 0 {
SetConsoleMode(h, mode & !ENABLE_ECHO_INPUT);
let line = read_line(prompt);
SetConsoleMode(h, mode);
println!();
return line;
}
}
read_line(prompt)
}
fn valid_login(text: &str) -> bool {
(1..=16).contains(&text.len()) && text.bytes().all(|b| b.is_ascii_alphanumeric())
}
fn ra(cfg: &Settings, root: &Path, command: &str) -> Result<String, String> {
if !services::ready(root, "world", cfg.ra_port) {
return Err("Start this repack's worldserver first.".into());
}
let mut console = coa_core::ra::Ra::connect_to(cfg.ra_port, &cfg.ra_username, &cfg.ra_password).map_err(|e| e.to_string())?;
console.run(command).map_err(|e| e.to_string())
}
fn run(args: Args) -> Result<(), String> {
let root = args.root.as_path();
let e = |x: coa_core::Error| x.to_string();
match args.action.as_str() {
"watch-world" => {
let me = std::env::current_exe().map_err(|x| x.to_string())?;
return world::watch_world(root, Some(&me), &|m| say(m)).map_err(e);
}
"relay-worker" => return coa_core::launcher::relay::worker(root).map_err(e),
"debug-logs-status" => {
let on = services::status(root)["debugLogs"].as_bool().unwrap_or(false);
say(&format!("Detailed server logging is {}.", if on { "ON" } else { "off" }));
if on {
say("Every AzerothCore logger is forced to Trace level in Core/Logs (Server.log, Auth.log, world-console.log, auth-console.log). Expect much larger, faster-growing log files.");
}
say("Run Debug_Logs_On.bat / Debug_Logs_Off.bat, then restart the affected service(s) to apply.");
return Ok(());
}
"debug-logs-on" | "debug-logs-off" => {
let on = args.action == "debug-logs-on";
let changed = {
let _lock = state::ControlLock::acquire(root, &args.action, Duration::from_secs(30), &|m| say(m)).map_err(e)?;
world::debug_logs(root, on).map_err(e)?
};
if changed.is_empty() {
say(&format!("Detailed logging was already {}.", if on { "on" } else { "off" }));
} else {
say(&format!("{} detailed logging in: {}", if on { "Enabled" } else { "Restored" }, changed.join(", ")));
}
say("Restart the affected service(s) (Stop_All_Server.bat then Start_All_Server.bat) to apply this.");
return Ok(());
}
_ => {}
}
let cfg = Settings::load(root, args.offset).map_err(e)?;
match args.action.as_str() {
"console" => {
say("World console. Enter a server command, or exit to close this window.");
loop {
let command = read_line("AC> ").map_err(|x| x.to_string())?;
let command = command.trim();
if command.eq_ignore_ascii_case("exit") || command.eq_ignore_ascii_case("quit") {
return Ok(());
}
if !command.is_empty() {
say(&ra(&cfg, root, command)?);
}
}
}
"create-account" => {
let name = read_line("New account name (letters and digits, up to 16): ").map_err(|x| x.to_string())?;
let name = name.trim();
let password = read_secret("New account password (letters and digits, up to 16): ").map_err(|x| x.to_string())?;
let again = read_secret("Repeat password: ").map_err(|x| x.to_string())?;
if !valid_login(name) || !valid_login(&password) {
return Err("Use 1-16 letters or digits for the account name and password.".into());
}
if password != again {
return Err("Passwords do not match.".into());
}
say(&ra(&cfg, root, &format!("account create {name} {password}"))?);
if read_line("Give this account GM permissions? [y/N]: ").map_err(|x| x.to_string())?.trim().eq_ignore_ascii_case("y") {
say(&ra(&cfg, root, &format!("account set gmlevel {name} 3 -1"))?);
}
return Ok(());
}
"ra-once" => {
let command = read_line("").map_err(|x| x.to_string())?;
let command = command.trim();
if command.is_empty() {
return Err("No command given.".into());
}
say(&ra(&cfg, root, command)?);
return Ok(());
}
"create-account-once" => {
let line = read_line("").map_err(|x| x.to_string())?;
let request: serde_json::Value = serde_json::from_str(&line).map_err(|x| x.to_string())?;
let name = request.get("username").and_then(|v| v.as_str()).unwrap_or("").trim().to_string();
let password = request.get("password").and_then(|v| v.as_str()).unwrap_or("").to_string();
if !valid_login(&name) || !valid_login(&password) {
return Err("Use 1-16 letters or digits for the account name and password.".into());
}
let mut messages = vec![ra(&cfg, root, &format!("account create {name} {password}"))?];
if request.get("gm").and_then(|v| v.as_bool()).unwrap_or(false) {
messages.push(ra(&cfg, root, &format!("account set gmlevel {name} 3 -1"))?);
}
say(&serde_json::json!({ "messages": messages }).to_string());
return Ok(());
}
_ => {}
}
match args.action.as_str() {
"status" | "status-json" => {
let _lock = state::ControlLock::acquire(root, &args.action, Duration::from_secs(30), &|m| say(m)).map_err(e)?;
if args.action == "status-json" {
say(&services::status(root).to_string());
} else {
for name in ["mysql", "auth", "world", "relay"] {
let line = match state::running(root, name) {
Some(r) => format!("{name:12} running (PID {})", r.pid),
None => format!("{name:12} stopped"),
};
say(&line);
}
}
return Ok(());
}
_ => {}
}
let action = Action::parse(&args.action).ok_or_else(usage)?;
let me = world::Supervisor::Launcher(std::env::current_exe().map_err(|x| x.to_string())?);
ops::run(root, &cfg, args.offset, action, Some(&me), &|m| say(m)).map_err(e)?;
if args.action.starts_with("start-") {
say("Use Stop_All_Server.bat to shut down this repack safely.");
}
Ok(())
}
fn main() {
let result = parse().and_then(run);
if let Err(message) = result {
eprintln!("ERROR: {message}");
std::process::exit(1);
}
}
+2 -2
View File
@@ -1,12 +1,12 @@
{
"name": "coa-server-manager",
"version": "0.9.8",
"version": "0.9.10",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"name": "coa-server-manager",
"version": "0.9.8",
"version": "0.9.10",
"dependencies": {
"@tauri-apps/api": "^2.12.0",
"@tauri-apps/plugin-dialog": "^2.8.0",
+1 -1
View File
@@ -1,7 +1,7 @@
{
"name": "coa-server-manager",
"private": true,
"version": "0.9.8",
"version": "0.9.10",
"license": "AGPL-3.0-only",
"type": "module",
"scripts": {
+1 -1
View File
@@ -1,7 +1,7 @@
{
"$schema": "https://schema.tauri.app/config/2",
"productName": "CoA Server Manager",
"version": "0.9.8",
"version": "0.9.10",
"identifier": "com.coa.servermanager",
"build": {
"beforeDevCommand": "npm run dev",
+6 -2
View File
@@ -2,8 +2,8 @@
The Manager feed is imported from the canonical `changelog/history.json`. The
server snapshot in this directory is copied from `Corfirean/coa-server-build`
commit `e91ae8af4e506c9b8461c7eed6731945a34c3ad8`, path
`changelog/history.json`, on 2026-10-31. Only schema, component, repository and
commit `902ed8eed3017e3ee8c31e5dc5e4df6f551362bf`, path
`changelog/history.json`, on 2026-11-03. Only schema, component, repository and
releases are retained. Do not independently edit historical records here.
At runtime the native read-only command fetches the fixed canonical URL, bounds
@@ -36,3 +36,7 @@ Manager 0.9.8 preparation refreshes the bundled server history through 0.261030.
The two reviewed upcoming records are in `tools/reviewed-manager-notes.json` and
`tools/reviewed-server-notes.json`; every new note has all five translations.
These files describe preparation and do not add unpublished releases to canonical history.
Manager 0.9.10 refreshes the bundled server history through 0.261104.94 from
canonical build commit `a9c6b17c8c1a295680fda4ad4bcdde266357264d` on 2026-11-08.
The reviewed upcoming Manager and server records carry translations in all five languages.
+85 -15
View File
@@ -36,7 +36,9 @@
"Dungeon Clear can be enabled when SQUID bots are active": "Dungeon Clear можно включить при активных SQUID bots",
"Update validation keeps MySQL running between compatible checks": "При проверке обновления MySQL продолжает работать между совместимыми проверками",
"Choose normal logs, errors only or no server logs in maintenance settings": "Выбирайте обычные логи, только ошибки или отключение логов в настройках обслуживания",
"Diagnostic exports include launcher stages and lock owner records": "В архив диагностики входят этапы лаунчера и записи о владельцах блокировок"
"Diagnostic exports include launcher stages and lock owner records": "В архив диагностики входят этапы лаунчера и записи о владельцах блокировок",
"Update and recovery checks use the temporary login port even with a Windows override": "Проверка обновления и восстановления использует временный порт входа даже при переопределении в Windows",
"Custom Races patch installation recovers from interrupted downloads": "Установка патчей дополнительных рас восстанавливается после прерывания загрузки"
},
"de": {
"Choose Parallel or Global level scaling in module settings": "Parallele oder globale Levelskalierung in den Moduleinstellungen wählen",
@@ -74,7 +76,9 @@
"Dungeon Clear can be enabled when SQUID bots are active": "Dungeon Clear lässt sich bei aktiven SQUID-Bots einschalten",
"Update validation keeps MySQL running between compatible checks": "Bei der Update-Validierung bleibt MySQL zwischen kompatiblen Prüfungen aktiv",
"Choose normal logs, errors only or no server logs in maintenance settings": "In den Wartungseinstellungen normale Protokolle, nur Fehler oder keine Serverprotokolle wählen",
"Diagnostic exports include launcher stages and lock owner records": "Diagnoseexporte enthalten Launcher-Schritte und aufgezeichnete Sperrbesitzer"
"Diagnostic exports include launcher stages and lock owner records": "Diagnoseexporte enthalten Launcher-Schritte und aufgezeichnete Sperrbesitzer",
"Update and recovery checks use the temporary login port even with a Windows override": "Update- und Wiederherstellungsprüfungen verwenden den temporären Anmeldeport auch bei einer Windows-Vorgabe",
"Custom Races patch installation recovers from interrupted downloads": "Die Installation zusätzlicher Völker setzt unterbrochene Downloads fort"
},
"fr": {
"Choose Parallel or Global level scaling in module settings": "Choisissez une progression parallèle ou globale des niveaux dans les paramètres du module",
@@ -112,7 +116,9 @@
"Dungeon Clear can be enabled when SQUID bots are active": "Dungeon Clear peut être activé lorsque les bots SQUID sont actifs",
"Update validation keeps MySQL running between compatible checks": "La validation des mises à jour garde MySQL actif entre les vérifications compatibles",
"Choose normal logs, errors only or no server logs in maintenance settings": "Choisissez les journaux normaux, les erreurs uniquement ou aucun journal dans les paramètres de maintenance",
"Diagnostic exports include launcher stages and lock owner records": "Les exports de diagnostic incluent les étapes de lancement et les propriétaires des verrous"
"Diagnostic exports include launcher stages and lock owner records": "Les exports de diagnostic incluent les étapes de lancement et les propriétaires des verrous",
"Update and recovery checks use the temporary login port even with a Windows override": "Les contrôles de mise à jour et de restauration utilisent le port de connexion temporaire même si Windows en impose un autre",
"Custom Races patch installation recovers from interrupted downloads": "L’installation des races supplémentaires reprend les téléchargements interrompus"
},
"es": {
"Choose Parallel or Global level scaling in module settings": "Elige escalado de nivel paralelo o global en los ajustes del módulo",
@@ -150,7 +156,9 @@
"Dungeon Clear can be enabled when SQUID bots are active": "Dungeon Clear se puede activar cuando los bots SQUID están activos",
"Update validation keeps MySQL running between compatible checks": "La validación de actualizaciones mantiene MySQL activo entre comprobaciones compatibles",
"Choose normal logs, errors only or no server logs in maintenance settings": "Elige registros normales, solo errores o ningún registro en los ajustes de mantenimiento",
"Diagnostic exports include launcher stages and lock owner records": "Los archivos de diagnóstico incluyen las etapas del lanzador y los propietarios de bloqueos"
"Diagnostic exports include launcher stages and lock owner records": "Los archivos de diagnóstico incluyen las etapas del lanzador y los propietarios de bloqueos",
"Update and recovery checks use the temporary login port even with a Windows override": "Las comprobaciones de actualización y recuperación usan el puerto temporal de acceso aunque Windows indique otro",
"Custom Races patch installation recovers from interrupted downloads": "La instalación de razas adicionales se recupera de descargas interrumpidas"
},
"zh": {
"Choose Parallel or Global level scaling in module settings": "在模块设置中选择并行或全局等级缩放",
@@ -188,7 +196,9 @@
"Dungeon Clear can be enabled when SQUID bots are active": "启用 SQUID 机器人后即可开启 Dungeon Clear",
"Update validation keeps MySQL running between compatible checks": "更新验证会在兼容的检查步骤之间保持 MySQL 运行",
"Choose normal logs, errors only or no server logs in maintenance settings": "在维护设置中选择普通日志、仅错误或关闭服务器日志",
"Diagnostic exports include launcher stages and lock owner records": "诊断导出包含启动器阶段和锁所属进程记录"
"Diagnostic exports include launcher stages and lock owner records": "诊断导出包含启动器阶段和锁所属进程记录",
"Update and recovery checks use the temporary login port even with a Windows override": "即使 Windows 指定了其他端口,更新和恢复检查也会使用临时登录端口",
"Custom Races patch installation recovers from interrupted downloads": "自定义种族补丁安装可从中断的下载中恢复"
}
},
"server": {
@@ -222,7 +232,7 @@
"Imported 40 upstream commits with class, item and Pale Reach quest fixes, optional account-wide friends, and corrected Vanity purchases": "Включены 40 изменений апстрима: исправления классов, предметов и заданий Pale Reach, необязательные друзья на весь аккаунт и исправленные покупки Vanity",
"Server includes newer upstream class, quest and dungeon updates": "Сервер включает новые обновления классов, заданий и подземелий из апстрима",
"Dungeon scaling preserves the level differences between creatures": "Масштабирование подземелий сохраняет разницу уровней между существами",
"Normal Classic dungeons retain their authored damage at full party size": "Обычные подземелья классики сохраняют исходный урон при полной группе",
"Normal Classic dungeons retain their authored damage at full party size": "В обычных классических подземельях урон при полной группе соответствует исходной настройке",
"Interactive World Map displays allied bots, guild tasks and events": "Интерактивная карта мира показывает союзных ботов, задания гильдии и события",
"Database startup allows time for slower hard drives": "Запуск базы данных допускает более долгое ожидание на медленных дисках",
"Option to make low-health runners walk": "Добавлена возможность замедлить убегающих существ с низким здоровьем до шага",
@@ -237,7 +247,19 @@
"Dungeon Clear is available as an optional extension for SQUID bots": "Dungeon Clear доступен как дополнительный модуль для SQUID bots",
"Server validation skips creating and logging in SQUID bots": "При проверке сервера аккаунты SQUID bots не создаются и боты не входят в мир",
"Startup and shutdown keep bounded diagnostics of launcher stages": "При запуске и остановке сохраняется ограниченная по объёму диагностика этапов лаунчера",
"Database shutdown succeeds when MySQL closes its connection before replying": "Остановка базы завершается успешно, если MySQL закрыл соединение до отправки ответа"
"Database shutdown succeeds when MySQL closes its connection before replying": "Остановка базы завершается успешно, если MySQL закрыл соединение до отправки ответа",
"Server startup waits for ports that Windows is still releasing": "При запуске сервер ждёт, пока Windows освободит порт",
"Companions avoid repeating unreachable routes in the open world": "В открытом мире спутники перестают повторять непроходимые маршруты",
"Login server startup works when Windows does not list its listening port": "Сервер входа запускается, даже если Windows не показывает его прослушиваемый порт",
"Updated SQUID's Playerbots to 2.9.4 and refreshed Dungeon Clear": "Обновлены SQUID’s Playerbots до 2.9.4 и Dungeon Clear",
"Electrocutioner is used up by Electrocute and no longer makes it look ready too early": "Electrocute расходует Electrocutioner и больше не выглядит готовым раньше времени",
"The Dungeon Finder boss objective survives a relog": "Цель убийства босса в поиске подземелий сохраняется после повторного входа",
"Vanilla dungeon bosses no longer sleep or mind control tanks and healers": "Боссы классических подземелий больше не усыпляют и не подчиняют танков и лекарей",
"Classic dungeons scale only for Dungeon Finder groups": "Классические подземелья масштабируются только для групп поиска подземелий",
"Darkmaster Gandling raises Risen Students only at 52% health": "Тёмный магистр Гандлинг поднимает восставших студентов только при 52% здоровья",
"Sunken Temple's dragons appear only after the Avatar of Hakkar and Jammal'an": "Драконы Затонувшего храма появляются только после Аватары Хаккара и Джаммал’ана",
"Scaled loot previews survive a map change": "Предпросмотр масштабированной добычи сохраняется при смене карты",
"Updated SQUID Playerbots to 2.9.4": "SQUID Playerbots обновлён до 2.9.4"
},
"de": {
"Restrict new characters by custom race without changing existing characters": "Neue Charaktere nach zusätzlichem Volk beschränken, ohne bestehende Charaktere zu ändern",
@@ -269,7 +291,7 @@
"Imported 40 upstream commits with class, item and Pale Reach quest fixes, optional account-wide friends, and corrected Vanity purchases": "40 Upstream-Änderungen mit Klassen-, Gegenstands- und Pale-Reach-Questkorrekturen, optionalen accountweiten Freunden und korrigierten Vanity-Käufen übernommen",
"Server includes newer upstream class, quest and dungeon updates": "Der Server enthält neuere Upstream-Updates für Klassen, Quests und Dungeons",
"Dungeon scaling preserves the level differences between creatures": "Die Dungeon-Skalierung erhält die Stufenunterschiede zwischen Kreaturen",
"Normal Classic dungeons retain their authored damage at full party size": "Normale Classic-Dungeons behalten bei voller Gruppe ihren ursprünglichen Schaden",
"Normal Classic dungeons retain their authored damage at full party size": "Normale klassische Dungeons behalten bei voller Gruppe ihren vorgesehenen Schaden",
"Interactive World Map displays allied bots, guild tasks and events": "Die interaktive Weltkarte zeigt verbündete Bots, Gildenaufgaben und Ereignisse",
"Database startup allows time for slower hard drives": "Der Datenbankstart lässt langsameren Festplatten mehr Zeit",
"Option to make low-health runners walk": "Fliehende Kreaturen mit wenig Gesundheit können im Schritttempo laufen",
@@ -284,7 +306,19 @@
"Dungeon Clear is available as an optional extension for SQUID bots": "Dungeon Clear ist als optionale Erweiterung für SQUID-Bots verfügbar",
"Server validation skips creating and logging in SQUID bots": "Die Servervalidierung überspringt das Erstellen und Anmelden von SQUID-Bots",
"Startup and shutdown keep bounded diagnostics of launcher stages": "Start und Herunterfahren speichern begrenzte Diagnosedaten der Launcher-Schritte",
"Database shutdown succeeds when MySQL closes its connection before replying": "Das Herunterfahren der Datenbank gelingt auch, wenn MySQL die Verbindung vor der Antwort schließt"
"Database shutdown succeeds when MySQL closes its connection before replying": "Das Herunterfahren der Datenbank gelingt auch, wenn MySQL die Verbindung vor der Antwort schließt",
"Server startup waits for ports that Windows is still releasing": "Beim Start wartet der Server, bis Windows den Port freigibt",
"Companions avoid repeating unreachable routes in the open world": "Gefährten meiden in der offenen Welt wiederholte Versuche auf unpassierbaren Routen",
"Login server startup works when Windows does not list its listening port": "Der Anmeldeserver startet auch ohne Eintrag seines lauschenden Ports in Windows",
"Updated SQUID's Playerbots to 2.9.4 and refreshed Dungeon Clear": "SQUID’s Playerbots auf 2.9.4 aktualisiert und Dungeon Clear erneuert",
"Electrocutioner is used up by Electrocute and no longer makes it look ready too early": "Electrocute verbraucht Electrocutioner und erscheint nicht mehr vorzeitig einsatzbereit",
"The Dungeon Finder boss objective survives a relog": "Das Bossziel der Dungeonsuche bleibt nach erneutem Einloggen erhalten",
"Vanilla dungeon bosses no longer sleep or mind control tanks and healers": "Bosse klassischer Dungeons versetzen Tanks und Heiler nicht mehr in Schlaf oder Gedankenkontrolle",
"Classic dungeons scale only for Dungeon Finder groups": "Klassische Dungeons skalieren nur für Gruppen der Dungeonsuche",
"Darkmaster Gandling raises Risen Students only at 52% health": "Dunkelmeister Gandling erweckt auferstandene Studenten erst bei 52 % Gesundheit",
"Sunken Temple's dragons appear only after the Avatar of Hakkar and Jammal'an": "Die Drachen im Versunkenen Tempel erscheinen erst nach dem Avatar von Hakkar und Jammal’an",
"Scaled loot previews survive a map change": "Die Vorschau skalierter Beute bleibt beim Kartenwechsel erhalten",
"Updated SQUID Playerbots to 2.9.4": "SQUID Playerbots auf 2.9.4 aktualisiert"
},
"fr": {
"Restrict new characters by custom race without changing existing characters": "Restreignez les races supplémentaires des nouveaux personnages sans modifier les personnages existants",
@@ -316,7 +350,7 @@
"Imported 40 upstream commits with class, item and Pale Reach quest fixes, optional account-wide friends, and corrected Vanity purchases": "Intégration de 40 changements amont : classes, objets et quêtes de Pale Reach corrigés, amis de compte facultatifs et achats Vanity corrigés",
"Server includes newer upstream class, quest and dungeon updates": "Le serveur intègre de nouvelles mises à jour des classes, quêtes et donjons provenant du projet amont",
"Dungeon scaling preserves the level differences between creatures": "La mise à l’échelle des donjons conserve les écarts de niveau entre les créatures",
"Normal Classic dungeons retain their authored damage at full party size": "Les donjons Classic normaux conservent leurs dégâts d’origine avec un groupe complet",
"Normal Classic dungeons retain their authored damage at full party size": "Les donjons classiques normaux conservent leurs dégâts prévus pour un groupe complet",
"Interactive World Map displays allied bots, guild tasks and events": "La carte du monde interactive affiche les bots alliés, les tâches de guilde et les événements",
"Database startup allows time for slower hard drives": "Le démarrage de la base de données laisse plus de temps aux disques lents",
"Option to make low-health runners walk": "Une option permet aux créatures affaiblies de fuir en marchant",
@@ -331,7 +365,19 @@
"Dungeon Clear is available as an optional extension for SQUID bots": "Dungeon Clear est disponible comme extension facultative pour les bots SQUID",
"Server validation skips creating and logging in SQUID bots": "La validation du serveur ignore la création et la connexion des bots SQUID",
"Startup and shutdown keep bounded diagnostics of launcher stages": "Le démarrage et l’arrêt conservent un diagnostic limité des étapes de lancement",
"Database shutdown succeeds when MySQL closes its connection before replying": "L’arrêt de la base réussit même si MySQL ferme la connexion avant de répondre"
"Database shutdown succeeds when MySQL closes its connection before replying": "L’arrêt de la base réussit même si MySQL ferme la connexion avant de répondre",
"Server startup waits for ports that Windows is still releasing": "Au démarrage, le serveur attend que Windows libère le port",
"Companions avoid repeating unreachable routes in the open world": "Les compagnons évitent de reprendre les chemins impraticables en monde ouvert",
"Login server startup works when Windows does not list its listening port": "Le serveur de connexion démarre même si Windows ne répertorie pas son port d’écoute",
"Updated SQUID's Playerbots to 2.9.4 and refreshed Dungeon Clear": "SQUID’s Playerbots passe en version 2.9.4 et Dungeon Clear est actualisé",
"Electrocutioner is used up by Electrocute and no longer makes it look ready too early": "Electrocute consomme Electrocutioner et ne paraît plus disponible trop tôt",
"The Dungeon Finder boss objective survives a relog": "L’objectif de boss de la recherche de donjons est conservé après reconnexion",
"Vanilla dungeon bosses no longer sleep or mind control tanks and healers": "Les boss des donjons classiques n’endorment plus les tanks et soigneurs et ne contrôlent plus leur esprit",
"Classic dungeons scale only for Dungeon Finder groups": "Les donjons classiques ne s’adaptent que pour les groupes de la recherche de donjons",
"Darkmaster Gandling raises Risen Students only at 52% health": "Le sombre maître Gandling ne relève les étudiants qu’à 52 % de ses points de vie",
"Sunken Temple's dragons appear only after the Avatar of Hakkar and Jammal'an": "Les dragons du Temple englouti n’apparaissent qu’après l’Avatar d’Hakkar et Jammal’an",
"Scaled loot previews survive a map change": "L’aperçu du butin adapté est conservé lors d’un changement de carte",
"Updated SQUID Playerbots to 2.9.4": "SQUID Playerbots passe en version 2.9.4"
},
"es": {
"Restrict new characters by custom race without changing existing characters": "Restringe las razas adicionales de personajes nuevos sin modificar los existentes",
@@ -363,7 +409,7 @@
"Imported 40 upstream commits with class, item and Pale Reach quest fixes, optional account-wide friends, and corrected Vanity purchases": "Integrados 40 cambios del proyecto original: correcciones de clases, objetos y misiones de Pale Reach, amigos opcionales de toda la cuenta y compras Vanity corregidas",
"Server includes newer upstream class, quest and dungeon updates": "El servidor incorpora nuevas actualizaciones de clases, misiones y mazmorras del proyecto original",
"Dungeon scaling preserves the level differences between creatures": "El escalado de las mazmorras conserva las diferencias de nivel entre criaturas",
"Normal Classic dungeons retain their authored damage at full party size": "Las mazmorras Classic normales conservan su daño original con un grupo completo",
"Normal Classic dungeons retain their authored damage at full party size": "Las mazmorras clásicas normales conservan el daño previsto para un grupo completo",
"Interactive World Map displays allied bots, guild tasks and events": "El mapa del mundo interactivo muestra bots aliados, tareas de hermandad y eventos",
"Database startup allows time for slower hard drives": "El inicio de la base de datos permite más tiempo en discos lentos",
"Option to make low-health runners walk": "Una opción permite que las criaturas con poca salud huyan caminando",
@@ -378,7 +424,19 @@
"Dungeon Clear is available as an optional extension for SQUID bots": "Dungeon Clear está disponible como extensión opcional para los bots SQUID",
"Server validation skips creating and logging in SQUID bots": "La validación del servidor omite la creación y conexión de bots SQUID",
"Startup and shutdown keep bounded diagnostics of launcher stages": "El inicio y la parada guardan diagnósticos limitados de las etapas del lanzador",
"Database shutdown succeeds when MySQL closes its connection before replying": "La parada de la base de datos se completa aunque MySQL cierre la conexión antes de responder"
"Database shutdown succeeds when MySQL closes its connection before replying": "La parada de la base de datos se completa aunque MySQL cierre la conexión antes de responder",
"Server startup waits for ports that Windows is still releasing": "Al iniciarse, el servidor espera a que Windows libere el puerto",
"Companions avoid repeating unreachable routes in the open world": "Los compañeros evitan repetir rutas intransitables en el mundo abierto",
"Login server startup works when Windows does not list its listening port": "El servidor de acceso arranca aunque Windows no muestre su puerto de escucha",
"Updated SQUID's Playerbots to 2.9.4 and refreshed Dungeon Clear": "SQUID’s Playerbots se actualiza a 2.9.4 y se renueva Dungeon Clear",
"Electrocutioner is used up by Electrocute and no longer makes it look ready too early": "Electrocute consume Electrocutioner y ya no parece disponible antes de tiempo",
"The Dungeon Finder boss objective survives a relog": "El objetivo de jefe del buscador de mazmorras se conserva al volver a entrar",
"Vanilla dungeon bosses no longer sleep or mind control tanks and healers": "Los jefes de mazmorras clásicas ya no duermen ni controlan mentalmente a tanques y sanadores",
"Classic dungeons scale only for Dungeon Finder groups": "Las mazmorras clásicas solo se ajustan para grupos del buscador de mazmorras",
"Darkmaster Gandling raises Risen Students only at 52% health": "El Maestro Oscuro Gandling solo alza a los estudiantes resucitados al 52 % de salud",
"Sunken Temple's dragons appear only after the Avatar of Hakkar and Jammal'an": "Los dragones del Templo Sumergido solo aparecen después del Avatar de Hakkar y Jammal’an",
"Scaled loot previews survive a map change": "La vista previa del botín ajustado se conserva al cambiar de mapa",
"Updated SQUID Playerbots to 2.9.4": "SQUID Playerbots se actualiza a 2.9.4"
},
"zh": {
"Restrict new characters by custom race without changing existing characters": "限制新角色可选的自定义种族,不影响现有角色",
@@ -410,7 +468,7 @@
"Imported 40 upstream commits with class, item and Pale Reach quest fixes, optional account-wide friends, and corrected Vanity purchases": "合入 40 项上游更改:职业、物品及 Pale Reach 任务修复,可选的账号共享好友,以及 Vanity 购买修复",
"Server includes newer upstream class, quest and dungeon updates": "服务器整合了上游新的职业、任务和地下城更新",
"Dungeon scaling preserves the level differences between creatures": "地下城缩放保留生物之间的等级差异",
"Normal Classic dungeons retain their authored damage at full party size": "普通经典地下城在满员队伍下保留原始伤害",
"Normal Classic dungeons retain their authored damage at full party size": "满队时普通经典地下城保留原定的伤害数值",
"Interactive World Map displays allied bots, guild tasks and events": "交互式世界地图显示友方机器人、公会任务和事件",
"Database startup allows time for slower hard drives": "数据库启动为较慢的硬盘预留更多等待时间",
"Option to make low-health runners walk": "新增选项,可让低生命值的逃跑生物改为步行",
@@ -425,7 +483,19 @@
"Dungeon Clear is available as an optional extension for SQUID bots": "Dungeon Clear 现可作为 SQUID 机器人的可选扩展",
"Server validation skips creating and logging in SQUID bots": "服务器验证会跳过 SQUID 机器人的创建和登录",
"Startup and shutdown keep bounded diagnostics of launcher stages": "启动和关闭时会保留大小受限的启动器阶段诊断日志",
"Database shutdown succeeds when MySQL closes its connection before replying": "即使 MySQL 在回复前关闭连接,数据库关闭操作也能正确完成"
"Database shutdown succeeds when MySQL closes its connection before replying": "即使 MySQL 在回复前关闭连接,数据库关闭操作也能正确完成",
"Server startup waits for ports that Windows is still releasing": "服务器启动时会等待 Windows 释放端口",
"Companions avoid repeating unreachable routes in the open world": "伙伴在开放世界中会避免反复尝试无法通行的路线",
"Login server startup works when Windows does not list its listening port": "即使 Windows 未列出监听端口,登录服务器也能启动",
"Updated SQUID's Playerbots to 2.9.4 and refreshed Dungeon Clear": "已将 SQUID’s Playerbots 更新至 2.9.4,并更新 Dungeon Clear",
"Electrocutioner is used up by Electrocute and no longer makes it look ready too early": "Electrocute 会消耗 Electrocutioner,且不再过早显示为可用",
"The Dungeon Finder boss objective survives a relog": "地下城查找器的首领目标在重新登录后仍会保留",
"Vanilla dungeon bosses no longer sleep or mind control tanks and healers": "经典地下城首领不再使坦克和治疗者沉睡或受到精神控制",
"Classic dungeons scale only for Dungeon Finder groups": "经典地下城仅对通过地下城查找器组成的队伍进行缩放",
"Darkmaster Gandling raises Risen Students only at 52% health": "黑暗院长加丁仅在生命值降至 52% 时唤起复活的学生",
"Sunken Temple's dragons appear only after the Avatar of Hakkar and Jammal'an": "沉没的神庙中的巨龙仅在哈卡的化身和迦玛兰之后出现",
"Scaled loot previews survive a map change": "缩放后的战利品预览在切换地图后仍会保留",
"Updated SQUID Playerbots to 2.9.4": "已将 SQUID Playerbots 更新至 2.9.4"
}
}
}
+279
View File
@@ -1429,6 +1429,285 @@
"portable-characters"
],
"compare": "https://github.com/Corfirean/coa-server-build/compare/server-0.261029.85...server-0.261030.90"
},
{
"tag": "server-0.261101.92",
"version": "0.261101.92",
"date": "2026-11-01",
"url": "https://github.com/Corfirean/coa-server-build/releases/tag/server-0.261101.92",
"notes": [
"Concurrent server actions wait briefly and identify the action still running",
"Dungeon Clear is available as an optional extension for SQUID bots",
"Server launchers accept configuration paths in folders with spaces",
"Startup and shutdown keep bounded diagnostics of launcher stages",
"Database shutdown succeeds when MySQL closes its connection before replying",
"Database restarts recover from ownerless Windows port entries",
"Server validation skips creating and logging in SQUID bots",
"Updated the reviewed CoA upstream snapshot"
],
"snapshot": "f2be62fe451dd635a27393b6289b7801c7103826597232a78633f49f564f858c",
"components": {
"upstream": {
"repository": "jealous-sound/azerothcore-wotlk-coa",
"ref": "2ee0f77eebed8b984fb151cf7fe1163f640efd3a",
"sha": "2ee0f77eebed8b984fb151cf7fe1163f640efd3a"
},
"core": {
"repository": "Corfirean/azerothcore-wotlk-coa",
"ref": "66380c78147cbd01e22361df1df54dc87b0f1701",
"sha": "66380c78147cbd01e22361df1df54dc87b0f1701"
},
"bots": {
"repository": "Corfirean/mod-coa-playerbots",
"ref": "4f6cf99e6bf509ae2b178e993d1170cc7fe0cb0c",
"sha": "4f6cf99e6bf509ae2b178e993d1170cc7fe0cb0c"
},
"scaling": {
"repository": "Corfirean/mod-coa-content-scaling",
"ref": "0898a3e976677cde470a60ba4e6f9bb9d0fe5e2c",
"sha": "0898a3e976677cde470a60ba4e6f9bb9d0fe5e2c"
},
"manager": {
"repository": "Corfirean/coa-server-manager",
"ref": "23cbb108adb4f9c61c0ffff24a60c134e5a0dede",
"sha": "23cbb108adb4f9c61c0ffff24a60c134e5a0dede"
},
"races": {
"repository": "ilusixn/azerothcore-wotlk-coa",
"ref": "coa-custom-1.9.2",
"sha": "31bd63d309b8b0fb4f1a4d9b793a343b8ac36f1e",
"assets": [
{
"name": "CoA-Custom-1.9.2-Client-1.zip",
"size": 1513021586,
"digest": "sha256:a9dd51ed2d90fb048d549602f40f5429d56e2df0df5606a38781b358fa369568",
"url": "https://github.com/ilusixn/azerothcore-wotlk-coa/releases/download/coa-custom-1.9.2/CoA-Custom-1.9.2-Client-1.zip"
},
{
"name": "CoA-Custom-1.9.2-Client-2.zip",
"size": 1198283005,
"digest": "sha256:ab084a55509ccbcc2977a06dd0c01fa879973a1892baaacaeb3ff52f3dfc750e",
"url": "https://github.com/ilusixn/azerothcore-wotlk-coa/releases/download/coa-custom-1.9.2/CoA-Custom-1.9.2-Client-2.zip"
},
{
"name": "CoA-Custom-1.9.2-Client-3.zip",
"size": 1678829573,
"digest": "sha256:907e267f0ee7038807e626c3c1eca5e12db6c88b747137a23c5fb52eaa1a358e",
"url": "https://github.com/ilusixn/azerothcore-wotlk-coa/releases/download/coa-custom-1.9.2/CoA-Custom-1.9.2-Client-3.zip"
},
{
"name": "CoA-Custom-1.9.2-Client-4.zip",
"size": 502385128,
"digest": "sha256:e0bd87172af989fa50a8e2b08ba4321c72b6265047482f051a1db3b80d55bcaa",
"url": "https://github.com/ilusixn/azerothcore-wotlk-coa/releases/download/coa-custom-1.9.2/CoA-Custom-1.9.2-Client-4.zip"
},
{
"name": "CoA-Custom-1.9.2-Client-5.zip",
"size": 168079711,
"digest": "sha256:73364ad1b58c6342641a848a3b20a835472834f600416606be1470386774ca78",
"url": "https://github.com/ilusixn/azerothcore-wotlk-coa/releases/download/coa-custom-1.9.2/CoA-Custom-1.9.2-Client-5.zip"
},
{
"name": "CoA-Custom-1.9.2-Server.zip",
"size": 53004560,
"digest": "sha256:b893813573a4d3f6a0003c1f174582d3def997f37b402cbca44d53055d2fc1d2",
"url": "https://github.com/ilusixn/azerothcore-wotlk-coa/releases/download/coa-custom-1.9.2/CoA-Custom-1.9.2-Server.zip"
},
{
"name": "INSTALL-GUIDE.txt",
"size": 3006,
"digest": "sha256:f17e97fafa3225901d1caf8c3b8141293f98fbfb8c9243c0c4717278c60146aa",
"url": "https://github.com/ilusixn/azerothcore-wotlk-coa/releases/download/coa-custom-1.9.2/INSTALL-GUIDE.txt"
},
{
"name": "PATCH-NOTES-1.9.2.txt",
"size": 2822,
"digest": "sha256:f2fd4693ba181959a572d3fb10a0050e9ff6c4f735b3ab0019c7d16712db28cb",
"url": "https://github.com/ilusixn/azerothcore-wotlk-coa/releases/download/coa-custom-1.9.2/PATCH-NOTES-1.9.2.txt"
}
]
},
"squid": {
"repository": "Zyth45/mod-playerbots",
"ref": "v2.8.2",
"sha": "fa4cfd31997367b3e574a2b89b858c4669ff53fb",
"patch": "patches/squid-coa-validation.patch",
"patchSha256": "9b101db17369fb5a6af3f7e99323f7770eb8650ba3b5e9b3970bf09a0ef5d32f"
},
"build": {
"repository": "Corfirean/coa-server-build",
"ref": "9705eb844085b72379bef517635968473cb43419",
"sha": "9705eb844085b72379bef517635968473cb43419"
},
"dungeon-clear": {
"repository": "Zyth45/mod-dungeon-clear",
"sha": "9a9d09cf512e0a883af9cda6973445b81c123b13",
"patch": "patches/dungeon-clear-coa-validation.patch",
"patchSha256": "956f278865e22ee75c984ca22ff8238150b5886c9934ddfe64dd9c832c912dcc",
"ref": "9a9d09cf512e0a883af9cda6973445b81c123b13"
},
"navigation": {
"repository": "Corfirean/azerothcore-wotlk-coa",
"ref": "8b44099f480af0b69c6dfc697e4d388e865e9ffc",
"sha": "8b44099f480af0b69c6dfc697e4d388e865e9ffc",
"sourceRelease": "navigation-20261012",
"manifestSha256": "7f28600735f115792e79a5e8d1c8d78a83a8f5ed14a090c6d87268e49c2bb683",
"archiveSha256": "aa1347a095f85af44b4f592270a0e9314954801fda4578f0147f847e32c24a60",
"assets": [
{
"name": "navigation.zip.001",
"size": 1500000000,
"sha256": "e3a93903fc8155ee0d92db399ec426769c360bef87c44c07beb7e21cfd892c18",
"url": "https://github.com/Corfirean/coa-server-build/releases/download/navigation-20261012/navigation.zip.001"
},
{
"name": "navigation.zip.002",
"size": 1377006470,
"sha256": "c1af26ba7f83676278613076c357c4da0a11cfa6ae1ff00003479057c4864471",
"url": "https://github.com/Corfirean/coa-server-build/releases/download/navigation-20261012/navigation.zip.002"
}
]
}
},
"experimentalFeatures": [],
"compare": "https://github.com/Corfirean/coa-server-build/compare/server-0.261030.90...server-0.261101.92"
},
{
"tag": "server-0.261104.94",
"version": "0.261104.94",
"date": "2026-11-04",
"url": "https://github.com/Corfirean/coa-server-build/releases/tag/server-0.261104.94",
"notes": [
"Companions avoid repeating unreachable routes in the open world",
"Server startup waits for ports that Windows is still releasing",
"Updated the reviewed CoA upstream snapshot"
],
"snapshot": "f67a6d8545e4c6ece2f819f9dd2642fe5a81a69c959946a1031859c19b5c4d74",
"components": {
"upstream": {
"repository": "jealous-sound/azerothcore-wotlk-coa",
"ref": "a34c5ad7167b6b2087a678cb4344c6cbe6abb823",
"sha": "a34c5ad7167b6b2087a678cb4344c6cbe6abb823"
},
"core": {
"repository": "Corfirean/azerothcore-wotlk-coa",
"ref": "14cf375f1e006770b330d3fb89201ace54bfca24",
"sha": "14cf375f1e006770b330d3fb89201ace54bfca24"
},
"bots": {
"repository": "Corfirean/mod-coa-playerbots",
"ref": "447558bc27d6bb447aaf10eefcb2e85ac2b15c32",
"sha": "447558bc27d6bb447aaf10eefcb2e85ac2b15c32"
},
"scaling": {
"repository": "Corfirean/mod-coa-content-scaling",
"ref": "3c2febf636bd09087bb278e381b975271a70fdf6",
"sha": "3c2febf636bd09087bb278e381b975271a70fdf6"
},
"manager": {
"repository": "Corfirean/coa-server-manager",
"ref": "173248efbe24da9b4c1b5ca12fa7580fcd1e8ea7",
"sha": "173248efbe24da9b4c1b5ca12fa7580fcd1e8ea7"
},
"races": {
"repository": "ilusixn/azerothcore-wotlk-coa",
"ref": "coa-custom-1.9.2",
"sha": "31bd63d309b8b0fb4f1a4d9b793a343b8ac36f1e",
"assets": [
{
"name": "CoA-Custom-1.9.2-Client-1.zip",
"size": 1513021586,
"digest": "sha256:a9dd51ed2d90fb048d549602f40f5429d56e2df0df5606a38781b358fa369568",
"url": "https://github.com/ilusixn/azerothcore-wotlk-coa/releases/download/coa-custom-1.9.2/CoA-Custom-1.9.2-Client-1.zip"
},
{
"name": "CoA-Custom-1.9.2-Client-2.zip",
"size": 1198283005,
"digest": "sha256:ab084a55509ccbcc2977a06dd0c01fa879973a1892baaacaeb3ff52f3dfc750e",
"url": "https://github.com/ilusixn/azerothcore-wotlk-coa/releases/download/coa-custom-1.9.2/CoA-Custom-1.9.2-Client-2.zip"
},
{
"name": "CoA-Custom-1.9.2-Client-3.zip",
"size": 1678829573,
"digest": "sha256:907e267f0ee7038807e626c3c1eca5e12db6c88b747137a23c5fb52eaa1a358e",
"url": "https://github.com/ilusixn/azerothcore-wotlk-coa/releases/download/coa-custom-1.9.2/CoA-Custom-1.9.2-Client-3.zip"
},
{
"name": "CoA-Custom-1.9.2-Client-4.zip",
"size": 502385128,
"digest": "sha256:e0bd87172af989fa50a8e2b08ba4321c72b6265047482f051a1db3b80d55bcaa",
"url": "https://github.com/ilusixn/azerothcore-wotlk-coa/releases/download/coa-custom-1.9.2/CoA-Custom-1.9.2-Client-4.zip"
},
{
"name": "CoA-Custom-1.9.2-Client-5.zip",
"size": 168079711,
"digest": "sha256:73364ad1b58c6342641a848a3b20a835472834f600416606be1470386774ca78",
"url": "https://github.com/ilusixn/azerothcore-wotlk-coa/releases/download/coa-custom-1.9.2/CoA-Custom-1.9.2-Client-5.zip"
},
{
"name": "CoA-Custom-1.9.2-Server.zip",
"size": 53004560,
"digest": "sha256:b893813573a4d3f6a0003c1f174582d3def997f37b402cbca44d53055d2fc1d2",
"url": "https://github.com/ilusixn/azerothcore-wotlk-coa/releases/download/coa-custom-1.9.2/CoA-Custom-1.9.2-Server.zip"
},
{
"name": "INSTALL-GUIDE.txt",
"size": 3006,
"digest": "sha256:f17e97fafa3225901d1caf8c3b8141293f98fbfb8c9243c0c4717278c60146aa",
"url": "https://github.com/ilusixn/azerothcore-wotlk-coa/releases/download/coa-custom-1.9.2/INSTALL-GUIDE.txt"
},
{
"name": "PATCH-NOTES-1.9.2.txt",
"size": 2822,
"digest": "sha256:f2fd4693ba181959a572d3fb10a0050e9ff6c4f735b3ab0019c7d16712db28cb",
"url": "https://github.com/ilusixn/azerothcore-wotlk-coa/releases/download/coa-custom-1.9.2/PATCH-NOTES-1.9.2.txt"
}
]
},
"squid": {
"repository": "Zyth45/mod-playerbots",
"ref": "v2.8.2",
"sha": "fa4cfd31997367b3e574a2b89b858c4669ff53fb",
"patch": "patches/squid-coa-validation.patch",
"patchSha256": "9b101db17369fb5a6af3f7e99323f7770eb8650ba3b5e9b3970bf09a0ef5d32f"
},
"build": {
"repository": "Corfirean/coa-server-build",
"ref": "d9aaa5263154473b2fe1623172492f88e6e03d73",
"sha": "d9aaa5263154473b2fe1623172492f88e6e03d73"
},
"dungeon-clear": {
"repository": "Zyth45/mod-dungeon-clear",
"sha": "9a9d09cf512e0a883af9cda6973445b81c123b13",
"patch": "patches/dungeon-clear-coa-validation.patch",
"patchSha256": "956f278865e22ee75c984ca22ff8238150b5886c9934ddfe64dd9c832c912dcc",
"ref": "9a9d09cf512e0a883af9cda6973445b81c123b13"
},
"navigation": {
"repository": "Corfirean/azerothcore-wotlk-coa",
"ref": "8b44099f480af0b69c6dfc697e4d388e865e9ffc",
"sha": "8b44099f480af0b69c6dfc697e4d388e865e9ffc",
"sourceRelease": "navigation-20261012",
"manifestSha256": "7f28600735f115792e79a5e8d1c8d78a83a8f5ed14a090c6d87268e49c2bb683",
"archiveSha256": "aa1347a095f85af44b4f592270a0e9314954801fda4578f0147f847e32c24a60",
"assets": [
{
"name": "navigation.zip.001",
"size": 1500000000,
"sha256": "e3a93903fc8155ee0d92db399ec426769c360bef87c44c07beb7e21cfd892c18",
"url": "https://github.com/Corfirean/coa-server-build/releases/download/navigation-20261012/navigation.zip.001"
},
{
"name": "navigation.zip.002",
"size": 1377006470,
"sha256": "c1af26ba7f83676278613076c357c4da0a11cfa6ae1ff00003479057c4864471",
"url": "https://github.com/Corfirean/coa-server-build/releases/download/navigation-20261012/navigation.zip.002"
}
]
}
},
"experimentalFeatures": [],
"compare": "https://github.com/Corfirean/coa-server-build/compare/server-0.261101.92...server-0.261104.94"
}
]
}
+2 -6
View File
@@ -1,10 +1,6 @@
{
"version": "0.9.8",
"version": "0.9.10",
"notes": [
"Update checks temporarily suspend bot population and restore your configuration",
"Dungeon Clear can be enabled when SQUID bots are active",
"Update validation keeps MySQL running between compatible checks",
"Choose normal logs, errors only or no server logs in maintenance settings",
"Diagnostic exports include launcher stages and lock owner records"
"Custom Races patch installation recovers from interrupted downloads"
]
}
+27 -13
View File
@@ -1,16 +1,30 @@
{
"core": "66380c78147cbd01e22361df1df54dc87b0f1701",
"bots": "4f6cf99e6bf509ae2b178e993d1170cc7fe0cb0c",
"squid": "fa4cfd31997367b3e574a2b89b858c4669ff53fb",
"components": {
"core": {
"repository": "Corfirean/azerothcore-wotlk-coa",
"sha": "85ecc2122efd4bc168e750ab35c3e3e8d9c49735"
},
"upstream": {
"repository": "jealous-sound/azerothcore-wotlk-coa",
"sha": "f8955cb9b29042c359a938ff732e4b608dd62ea5"
},
"bots": {
"repository": "Corfirean/mod-coa-playerbots",
"sha": "0588a8e5cdfe54f81fe47bbb40fc9f75d29662e3"
},
"scaling": {
"repository": "Corfirean/mod-coa-content-scaling",
"sha": "3c2febf636bd09087bb278e381b975271a70fdf6"
},
"build": {
"repository": "Corfirean/coa-server-build",
"sha": "ccb121b2a050e9f6eae4e5798dbca1c4ee66264f"
}
},
"notes": [
"Server launchers accept configuration paths in folders with spaces",
"Database restarts recover from ownerless Windows port entries",
"Concurrent server actions wait briefly and identify the action still running",
"Dungeon Clear is available as an optional extension for SQUID bots",
"Server validation skips creating and logging in SQUID bots",
"Startup and shutdown keep bounded diagnostics of launcher stages",
"Updated the reviewed CoA upstream snapshot",
"Database shutdown succeeds when MySQL closes its connection before replying"
],
"dungeon-clear": "9a9d09cf512e0a883af9cda6973445b81c123b13"
"Login server startup works when Windows does not list its listening port",
"Updated SQUID's Playerbots to 2.9.4 and refreshed Dungeon Clear",
"Updated SQUID Playerbots to 2.9.4",
"Updated the reviewed CoA upstream snapshot"
]
}
-223
View File
@@ -1,223 +0,0 @@
import pathlib
import runpy
import sys
import tempfile
import unittest
import time
from unittest.mock import patch
BRIDGE = pathlib.Path(__file__).resolve().parents[1] / 'crates/coa-core/src/launcher_bridge.py'
class LauncherBridgeTests(unittest.TestCase):
def launch(self, action, body):
with tempfile.TemporaryDirectory() as directory:
script = pathlib.Path(directory) / 'Scripts/manage.py'
script.parent.mkdir()
script.write_text(body, encoding='utf8')
original = runpy.run_path
def capture(*args, **kwargs):
self.launcher = original(*args, **kwargs)
return self.launcher
with patch.object(sys, 'argv', ['bridge', str(script), action]), patch.object(runpy, 'run_path', side_effect=capture):
return original(str(BRIDGE))
def shutdown_fixture(self, *, console_error='RuntimeError', stopped=True, foreign=False, same=True, modern=False, terminate_error=False):
return f'''
from pathlib import Path
from contextlib import nullcontext
calls = []
world = {{'pid': 123, 'created': 456, 'exe': str(Path(__file__).resolve().parents[1] / {'"foreign.exe"' if foreign else '"Core/worldserver.exe"'})}}
def wait_ready(*args): pass
def start_mysql(): raise AssertionError('must not start')
def main(): raise AssertionError('must not prepare')
def settings(): return {{}}
def control_lock(): return nullcontext()
def process(name): return world if name == 'world' else None
def same_process(record): return {same!r}
def ra(command, config):
calls.append('console')
{'raise '+console_error+'("Start this repack worldserver first")' if console_error else 'return "Graceful shutdown"'}
def terminate(record):
assert record is world
calls.append('terminate')
{'raise RuntimeError("identity changed")' if terminate_error else 'pass'}
def wait_stopped(record, seconds):
assert record is world
calls.append('wait')
return {stopped!r}
def stop_all(config):
record = process('world')
if record:
if {modern!r}:
try: ra('server shutdown 1s 0', config)
except (OSError, RuntimeError): terminate(record)
else:
ra('server shutdown 1s 0', config)
if not wait_stopped(record, 60): raise RuntimeError('world still alive')
calls.append('mysql-shutdown')
'''
def test_unavailable_console_in_restored_legacy_launcher_stops_owned_world_before_mysql(self):
for error in ['RuntimeError', 'OSError']:
with self.subTest(error=error):
result = self.launch('stop-all', self.shutdown_fixture(console_error=error))
self.assertEqual(result['launcher']['calls'], ['console', 'terminate', 'wait', 'wait', 'mysql-shutdown'])
def test_force_stop_terminates_only_the_owned_world_before_mysql(self):
body = self.shutdown_fixture(console_error=None)
body = body.replace("return world if name == 'world' else None", "return world if name == 'world' and 'terminate' not in calls else None")
result = self.launch('force-stop-all', body)
self.assertEqual(result['launcher']['calls'], ['terminate', 'wait', 'mysql-shutdown'])
def test_force_stop_rejects_foreign_or_reused_pids_and_a_world_that_stays_alive(self):
for options, message in [({'foreign': True}, 'ownership could not be verified'),
({'same': False}, 'ownership could not be verified'),
({'stopped': False}, 'database was left running')]:
with self.subTest(options=options):
with self.assertRaisesRegex(Exception, message):
self.launch('force-stop-all', self.shutdown_fixture(**options))
self.assertNotIn('mysql-shutdown', self.launcher['calls'])
def test_healthy_console_keeps_graceful_shutdown(self):
result = self.launch('stop-all', self.shutdown_fixture(console_error=None))
self.assertEqual(result['launcher']['calls'], ['console', 'wait', 'mysql-shutdown'])
def test_foreign_or_reused_process_is_never_terminated_even_by_a_modern_launcher_catch(self):
for modern in [False, True]:
for identity in [{'foreign': True}, {'same': False}]:
with self.subTest(modern=modern, **identity):
with self.assertRaisesRegex(Exception, 'ownership could not be verified'):
self.launch('stop-all', self.shutdown_fixture(modern=modern, **identity))
self.assertEqual(self.launcher['calls'], ['console'])
def test_world_that_stays_alive_blocks_database_shutdown(self):
for modern in [False, True]:
with self.subTest(modern=modern):
with self.assertRaisesRegex(Exception, 'database was left running'):
self.launch('stop-all', self.shutdown_fixture(stopped=False, modern=modern))
self.assertEqual(self.launcher['calls'], ['console', 'terminate', 'wait'])
def test_termination_identity_failure_leaves_mysql_untouched(self):
for modern in [False, True]:
with self.subTest(modern=modern):
with self.assertRaisesRegex(Exception, 'could not be stopped safely'):
self.launch('stop-all', self.shutdown_fixture(terminate_error=True, modern=modern))
self.assertEqual(self.launcher['calls'], ['console', 'terminate'])
def test_slow_mysql_gets_time_to_finish_but_other_waits_are_unchanged(self):
result = self.launch('start-mysql', '''
calls = []
def wait_ready(name, port, seconds=180):
calls.append((name, seconds))
if name == 'mysql' and seconds < 162:
raise RuntimeError('mysql is still starting')
def start_mysql():
wait_ready('mysql', 12345, 60)
def main():
start_mysql()
wait_ready('world', 23456, 180)
wait_ready('mysql', 12345, 900)
''')
calls = result['launcher']['calls']
self.assertEqual(calls[0], ('mysql', 300))
self.assertEqual(calls[2], ('mysql', 900))
self.assertEqual(calls[1][0], 'world')
self.assertAlmostEqual(calls[1][1], 1500, delta=1)
def world_start(self, *, game_at=420, console_at=480, dies_at=None, requested=180):
clock = [0.0]
def sleep(seconds): clock[0] += seconds
body = f'''
import time
calls = []
dies_at = {dies_at!r}
def wait_ready(name, port, seconds=180):
until = time.monotonic() + seconds
while time.monotonic() < until:
if dies_at is not None and time.monotonic() >= dies_at:
raise RuntimeError('world stopped during startup')
if time.monotonic() >= ({game_at!r} if port == 1 else {console_at!r}):
calls.append(port)
return
time.sleep(0.5)
raise RuntimeError('world is still starting')
def start_mysql(): pass
def settings(): return {{}}
def process(name): return {{'pid': 1}}
def ra(command, config): return 'server info ready'
def main():
wait_ready('world', 1, {requested})
wait_ready('world', 2, {requested})
'''
with patch('time.monotonic', side_effect=lambda: clock[0]), patch('time.sleep', side_effect=sleep):
result = self.launch('start-all', body)
return clock[0], result['launcher']['calls']
def test_open_ports_do_not_finish_startup_until_commands_are_processed(self):
clock = [0.0]
def sleep(seconds): clock[0] += seconds
body = """
import time
calls=[]
def wait_ready(*args): pass
def start_mysql(): pass
def settings(): return {}
def process(name): return {'pid': 1}
def ra(command, config):
calls.append(command)
if time.monotonic() < 5: raise TimeoutError('main loop is loading')
return 'ready'
def main():
wait_ready('world',1)
wait_ready('world',2)
"""
with patch('time.monotonic', side_effect=lambda: clock[0]), patch('time.sleep', side_effect=sleep):
result=self.launch('start-all',body)
self.assertEqual(clock[0],5)
self.assertEqual(set(result['launcher']['calls']),{'server info'})
def test_world_death_after_ports_open_is_a_startup_failure(self):
body="""
def wait_ready(*args): pass
def start_mysql(): pass
def settings(): return {}
def process(name): return None
def main(): pass
"""
with self.assertRaisesRegex(RuntimeError,'stopped before its console accepted'):
self.launch('start-world',body)
def test_legacy_coa_world_waits_for_both_ports_after_three_minutes(self):
elapsed, calls = self.world_start()
self.assertEqual((elapsed, calls), (480, [1, 2]))
def test_console_wait_shares_the_world_deadline(self):
with self.assertRaisesRegex(RuntimeError, 'still starting'):
self.world_start(game_at=1490, console_at=1510)
self.assertEqual(self.launcher['calls'], [1])
def test_world_exit_is_reported_without_waiting_out_the_extended_budget(self):
with self.assertRaisesRegex(RuntimeError, 'stopped during startup'):
self.world_start(dies_at=12)
self.assertEqual(self.launcher['calls'], [])
def test_existing_longer_world_timeout_is_preserved(self):
self.assertEqual(self.world_start(game_at=1600, console_at=1700, requested=1800), (1700, [1, 2]))
def test_stop_dispatch_does_not_prepare_or_start_anything(self):
result = self.launch('stop-all', '''
from contextlib import nullcontext
calls = []
def wait_ready(*args): raise AssertionError('must not wait')
def start_mysql(): raise AssertionError('must not start')
def main(): raise AssertionError('must not prepare')
def settings(): return {'mysqlPort': 12345}
def control_lock(): return nullcontext()
def stop_all(config): calls.append(config['mysqlPort'])
''')
self.assertEqual(result['launcher']['calls'], [12345])
if __name__ == '__main__':
unittest.main()