Compare commits

..
51 changed files with 1645 additions and 1421 deletions

No files matched your search

+43 -5
View File
@@ -12,16 +12,32 @@ permissions:
jobs:
installer:
runs-on: windows-latest
timeout-minutes: 60
runs-on: [self-hosted, Windows, X64, coa-update-acceptance]
timeout-minutes: 1440
steps:
- uses: actions/checkout@v7
- uses: actions/setup-node@v4
with:
node-version: 22
node-version: 26.10.0
- run: npm ci
- name: Tests
run: cargo test --workspace -- --test-threads=1
run: cargo test --workspace --locked -- --test-threads=1
- name: Windows server upgrade and recovery gate
shell: pwsh
env:
GH_TOKEN: ${{ github.token }}
run: |
cargo build -p coa-release --locked
if ($LASTEXITCODE) { throw 'Verification tools failed to build.' }
gh release download base --repo Corfirean/coa-server-build --dir _acceptance-base
if ($LASTEXITCODE) { throw 'Signed base download failed.' }
& target/debug/coa-release.exe resolve --source https://github.com/Corfirean/coa-server-build/releases/download/edge --out _candidate-manifest.json
if ($LASTEXITCODE) { throw 'Cannot pin the candidate server release.' }
$version = (Get-Content _candidate-manifest.json -Raw | ConvertFrom-Json).version
gh release download "server-$version" --repo Corfirean/coa-server-build --dir _acceptance-candidate
if ($LASTEXITCODE) { throw 'Candidate download failed.' }
& tools/update-chaos-matrix.ps1 -BasePackage _acceptance-base -CandidatePackage _acceptance-candidate
if ($LASTEXITCODE) { throw 'Update/recovery acceptance failed; manager will not be published.' }
- name: Build, sign and publish
uses: tauri-apps/tauri-action@v0
env:
@@ -32,7 +48,29 @@ jobs:
tagName: ${{ github.ref_name }}
releaseName: CoA Server Manager ${{ github.ref_name }}
releaseBody: See the assets to download the installer. Existing installations update themselves.
releaseDraft: false
releaseDraft: true
prerelease: false
args: --bundles nsis
includeUpdaterJson: true
- name: Verify the exact packaged installer
shell: pwsh
run: |
$installer = Get-ChildItem target/release/bundle/nsis/*-setup.exe | Select-Object -First 1
if (-not $installer) { throw 'Built installer is missing.' }
$destination = Join-Path $env:RUNNER_TEMP ('coa-manager-installer-' + [guid]::NewGuid().ToString('N'))
$process = Start-Process -FilePath $installer.FullName -ArgumentList @('/S', "/D=$destination") -WindowStyle Hidden -Wait -PassThru
if ($process.ExitCode) { throw 'Silent installer failed.' }
$installed = Join-Path $destination 'coa-server-manager.exe'
if (-not (Test-Path $installed)) { throw 'Installed manager binary is missing.' }
if ((Get-FileHash $installed).Hash -ne (Get-FileHash target/release/coa-server-manager.exe).Hash) { throw 'Installer contains a different manager binary.' }
$report = @{ installerSha256 = (Get-FileHash $installer.FullName).Hash.ToLower(); managerSha256 = (Get-FileHash $installed).Hash.ToLower(); source = '${{ github.sha }}'; serverManifestSha256 = (Get-FileHash _acceptance-candidate/manifest.json).Hash.ToLower(); result = 'passed' }
$report | ConvertTo-Json | Set-Content installer-acceptance.json -Encoding utf8NoBOM
- name: Publish validated draft
shell: pwsh
env:
GH_TOKEN: ${{ github.token }}
run: |
gh release upload '${{ github.ref_name }}' installer-acceptance.json --clobber
if ($LASTEXITCODE) { throw 'Acceptance report upload failed.' }
gh release edit '${{ github.ref_name }}' --draft=false
if ($LASTEXITCODE) { throw 'Validated draft publication failed.' }
Generated
+3
View File
@@ -521,9 +521,12 @@ dependencies = [
name = "coa-release"
version = "0.6.5"
dependencies = [
"base64 0.22.1",
"chrono",
"coa-core",
"ed25519-dalek",
"serde_json",
"tempfile",
]
[[package]]
-104
View File
@@ -1,104 +0,0 @@
# Urgent update hotfix
Deadline: 2026-10-06. This checkout starts at the exact v0.6.4 tag, commit
6c771fa, and excludes the ongoing isolated-trial/recovery redesign.
The client accepts checksum compatibility only from a verified signed manifest and only
for an Applied migration. It never updates the historical checksum, reruns historical
SQL, or excuses a Running/Failed ledger row. A server package must explicitly list the
verified published variants and append corrections under new migration IDs.
Current local evidence: the locked workspace tests passed, including 252 core tests
run serially. Six frontend logic tests and the frontend production build passed.
The hotfix runtime was tested against the exact signed candidate manifest on the marked
CoA/Wildcard fixture. Both published repair checksums were accepted independently in
both worlds, with zero migration executions, unchanged historical checksums, and unchanged
account, character and inventory counts. The original ledger rows were restored after
the test, and all fixture processes were stopped. A real Running or Failed repair row in
either world was rejected before staging or creating a transaction, with unchanged world
executable and installation metadata. Tests use independent hotfix metadata so experimental
transaction formats are not confused with the 0.6.4 upgrade path. Windows journal writes also use flushed
atomic replacement with long-path support. Changelog validation passed.
Additional guards implemented:
- Read migration history without creating its ledger before downloading or replacing files.
- Reject missing journals, invalid identities, paths, hashes and inconsistent operations.
Durable completed-cleanup markers distinguish interrupted pruning from a lost journal.
- Preserve all backups while an update is unfinished or its journal is damaged.
- Verify saved-file hashes and the complete database/configuration recovery point before
stopping services or changing files/databases. New snapshots include configuration hashes;
update journals bind their backup metadata to a hash.
- Surface state-reading errors in Settings and disable applying until the disk state is
successfully read. Checking again refreshes that state.
- Verify every extracted SQL artifact before taking the update snapshot or replacing
server files; missing files, invalid IDs, duplicate migrations and checksum disagreements
reject the update early. SQL application repeats the integrity check immediately before use.
- Count unapplied migrations in the active and secondary realms, counting shared auth once.
Matching versions and files do not hide remaining database work. Preview reads history
under the installation lock; a stopped database is temporarily started for inspection
and stopped again when no game services are running.
- Reread the disk state after every update/recovery attempt, including failed attempts and
background updates. Unfinished or unreadable state blocks another application in the UI.
- Acquire the installation lock before checking and deleting a backup.
Latest real-runtime test used the independently copied, doubly marked fixture
`C:\games\coa-schema-fixture-chaos-20261005-v1` and signed candidate `0.261005.24`, manifest SHA-256
`1284b1273815209c9621b6d173a2211bae316f33462ccbe8b578e53b8d26fb5b`.
All 1748 SQL artifacts passed verification after authenticated archive extraction.
Removing one repair record separately in CoA and Wildcard increased the pending count
by exactly one; restoring its original record restored the original count. No migrations
were executed, player counts were preserved and fixture services were stopped afterward.
The source checkout remains uncommitted; these results are not an installer acceptance report.
Additional acceptance on 2026-10-06: a new independent installation/database copy at
`C:\games\coa-schema-fixture-chaos-064-transition-20261006` received the authenticated
published `0.261005.22` program files, original CRLF repair checksum, and a deliberately
missing Wildcard table in both realms. The production hotfix update pipeline committed
signed candidate `0.261005.24`, repaired both realms, passed schema checks and actual
bundled-Python server startup, and preserved the selected account, character, item and
inventory fields byte-for-byte. The fixture was stopped afterward. The harness explicitly
instruments the launcher to prevent relay submissions and bind to localhost; this is not
proof of packaged UI behavior or operating-system network containment.
Local installer `C:\games\source\manager-065-local-installer-20261006\CoA Server Manager_0.6.5_x64-setup.exe`
has SHA-256 `520ee0391d923b92da0a20591e30006c048cdb60156275d7a829918bf1b77491`.
Its updater signature and the published 0.6.4 installer's signature passed independent
verification with the configured updater public key. Both executables extracted from
their exact NSIS packages started, created responsive windows, and were stopped using
an independent application/WebView profile. No installer was executed over a user's
installation, and no UI update operation was exercised.
Legacy limitation: old 0.6.4 transaction copies and configuration snapshots without recorded
hashes can be checked for presence and declared database hashes, but their original file
contents cannot be authenticated retroactively. Missing copies block restoration. This
hotfix does not claim that old unchecksummed copies received full integrity verification.
Remaining release requirements: reproduce the existing-user failures through the published
0.6.4 interface, verify legacy unfinished transaction handling on real-runtime fixtures,
and execute the exact installer over 0.6.4 in an isolated Windows environment with UI
state/settings/server-list verification. Windows native UI automation is unavailable in
this session. Packaged startup and signature checks do not satisfy that installer gate.
No public release has been made.
The user subsequently exercised the packaged UI: candidate 0.261005.24 committed and
both CoA and Wildcard were shown running. Repeat-check/restart acceptance is still pending.
The screenshots exposed an older published package being offered after the local candidate
was installed. Follow-up changes reject older packages before preview/database inspection
and application and clear a cached offer after a failed recheck. All 253 core tests and
seven frontend tests passed. The earlier installer hash above does not include this follow-up;
a separately recorded revision is required. Native UI control was subsequently initialized
through the deferred node_repl tool, then the user stopped automation with Escape and
performed the UI check manually.
Another user repeat-check exposed the already installed launcher being offered again.
The preview now verifies canonical launcher bytes against the current signed package,
caches those bytes by SHA-256, and compares only recognized Manager transformations.
The actual disposable fixture's repeat preview passed with all 104 files skipped and
zero pending SQL. User edits, recorded custom content, and a package with different
launcher bytes are not mistaken for that integration. All 254 core tests passed;
the strengthened regression test and seven frontend tests also passed. The first
preview of a managed launcher may download/extract its authenticated package to build
the optional canonical cache. Earlier installer revisions do not include this fix.
Do not recommend deleting an installation or replacing its player databases.
@@ -0,0 +1,7 @@
---
area: manager
type: changed
audience: admins
title: Server updates are tested on a private copy and automatically restored after failure
---
Updates keep a fixed verified package, preserve migration history, and recover interrupted changes before starting the server. Recovery problems show a specific reason and keep the available backups.
@@ -1,7 +0,0 @@
---
area: manager
type: fixed
audience: admins
title: Server updates accept verified published migration variants without rerunning them
---
Signed updates can recognise known published checksums without changing your migration history. Interrupted or failed SQL still requires recovery before retrying.
@@ -1,7 +0,0 @@
---
area: manager
type: fixed
audience: admins
title: Server updates replace older launchers adapted by the Manager for Wildcard
---
Updates recognize the Manager’s own realm and import adjustments even when older metadata still records the original launcher. New server binaries receive their matching launcher; genuine custom edits still require your decision.
@@ -1,7 +0,0 @@
---
area: manager
type: fixed
audience: admins
title: Older server packages cannot replace a newer installation
---
Update checks stop offering stale packages after an update. To undo an update, use its recovery point instead of applying an older server package.
@@ -1,7 +0,0 @@
---
area: manager
type: fixed
audience: admins
title: Checking again no longer offers an already installed launcher update
---
The Manager recognizes its own launcher integration while still detecting user edits and changes in newer signed packages.
@@ -1,7 +0,0 @@
---
area: manager
type: fixed
audience: admins
title: Large SQUID database imports have more time to finish on first startup
---
The Manager allows up to 45 minutes when SQUID Playerbots is enabled, covering its initial database import and bot creation. Ordinary server startup and shutdown keep their existing deadlines.
@@ -1,7 +0,0 @@
---
area: manager
type: fixed
audience: admins
title: Update history conflicts are detected before server files change
---
Damaged update records block changes and remain visible. Recovery checks saved copies before restoring, and unfinished updates protect backups from deletion and cleanup.
@@ -1,7 +0,0 @@
---
area: manager
type: fixed
audience: admins
title: Pending database updates remain visible when the server version matches
---
SQL files are checked before replacing server files. Update and recovery attempts refresh their saved status, including errors. Backup deletion cannot race with an update.
@@ -1,38 +0,0 @@
use std::{fs, path::PathBuf};
use coa_core::{manifest::{Kind, Manifest}, package::{self, BuildOptions}, pkgsource::{self, Source}, release, signing, Result};
fn main() -> Result<()> {
let args: Vec<String> = std::env::args().skip(1).collect();
let source = Source::Dir(args[1].clone().into());
let (previous, _) = pkgsource::fetch_manifest(&source, signing::EMBEDDED_PUBLIC_KEY)?;
let tree = PathBuf::from(&args[2]);
if args[0] == "extract" {
assert!(!tree.exists(), "Use a new release tree");
package::extract(&PathBuf::from(&args[1]), &previous, &tree, &|_, _| {})?;
println!("Verified and extracted {}: {} historical migrations", previous.version, previous.migrations.len());
return Ok(());
}
assert_eq!(args[0], "pack");
let out = PathBuf::from(&args[3]);
assert!(!out.exists(), "Release addresses must be immutable");
for migration in &previous.migrations {
let entry = previous.files.iter().find(|file| file.path.starts_with("_migrations/") && file.sha256 == migration.sha256).expect("Historical SQL entry");
assert_eq!(coa_core::fsx::sha256_file(&tree.join(&entry.path))?, entry.sha256, "Historical SQL changed: {}", migration.id);
}
let mut manifest = package::build(&tree, &out, &BuildOptions {
kind: Kind::Update, version: args[4].clone(), core_commit: Some(args[5].clone()),
bots_commit: previous.bots.and_then(|revision| revision.commit),
built_at: chrono::Utc::now().to_rfc3339(), part_size: package::DEFAULT_PART_SIZE,
migrations: previous.migrations.clone(),
}, &|line| println!("{line}"))?;
manifest.min_manager_version = "0.6.5".into();
manifest.validate()?;
coa_core::fsx::atomic_write(&out.join("manifest.json"), &serde_json::to_vec_pretty(&manifest)?)?;
let key_path = PathBuf::from(std::env::var("USERPROFILE").unwrap()).join(".coa-manager/signing/manifest-signing.key");
release::sign_manifest(&out, &fs::read_to_string(key_path)?)?;
coa_core::release_schema::verify_package(&out, signing::EMBEDDED_PUBLIC_KEY)?;
let reread: Manifest = serde_json::from_slice(&fs::read(out.join("manifest.json"))?)?;
assert_eq!(serde_json::to_value(reread.migrations)?, serde_json::to_value(previous.migrations)?);
println!("PASS: signed {}; all historical migration bytes, checksums, aliases and order preserved", manifest.version);
Ok(())
}
@@ -1,70 +0,0 @@
use std::path::{Path, PathBuf};
use coa_core::{backup, driver, fsx, Result};
fn set(root: &Path, filename: &str, values: &[(&str, &str)]) -> Result<()> {
let path = root.join("Core/configs/modules").join(filename);
let mut config = coa_core::config::parser::ConfFile::parse_bytes(&std::fs::read(&path)?)?;
for (key, value) in values { config.set(key, value, &[]); }
fsx::atomic_write(&path, config.to_text().as_bytes())
}
fn ledgers(root: &Path) -> Result<Vec<String>> {
backup::with_database(root, |db| ["acore_playerbots", "acore_world", "acore_characters"].into_iter()
.map(|schema| db.query(&format!("SELECT path,sha256 FROM `{schema}`.coa_squid_migrations ORDER BY path;"))).collect())
}
fn exercise(root: &Path) -> Result<()> {
let meta = coa_core::registry::metadata_dir_for(root)?;
let point = backup::create(root, &meta, backup::Kind::Full, backup::Trigger::Manual, Some("Disposable SQUID acceptance".into()), &|stage| println!("{stage}"))?;
assert!(backup::verify(&meta, &point.id)?.ok);
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| -> Result<()> {
backup::with_database(root, |db| db.query("DROP DATABASE IF EXISTS acore_playerbots;").map(|_| ()))?;
assert!(driver::run(root, driver::Verb::StartAll)?.ok, "Disabled SQUID must start without its database");
assert!(driver::run(root, driver::Verb::StopAll)?.ok);
coa_core::multiworld::set_enabled(root, false)?;
coa_core::realms::select(root, coa_core::realms::Mode::Coa)?;
set(root, "mod_coa_playerbots.conf", &[("CoaBots.Enable", "0")])?;
set(root, "playerbots.conf", &[("AiPlayerbot.Enabled", "1"), ("AiPlayerbot.RandomBotAutologin", "0"), ("AiPlayerbot.MinRandomBots", "0"), ("AiPlayerbot.MaxRandomBots", "0"), ("AiPlayerbot.RandomBotGuildCount", "0"), ("AiPlayerbot.RandomBotAccountCount", "0")])?;
let started = driver::run(root, driver::Verb::StartAll)?;
assert!(started.ok, "Fresh SQUID startup: {}", coa_core::diag::redact(&started.output));
let before = ledgers(root)?;
assert!(!before[0].is_empty(), "Fresh SQUID history missing");
assert!(driver::run(root, driver::Verb::StopAll)?.ok);
let started = driver::run(root, driver::Verb::StartAll)?;
assert!(started.ok, "Repeated SQUID startup: {}", coa_core::diag::redact(&started.output));
assert_eq!(ledgers(root)?, before, "SQUID replay changed its migration history");
println!("PASS: SQUID-disabled dual startup without its database; fresh enabled SQUID import and startup; repeated startup preserves all three histories");
Ok(())
}));
assert!(driver::run(root, driver::Verb::StopAll)?.ok);
restore(root, &meta, &point)?;
result.map_err(|_| coa_core::Error::Invalid("SQUID acceptance failed; disposable databases and configurations restored".into()))?
}
fn restore(root: &Path, meta: &Path, point: &backup::RecoveryPoint) -> Result<()> {
assert!(backup::verify(meta, &point.id)?.ok);
assert!(driver::run(root, driver::Verb::StopAll)?.ok);
coa_core::realms::select(root, point.realm)?;
for component in point.components.iter().filter(|component| component.name != "configs") {
backup::restore_database(root, meta, &point.id, &component.name)?;
}
backup::restore_configs(root, meta, &point.id)?;
assert!(driver::run(root, driver::Verb::StopAll)?.ok);
println!("PASS: disposable SQUID acceptance databases and original realm configurations restored");
Ok(())
}
fn main() -> Result<()> {
let root = PathBuf::from(std::env::args().nth(1).unwrap());
assert!(root.file_name().unwrap().to_string_lossy().starts_with("coa-schema-fixture-chaos-064-transition-"));
assert_eq!(std::fs::read(root.join(".transition-fixture"))?, b"disposable published-064 transition fixture");
assert!(!root.join("Data").symlink_metadata()?.file_type().is_symlink());
assert!(driver::run(&root, driver::Verb::StopAll)?.ok);
if let Some(id) = std::env::args().nth(2) {
let meta = coa_core::registry::metadata_dir_for(&root)?;
return restore(&root, &meta, &backup::get(&meta, &id)?);
}
let result = exercise(&root);
assert!(driver::run(&root, driver::Verb::StopAll)?.ok);
result
}
@@ -1,54 +0,0 @@
use std::{collections::BTreeMap, path::PathBuf};
use coa_core::{backup, driver, registry::MetaDir, update::{self, RepackEnv}, Result};
fn players(db: &coa_core::db::Db) -> Result<String> {
db.query("SELECT CONCAT(id,':',username,':',HEX(salt),':',HEX(verifier)) FROM acore_auth.account WHERE id=900001; SELECT CONCAT(guid,':',account,':',name,':',level,':',money) FROM acore_characters.characters WHERE guid=900001; SELECT CONCAT(guid,':',itemEntry,':',owner_guid,':',enchantments) FROM acore_characters.item_instance WHERE guid=900001; SELECT CONCAT(guid,':',bag,':',slot,':',item) FROM acore_characters.character_inventory WHERE guid=900001;")
}
fn exercise(root: &std::path::Path, package: &str) -> Result<()> {
let meta_dir = coa_core::registry::metadata_dir_for(root)?;
let (_, meta) = MetaDir::open(&meta_dir)?;
let expected = backup::with_database(root, |db| [coa_core::realms::Mode::Coa, coa_core::realms::Mode::Wildcard].into_iter().map(|mode| players(&db.clone().for_realm(mode))).collect::<Result<Vec<_>>>())?;
assert!(driver::run(root, driver::Verb::StopAll)?.ok);
let source = coa_core::pkgsource::Source::Dir(package.into());
let preview = update::preview(root, &meta, &source, coa_core::signing::EMBEDDED_PUBLIC_KEY, &BTreeMap::new())?;
assert_eq!(preview.pending_migrations, 0, "Historical SQL must not replay");
assert!(!preview.items.iter().any(|item| item.action == update::Action::Conflict), "Unresolved candidate files: {:?}", preview.items);
let environment = RepackEnv { root, meta_dir: &meta_dir };
let outcome = update::apply(&update::Params {
root, meta_dir: &meta_dir, source, trusted_key: coa_core::signing::EMBEDDED_PUBLIC_KEY,
resolutions: BTreeMap::new(), cancel: Default::default(), env: &environment, fail_after_ops: None,
}, &|stage, progress| println!("{progress}% {stage}"))?;
assert_eq!(outcome.txn.state, update::State::Committed, "{:?}", outcome.txn);
backup::with_database(root, |db| {
for (index, mode) in [coa_core::realms::Mode::Coa, coa_core::realms::Mode::Wildcard].into_iter().enumerate() {
let realm = db.clone().for_realm(mode);
assert_eq!(players(&realm)?, expected[index], "Player data changed in {mode:?}");
let problems = coa_core::schema_check::check(&realm, root)?;
assert!(problems.is_empty(), "{problems:?}");
}
Ok(())
})?;
let release = coa_core::squid::release(root).expect("SQUID release metadata");
println!("SQUID metadata: {release:?}");
assert_eq!(coa_core::squid::fields(root)?.len(), 40);
let (_, installed) = MetaDir::open(&meta_dir)?;
let repeated = update::preview(root, &installed, &coa_core::pkgsource::Source::Dir(package.into()), coa_core::signing::EMBEDDED_PUBLIC_KEY, &BTreeMap::new())?;
assert_eq!(repeated.pending_migrations, 0);
assert!(repeated.items.iter().all(|item| item.action == update::Action::Skip), "{:?}", repeated.items);
println!("PASS: coordinated update committed, both realms started, player fields preserved, historical SQL skipped, repeated preview clean");
Ok(())
}
fn main() -> Result<()> {
let args: Vec<String> = std::env::args().skip(1).collect();
let root = PathBuf::from(&args[0]);
assert!(root.file_name().unwrap().to_string_lossy().starts_with("coa-schema-fixture-chaos-064-transition-"));
assert_eq!(std::fs::read(root.join(".transition-fixture"))?, b"disposable published-064 transition fixture");
assert_eq!(std::fs::read(root.join(".release-schema-fixture"))?, b"disposable release-schema fixture");
assert!(!root.join("Data").symlink_metadata()?.file_type().is_symlink());
assert!(driver::run(&root, driver::Verb::StopAll)?.ok);
let outcome = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| exercise(&root, &args[1])));
assert!(driver::run(&root, driver::Verb::StopAll)?.ok, "Fixture shutdown failed");
outcome.map_err(|_| coa_core::Error::Invalid("Disposable coordinated acceptance failed; stopped services and retained recovery copies".into()))?
}
@@ -1,93 +0,0 @@
//! Verify published checksum compatibility on a disposable real database, without running SQL migrations.
use std::{path::{Path, PathBuf}, sync::atomic::{AtomicUsize, Ordering}};
use coa_core::{backup, db::Db, migrations::{self, LedgerRow, Status, Store}, pkgsource::{self, Source}, Result};
struct Observed<'a> { db: &'a Db, executions: AtomicUsize }
impl Store for Observed<'_> {
fn load(&self) -> Result<Vec<LedgerRow>> { self.db.load() }
fn put(&self, row: &LedgerRow) -> Result<()> { self.db.put(row) }
fn run_file(&self, _: &str, _: &Path) -> Result<()> {
self.executions.fetch_add(1, Ordering::SeqCst);
panic!("Historical SQL must never be replayed");
}
}
fn main() -> Result<()> {
let args: Vec<_> = std::env::args().skip(1).collect();
let root = PathBuf::from(&args[0]);
assert!(root.file_name().unwrap().to_string_lossy().starts_with("coa-schema-fixture-chaos-"));
assert_eq!(std::fs::read(root.join(".coa-chaos-fixture"))?, b"disposable update chaos fixture");
assert_eq!(std::fs::read(root.join(".release-schema-fixture"))?, b"disposable release-schema fixture");
let source = Source::Dir(PathBuf::from(&args[1]));
let package = pkgsource::fetch_manifest(&source, coa_core::signing::EMBEDDED_PUBLIC_KEY)?.0;
let staging = tempfile::tempdir()?;
let parts = pkgsource::fetch_parts(&source, &package, &staging.path().join("download"), &Default::default(), &|_, _| {})?;
coa_core::package::extract(&parts, &package, &staging.path().join("tree"), &|_, _| {})?;
migrations::verify_files(&package.migrations, &staging.path().join("tree/_migrations"))?;
println!("PASS: all {} signed-package SQL artifacts verified before any database mutation", package.migrations.len());
let migration = package.migrations.iter().find(|m| m.id == "manager_repair__20261005_missing_wildcard_tables").unwrap();
let hashes = ["c1d8dbf2271234283a48a39e4b4aea1106b83b70581f1e3c4aa9fff438e8e4d2", "9e4a36245c3f83255415c122c01f08ceb3e3b83898d3d427ac4e2fbcf61e9638"];
for hash in hashes { assert!(migration.sha256 == hash || migration.compatible_sha256.iter().any(|h| h == hash)); }
let fixture_meta = coa_core::registry::metadata_dir_for(&root)?;
let test_meta = tempfile::tempdir()?;
coa_core::fsx::atomic_write(&test_meta.path().join("install.json"), &std::fs::read(fixture_meta.join("install.json"))?)?;
coa_core::registry::MetaDir::open(test_meta.path())?;
std::fs::create_dir_all(test_meta.path().join("updates"))?;
let result = backup::with_database(&root, |db| {
let mut modes = vec![coa_core::realms::Mode::Coa];
if coa_core::realms::state(&root)?.wildcard_created { modes.push(coa_core::realms::Mode::Wildcard); }
for mode in modes {
let db = db.clone().for_realm(mode);
let saved = db.load()?.into_iter().find(|row| row.id == migration.id && row.db == migration.db).expect("Published repair must already be applied");
assert_eq!(saved.status, Status::Applied);
let counts = db.query("SELECT CONCAT((SELECT COUNT(*) FROM acore_characters.characters),':',(SELECT COUNT(*) FROM acore_characters.item_instance),':',(SELECT COUNT(*) FROM acore_auth.account));")?;
let check = || -> Result<()> {
for hash in hashes {
db.put(&LedgerRow { sha256: hash.into(), ..saved.clone() })?;
let observed = Observed { db: &db, executions: AtomicUsize::new(0) };
migrations::preflight(&db, std::slice::from_ref(migration))?;
let report = migrations::apply_pending(&observed, std::slice::from_ref(migration), &root.join(".unused-hotfix-sql"), &|| panic!("Already applied SQL needs no snapshot"))?;
assert!(report.applied.is_empty());
assert_eq!(observed.executions.load(Ordering::SeqCst), 0);
assert_eq!(db.load()?.into_iter().find(|r| r.id == migration.id && r.db == migration.db).unwrap().sha256, hash);
}
let meta = test_meta.path();
let file_hash = coa_core::fsx::sha256_file(&root.join("Core/worldserver.exe"))?;
let install_hash = coa_core::fsx::sha256_file(&meta.join("install.json"))?;
let transaction_count = std::fs::read_dir(meta.join("updates"))?.count();
for status in [Status::Running, Status::Failed] {
db.put(&LedgerRow { status, ..saved.clone() })?;
let env = coa_core::update::RepackEnv { root: &root, meta_dir: meta };
let rejected = coa_core::update::apply(&coa_core::update::Params {
root: &root, meta_dir: meta, source: Source::Dir(PathBuf::from(&args[1])),
trusted_key: coa_core::signing::EMBEDDED_PUBLIC_KEY, cancel: Default::default(),
resolutions: Default::default(), env: &env, fail_after_ops: None,
}, &|_, _| {});
let message = rejected.unwrap_err().to_string();
assert!(message.contains("partially applied"), "Unexpected rejection: {message}");
assert_eq!(std::fs::read_dir(meta.join("updates"))?.count(), transaction_count);
assert_eq!(coa_core::fsx::sha256_file(&root.join("Core/worldserver.exe"))?, file_hash);
assert_eq!(coa_core::fsx::sha256_file(&meta.join("install.json"))?, install_hash);
}
db.put(&saved)?;
let env = coa_core::update::RepackEnv { root: &root, meta_dir: meta };
let pending_before = env.pending_migrations(&package)?;
db.query("DELETE FROM acore_world.coa_manager_migrations WHERE db='characters' AND id='manager_repair__20261005_missing_wildcard_tables';")?;
assert_eq!(env.pending_migrations(&package)?, pending_before + 1,
"Missing history in either realm must remain visible even with identical server files");
db.put(&saved)?;
assert_eq!(env.pending_migrations(&package)?, pending_before);
Ok(())
};
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(check));
db.put(&saved)?;
result.map_err(|_| coa_core::Error::Invalid("History regression assertion failed; the injected ledger row was restored.".into()))??;
assert_eq!(db.query("SELECT CONCAT((SELECT COUNT(*) FROM acore_characters.characters),':',(SELECT COUNT(*) FROM acore_characters.item_instance),':',(SELECT COUNT(*) FROM acore_auth.account));")?, counts);
println!("PASS: {} published checksums; Running/Failed rejected before staging; missing migration counted; zero SQL replays; history and player counts preserved", mode.name());
}
Ok(())
});
assert!(coa_core::driver::run(&root, coa_core::driver::Verb::StopAll)?.ok);
result?;
Ok(())
}
@@ -1,16 +0,0 @@
//! Read-only update preview against the marked disposable acceptance fixture.
use std::{collections::BTreeMap,path::PathBuf};
fn main()->coa_core::Result<()> {
let args:Vec<_>=std::env::args().skip(1).collect();
let root=PathBuf::from(&args[0]);
assert!(root.file_name().unwrap().to_string_lossy().starts_with("coa-schema-fixture-chaos-064-transition-"));
assert_eq!(std::fs::read(root.join(".transition-fixture"))?,b"disposable published-064 transition fixture");
let meta_dir=coa_core::registry::metadata_dir_for(&root)?;
let (_,meta)=coa_core::registry::MetaDir::open(&meta_dir)?;
let preview=coa_core::update::preview(&root,&meta,&coa_core::pkgsource::Source::Dir(args[1].clone().into()),coa_core::signing::EMBEDDED_PUBLIC_KEY,&BTreeMap::new())?;
assert_eq!(preview.from_version.as_deref(),Some(preview.to_version.as_str()));
assert_eq!(preview.pending_migrations,0);
assert!(preview.items.iter().all(|item|item.action==coa_core::update::Action::Skip),"{:?}",preview.items.iter().filter(|item|item.action!=coa_core::update::Action::Skip).collect::<Vec<_>>());
println!("PASS: real fixture repeated preview: {} files unchanged, zero pending SQL, no update offered",preview.items.len());
Ok(())
}
@@ -1,165 +0,0 @@
//! Real signed-package transition on an independent, explicitly marked disposable copy.
//! The Env wrapper instruments only launcher isolation; migration/backup/update code is production code.
use std::{collections::BTreeMap, path::{Path, PathBuf}};
use coa_core::{backup, driver, fsx, migrations, pkgsource::{self, Source}, registry::{InstallMeta, MetaDir}, update::{self, Env, RepackEnv}, Result};
struct Offline<'a>(RepackEnv<'a>);
impl Env for Offline<'_> {
fn ensure_stopped(&self) -> Result<()> { self.0.ensure_stopped() }
fn preflight(&self, m: &coa_core::manifest::Manifest) -> Result<()> { self.0.preflight(m) }
fn verify_snapshot(&self, id: &str) -> Result<()> { self.0.verify_snapshot(id) }
fn snapshot(&self) -> Result<String> { self.0.snapshot() }
fn restore_snapshot(&self, id: &str) -> Result<()> { self.0.restore_snapshot(id) }
fn migrate(&self, m: &coa_core::manifest::Manifest, p: &Path) -> Result<migrations::ApplyReport> { self.0.migrate(m,p) }
fn validate(&self) -> Result<()> {
let path=self.0.root.join("Scripts/manage.py");
let source=std::fs::read_to_string(&path)?.replace("\r\n", "\n");
// Explicit test instrumentation prevents relay transmissions and binds services locally.
let guarded=source.replace("def spawn(name, command, cwd, log):\n", "def spawn(name, command, cwd, log):\n for filename in ('worldserver.conf', 'authserver.conf'):\n path = ROOT / 'Core/configs' / filename\n if path.exists():\n text = path.read_text(encoding='utf-8-sig')\n for key, value in (('BindIP', '\"127.0.0.1\"'), ('Ra.IP', '\"127.0.0.1\"'), ('SOAP.Enabled', '0')):\n text = re.sub(r'(?m)^\\s*' + re.escape(key) + r'\\s*=.*$', '', text)\n text += '\\n' + key + ' = ' + value + '\\n'\n path.write_text(text, encoding='utf-8')\n").replace("def relay_worker():\n", "def relay_worker():\n save_process('relay-ready', os.getpid())\n while not (STATE / 'stop-relay').exists():\n time.sleep(0.5)\n return\n");
assert_ne!(source,guarded,"Fixture launcher isolation failed");
fsx::atomic_write(&path,guarded.as_bytes())?;
self.0.validate()
}
}
fn players(db: &coa_core::db::Db) -> Result<String> {
db.query("SELECT CONCAT(id,':',username,':',HEX(salt),':',HEX(verifier)) FROM acore_auth.account WHERE id=900001; SELECT CONCAT(guid,':',account,':',name,':',level,':',money) FROM acore_characters.characters WHERE guid=900001; SELECT CONCAT(guid,':',itemEntry,':',owner_guid,':',enchantments) FROM acore_characters.item_instance WHERE guid=900001; SELECT CONCAT(guid,':',bag,':',slot,':',item) FROM acore_characters.character_inventory WHERE guid=900001;")
}
fn main() -> Result<()> {
let args:Vec<_>=std::env::args().skip(1).collect();
let root=PathBuf::from(&args[0]);
assert!(root.file_name().unwrap().to_string_lossy().starts_with("coa-schema-fixture-chaos-064-transition-"));
assert_eq!(std::fs::read(root.join(".transition-fixture"))?,b"disposable published-064 transition fixture");
if args.get(3).is_some_and(|mode| mode=="legacy-recovery") {
return run_fixture(&root,||legacy_recovery(&root));
}
assert!(!root.join(".transition-started").exists(),"Use a new independent fixture");
fsx::atomic_write(&root.join(".transition-started"),b"started")?;
let meta=coa_core::registry::metadata_dir_for(&root)?;
assert!(!meta.exists(),"Do not reuse experimental or user metadata");
run_fixture(&root,||exercise(&root,&meta,&args[1],&args[2]))
}
fn run_fixture(root:&Path,operation:impl FnOnce()->Result<()>)->Result<()> {
let result=std::panic::catch_unwind(std::panic::AssertUnwindSafe(operation));
assert!(driver::run(root,driver::Verb::StopAll)?.ok,"Fixture shutdown failed");
result.map_err(|_|coa_core::Error::Invalid("Disposable acceptance assertion failed; services were stopped and recovery copies retained.".into()))?
}
fn legacy_recovery(root:&Path)->Result<()> {
let meta=coa_core::registry::metadata_dir_for(root)?;
assert!(driver::run(root,driver::Verb::StopAll)?.ok);
let expected=backup::with_database(root,|db| [coa_core::realms::Mode::Coa,coa_core::realms::Mode::Wildcard].into_iter().map(|mode|players(&db.clone().for_realm(mode))).collect::<Result<Vec<_>>>())?;
assert!(driver::run(root,driver::Verb::StopAll)?.ok);
let dirs=std::fs::read_dir(meta.join("updates"))?.collect::<std::io::Result<Vec<_>>>()?;
assert_eq!(dirs.len(),1,"Requires exactly the preceding successful disposable transition");
let txn_dir=dirs[0].path();
let journal=txn_dir.join("txn.json");
let mut legacy:serde_json::Value=fsx::read_json(&journal)?;
assert_eq!(legacy["state"],"committed");
let point=legacy["recovery_point"].as_str().unwrap().to_string();
let point_path=meta.join("backups").join(&point).join("backup.json");
let mut point_json:serde_json::Value=fsx::read_json(&point_path)?;
point_json["manager_version"]="0.6.4".into();
for component in point_json["components"].as_array_mut().unwrap() { component.as_object_mut().unwrap().remove("file_sha256"); }
fsx::atomic_write_json(&point_path,&point_json)?;
legacy.as_object_mut().unwrap().remove("recovery_hashes");
legacy.as_object_mut().unwrap().remove("databases_started");
legacy["state"]="applied".into();
fsx::atomic_write_json(&journal,&legacy)?;
assert!(update::ensure_recovered(&meta).is_err(),"Legacy unfinished update must block startup");
let id=legacy["id"].as_str().unwrap();
let env=RepackEnv {root,meta_dir:&meta};
println!("Recovering legacy-format transaction and recovery point on disposable installation");
assert_eq!(update::rollback(root,&meta,id,&env)?.state,update::State::RolledBack);
for op in legacy["ops"].as_array().unwrap() {
let relative=op["path"].as_str().unwrap();
if op["had_previous"]==true {
assert_eq!(fsx::sha256_file(&fsx::safe_join(root,relative)?)?,fsx::sha256_file(&fsx::safe_join(&txn_dir.join("before"),relative)?)?,"Legacy file restoration mismatch: {relative}");
} else { assert!(!fsx::safe_join(root,relative)?.exists()); }
}
assert_eq!(std::fs::read(meta.join("install.json"))?,std::fs::read(txn_dir.join("before/manager-install.json"))?);
backup::with_database(root,|db| {
for (index,mode) in [coa_core::realms::Mode::Coa,coa_core::realms::Mode::Wildcard].into_iter().enumerate() {
let db=db.clone().for_realm(mode);
assert_eq!(players(&db)?,expected[index]);
assert_eq!(db.query("SELECT COUNT(*) FROM acore_world.coa_manager_migrations WHERE id IN ('manager_repair__20261005_reconcile_wildcard_tables','manager_repair__20261005_reconcile_missing_class_starts');")?,"0");
assert_eq!(db.query("SELECT sha256 FROM acore_world.coa_manager_migrations WHERE id='manager_repair__20261005_missing_wildcard_tables';")?,"9e4a36245c3f83255415c122c01f08ceb3e3b83898d3d427ac4e2fbcf61e9638");
}
Ok(())
})?;
assert!(driver::run(root,driver::Verb::StopAll)?.ok);
assert!(update::pending_checked(&meta)?.is_none());
assert!(update::rollback(root,&meta,id,&env).is_err(),"Completed recovery must not run again");
println!("PASS: legacy journal blocked startup; old files, metadata, migration histories and player fields restored; completed recovery rejects replay. Original baseline had a missing table, so healthy startup is not claimed after rollback.");
Ok(())
}
fn exercise(root:&Path,meta:&Path,baseline:&str,candidate:&str)->Result<()> {
let mut install:InstallMeta=fsx::read_json(&PathBuf::from("C:/games/coa-schema-fixture-chaos-20261005-v1.manager/install.json"))?;
install.server_path=root.to_string_lossy().into_owned();
install.id=uuid::Uuid::new_v4().to_string();
install.manager_version="0.6.4".into();
MetaDir::create(root,&install)?;
// Private ports, and no inherited PID records or paths to the source database.
let mut cfg:serde_json::Value=fsx::read_json(&root.join("Settings/repack.json"))?;
let mut listeners=Vec::new();
for key in ["mysqlPort","authPort","worldPort","raPort"] {
let listener=std::net::TcpListener::bind("127.0.0.1:0")?;
cfg[key]=listener.local_addr()?.port().into(); listeners.push(listener);
}
fsx::atomic_write_json(&root.join("Settings/repack.json"),&cfg)?;
let mut profile:serde_json::Value=fsx::read_json(&root.join("Settings/realm-profile.json"))?;
for key in ["secondary_world_port","secondary_ra_port"] {
let listener=std::net::TcpListener::bind("127.0.0.1:0")?;
profile[key]=listener.local_addr()?.port().into(); listeners.push(listener);
}
fsx::atomic_write_json(&root.join("Settings/realm-profile.json"),&profile)?;
drop(listeners);
let state=root.join(".state");
if state.exists() { std::fs::remove_dir_all(&state)?; }
let secondary_state=root.join(".realms/secondary/.state");
if secondary_state.exists() { std::fs::remove_dir_all(&secondary_state)?; }
let source=Source::Dir(baseline.into());
let (manifest,_)=pkgsource::fetch_manifest(&source,coa_core::signing::EMBEDDED_PUBLIC_KEY)?;
let temp=tempfile::tempdir()?;
let parts=pkgsource::fetch_parts(&source,&manifest,&temp.path().join("download"),&Default::default(),&|_,_|{})?;
let tree=temp.path().join("tree");
coa_core::package::extract(&parts,&manifest,&tree,&|_,_|{})?;
for file in &manifest.files {
if file.path.starts_with("_migrations/") {continue;}
fsx::atomic_write(&fsx::safe_join(root,&file.path)?,&std::fs::read(fsx::safe_join(&tree,&file.path)?)?)?;
install.original_hashes.insert(file.path.clone(),file.sha256.clone());
}
install.core.version=Some(manifest.version);
fsx::atomic_write_json(&meta.join("install.json"),&install)?;
// Both worlds must remain local, including generated secondary configuration.
for relative in ["Settings/worldserver.conf.template","Settings/authserver.conf.template"] {
let p=root.join(relative);
let mut conf=coa_core::config::parser::ConfFile::parse_bytes(&std::fs::read(&p)?)?;
conf.set("BindIP","\"127.0.0.1\"",&[]); conf.set("Ra.IP","\"127.0.0.1\"",&[]); conf.set("SOAP.Enabled","0",&[]);
fsx::atomic_write(&p,conf.to_text().as_bytes())?;
}
let expected=backup::with_database(root,|db| {
let mut saved=Vec::new();
for mode in [coa_core::realms::Mode::Coa,coa_core::realms::Mode::Wildcard] {
let db=db.clone().for_realm(mode);
saved.push(players(&db)?);
db.query("DROP TABLE IF EXISTS acore_characters.coa_wildcard_skill_card; DELETE FROM acore_world.coa_manager_migrations WHERE id IN ('manager_repair__20261005_reconcile_wildcard_tables','manager_repair__20261005_reconcile_missing_class_starts'); UPDATE acore_world.coa_manager_migrations SET sha256='9e4a36245c3f83255415c122c01f08ceb3e3b83898d3d427ac4e2fbcf61e9638' WHERE id='manager_repair__20261005_missing_wildcard_tables' AND status='applied';")?;
}
Ok(saved)
})?;
let source=Source::Dir(candidate.into());
let candidate_manifest=pkgsource::fetch_manifest(&source,coa_core::signing::EMBEDDED_PUBLIC_KEY)?.0;
let choices:BTreeMap<_,_>=update::plan(root,&install,&candidate_manifest,&BTreeMap::new(),None)?.into_iter().filter(|p|p.action==update::Action::Conflict).map(|p|(p.path,update::Resolution::Replace)).collect();
let env=Offline(RepackEnv{root,meta_dir:meta});
let outcome=update::apply(&update::Params {root,meta_dir:meta,source,trusted_key:coa_core::signing::EMBEDDED_PUBLIC_KEY,cancel:Default::default(),resolutions:choices,env:&env,fail_after_ops:None},&|stage,pct|println!("{pct}% {stage}"))?;
assert_eq!(outcome.txn.state,update::State::Committed,"{:?}",outcome.txn.message);
backup::with_database(root,|db| {
for (index,mode) in [coa_core::realms::Mode::Coa,coa_core::realms::Mode::Wildcard].into_iter().enumerate() {
let db=db.clone().for_realm(mode);
assert_eq!(players(&db)?,expected[index],"Player data changed in {}",mode.name());
assert!(coa_core::schema_check::check(&db,root)?.is_empty());
assert_eq!(migrations::pending_count(&db,&candidate_manifest.migrations)?,0);
}
Ok(())
})?;
println!("PASS: signed historical package to candidate; missing Wildcard table repaired in both realms; player fields and inventory preserved; schema and startup verified. Launcher isolation was test instrumentation, not packaged UI acceptance.");
Ok(())
}
+76 -52
View File
@@ -51,7 +51,7 @@ pub struct Component {
pub sha256: Option<String>,
pub tables: Option<usize>,
pub files: Option<Vec<String>>,
#[serde(default)]
#[serde(default, skip_serializing_if = "std::collections::BTreeMap::is_empty")]
pub file_sha256: std::collections::BTreeMap<String, String>,
}
@@ -93,7 +93,8 @@ pub fn list(meta: &Path) -> Vec<RecoveryPoint> {
}
pub fn get(meta: &Path, id: &str) -> Result<RecoveryPoint> {
let point: RecoveryPoint = fsx::read_json(&fsx::ensure_within(meta, &point_dir(meta, id)?.join("backup.json"))?).map_err(|_| Error::Invalid(format!("backup {id} was not found or its metadata is damaged")))?;
let path = fsx::ensure_within(meta, &point_dir(meta, id)?.join("backup.json"))?;
let point: RecoveryPoint = fsx::read_json(&path).map_err(|_| Error::Invalid(format!("backup {id} was not found or its metadata is damaged")))?;
if point.id != id || point.schema != 1 { return Err(Error::Invalid(format!("Backup {id} has inconsistent identity or an unsupported schema."))); }
Ok(point)
}
@@ -136,6 +137,7 @@ pub fn config_files(root: &Path) -> Vec<String> {
walk(root, &root.join("Settings/realm-profiles"), &mut out);
if root.join("Settings/realm-profile.json").is_file() { out.push("Settings/realm-profile.json".into()); }
out.sort();
out.dedup();
out
}
@@ -147,10 +149,11 @@ fn copy_configs(root: &Path, dir: &Path) -> Result<Component> {
for rel in &files {
let src = fsx::safe_join(root, rel)?;
let dst = fsx::safe_join(&target, rel)?;
let content = fs::read(&src)?;
fsx::atomic_write(&dst, &content)?;
bytes += content.len() as u64;
file_sha256.insert(rel.clone(), fsx::sha256_bytes(&content));
fs::create_dir_all(dst.parent().unwrap())?;
let contents = fs::read(&src)?;
fsx::atomic_write(&dst, &contents)?;
bytes += contents.len() as u64;
file_sha256.insert(rel.clone(), fsx::sha256_bytes(&contents));
}
Ok(Component { name: "configs".into(), path: "files".into(), bytes, sha256: None, tables: None, files: Some(files), file_sha256 })
}
@@ -252,7 +255,7 @@ pub fn create(root: &Path, meta: &Path, kind: Kind, trigger: Trigger, label: Opt
components,
};
fsx::atomic_write_json(&partial.join("backup.json"), &point)?;
fs::rename(&partial, &final_dir)?;
fsx::durable_replace(&partial, &final_dir)?;
tracing::info!(%id, ?kind, ?trigger, "recovery point created");
if trigger == Trigger::Automatic {
prune_automatic(meta, 10);
@@ -281,21 +284,8 @@ pub fn verify(meta: &Path, id: &str) -> Result<VerifyReport> {
let point = get(meta, id)?;
let dir = point_dir(meta, id)?;
let mut problems = Vec::new();
let mut names = std::collections::BTreeSet::new();
let mut schemas = std::collections::BTreeSet::new();
for c in &point.components {
if !names.insert(&c.name) { problems.push(format!("{} appears more than once", c.name)); }
let path = fsx::ensure_within(&dir, &fsx::safe_join(&dir, &c.path)?)?;
if c.name != "configs" && (c.sha256.is_none() || c.tables.is_none()) { problems.push(format!("{} lacks database integrity metadata", c.name)); }
if c.name == "configs" {
if c.sha256.is_some() || c.files.is_none() { problems.push("configuration integrity metadata is inconsistent".into()); }
} else {
let schema = if c.name.contains('-') || c.name == "playerbots" { db::schema_of(&c.name) } else { point.realm.schema(&c.name) };
match schema {
Ok(schema) if schemas.insert(schema) => {}
_ => problems.push(format!("{} has an unknown or duplicate database target", c.name)),
}
}
match (&c.sha256, &c.files) {
(Some(sha), _) => match fsx::sha256_file(&path) {
Ok(actual) if actual.eq_ignore_ascii_case(sha) => {}
@@ -304,16 +294,14 @@ pub fn verify(meta: &Path, id: &str) -> Result<VerifyReport> {
},
(None, Some(files)) => {
for f in files {
if !c.file_sha256.is_empty() && !c.file_sha256.contains_key(f) { problems.push(format!("configuration file {f} lacks its checksum")); }
if !fsx::safe_join(&path, f).map(|p| p.is_file()).unwrap_or(false) {
problems.push(format!("configuration file {f} is missing"));
} else if let Some(expected) = c.file_sha256.get(f) {
let file = fsx::ensure_within(&dir, &fsx::safe_join(&path, f)?)?;
if fsx::sha256_file(&file)?.as_str() != expected { problems.push(format!("configuration file {f} is damaged")); }
if fsx::sha256_file(&fsx::safe_join(&path, f)?).ok().as_deref() != Some(expected.as_str()) { problems.push(format!("configuration file {f} is damaged")); }
}
}
}
_ => problems.push(format!("{} lacks an integrity inventory", c.name)),
_ => {}
}
}
Ok(VerifyReport { ok: problems.is_empty(), problems })
@@ -321,7 +309,8 @@ pub fn verify(meta: &Path, id: &str) -> Result<VerifyReport> {
/// Delete one recovery point (its own folder only).
pub fn delete(meta: &Path, id: &str) -> Result<()> {
let _lock = crate::update::operation_lock(meta)?;
// A damaged journal cannot reliably identify which copies recovery needs.
// Preserve every available point until the installation is consistent.
crate::update::ensure_recovered(meta)?;
if crate::update::unfinished(meta).is_some_and(|t| t.recovery_point.as_deref() == Some(id)) {
return Err(Error::Invalid("This recovery point is required by an unfinished update and cannot be deleted.".into()));
@@ -351,6 +340,20 @@ pub fn restore_configs(root: &Path, meta: &Path, id: &str) -> Result<RecoveryPoi
Ok(safety)
}
/// Transaction recovery has already protected the original state. Do not require a second backup.
pub(crate) fn restore_update_configs(root: &Path, meta: &Path, id: &str) -> Result<()> {
let point = get(meta, id)?;
if !verify(meta, id)?.ok { return Err(Error::Invalid("The update recovery point is damaged.".into())); }
let comp = point.components.iter().find(|c| c.name == "configs").ok_or_else(|| Error::Invalid("The update recovery point has no configuration.".into()))?;
if comp.files.as_deref().unwrap_or_default().iter().any(|file| !comp.file_sha256.contains_key(file)) {
return Err(Error::Invalid("This legacy recovery point has no configuration checksums. Automatic recovery cannot verify the original settings; copies were preserved for inspection.".into()));
}
for rel in comp.files.as_deref().unwrap_or_default() {
fsx::atomic_write(&fsx::ensure_within(root, &fsx::safe_join(root, rel)?)?, &fs::read(fsx::safe_join(&point_dir(meta, id)?.join(&comp.path), rel)?)?)?;
}
Ok(())
}
#[derive(Debug, Serialize)]
pub struct DbRestore {
/// The database the restore replaced, kept intact under this name.
@@ -362,6 +365,14 @@ pub struct DbRestore {
/// Restore one database from a recovery point without dropping anything:
/// import into a staging schema, sanity-check it, then swap tables atomically and keep the old schema.
pub fn restore_database(root: &Path, meta: &Path, id: &str, name: &str) -> Result<DbRestore> {
restore_database_inner(root, meta, id, name, true)
}
pub(crate) fn restore_update_database(root: &Path, meta: &Path, id: &str, name: &str) -> Result<DbRestore> {
restore_database_inner(root, meta, id, name, false)
}
fn restore_database_inner(root: &Path, meta: &Path, id: &str, name: &str, safety_copy: bool) -> Result<DbRestore> {
let point = get(meta, id)?;
if point.realm != crate::realms::state(root)?.active {
return Err(Error::Invalid("Select the realm this backup belongs to before restoring it.".into()));
@@ -377,21 +388,48 @@ pub fn restore_database(root: &Path, meta: &Path, id: &str, name: &str) -> Resul
let live = if name.contains('-') || name == "playerbots" { db::schema_of(name)? } else { point.realm.schema(name)? };
let expected_tables = comp.tables.unwrap_or(0);
let dump = point_dir(meta, id)?.join(&comp.path);
let stamp = uuid::Uuid::new_v4().simple().to_string()[..16].to_string();
let reconstructed_hash = point_dir(meta, id)?.join(format!("restore-{name}.sha256"));
let stamp = if safety_copy { uuid::Uuid::new_v4().simple().to_string()[..16].to_string() }
else { fsx::sha256_bytes(format!("update-recovery:{id}:{name}").as_bytes())[..16].to_string() };
// 1. Safety copy of the current state, so even a wrong restore is reversible.
let safety = create(root, meta, Kind::Database, Trigger::BeforeRestore, Some(format!("before restoring {name} from {id}")), &|_| {})?;
let safety = if safety_copy { Some(create(root, meta, Kind::Database, Trigger::BeforeRestore, Some(format!("before restoring {name} from {id}")), &|_| {})?.id) } else { None };
with_database(root, |db| {
let db = db.clone().for_realm(crate::realms::Mode::Coa);
let staging = format!("{live}_restore_{stamp}");
let old = format!("{live}_before_restore_{stamp}");
if db.schema_exists(&staging)? || db.schema_exists(&old)? {
if safety_copy && (db.schema_exists(&staging)? || db.schema_exists(&old)?) {
return Err(Error::Invalid("A previous restore left its work schemas behind; try again in a moment.".into()));
}
if !safety_copy {
if db.schema_exists(&old)? {
// RENAME TABLE is atomic. An empty staging schema proves that the old tables
// were moved out and the complete restored set was moved into live together.
if reconstructed_hash.is_file() && db.schema_exists(&staging)? && db.tables(&staging)?.is_empty() && db.tables(live)?.len() == expected_tables {
db.query(&format!("DROP DATABASE `{old}`; DROP DATABASE `{staging}`;"))?;
return Ok(DbRestore { previous_schema: old, safety_backup: String::new(), tables_restored: expected_tables });
}
// A server crash can interrupt a rename involving MyISAM tables.
// The original dump was verified above and is authoritative: discard only
// this recovery's deterministic work schemas and import a complete set again.
db.query(&format!("DROP DATABASE `{old}`;"))?;
}
if db.schema_exists(&staging)? { db.query(&format!("DROP DATABASE `{staging}`;"))?; }
}
// 2. Import into staging.
db.query(&format!("CREATE DATABASE `{staging}` CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;"))?;
db.import_from(&staging, &dump)?;
if !safety_copy {
// SHOW CREATE TABLE can make implicit character sets explicit on import.
// Compare live against the independently reconstructed snapshot, keeping all
// schema and row bytes rather than accepting a table-count approximation.
let check = point_dir(meta, id)?.join(format!("restore-{name}.sql.zst"));
let (_, hash) = db.dump_to(&staging, &check)?;
fsx::atomic_write(&reconstructed_hash, hash.as_bytes())?;
fs::remove_file(check)?;
}
crate::update_fault::checkpoint(root, &format!("restore-database:{name}:imported"));
// 3. Sanity checks.
let staged = db.tables(&staging)?;
if comp.tables.is_some_and(|expected| staged.len() != expected) || (comp.tables.is_none() && staged.is_empty()) {
@@ -411,7 +449,11 @@ pub fn restore_database(root: &Path, meta: &Path, id: &str, name: &str) -> Resul
renames.push(format!("`{staging}`.`{t}` TO `{live}`.`{t}`"));
}
if !renames.is_empty() { db.query(&format!("RENAME TABLE {};", renames.join(", ")))?; }
Ok(DbRestore { previous_schema: old, safety_backup: safety.id.clone(), tables_restored: staged.len() })
crate::update_fault::checkpoint(root, &format!("restore-database:{name}:swapped"));
// For emergency recovery, completed temporary schemas are disposable. A crash before
// cleanup leaves the original dump intact, and another recovery can repeat the swap.
if !safety_copy { db.query(&format!("DROP DATABASE `{old}`; DROP DATABASE `{staging}`;"))?; }
Ok(DbRestore { previous_schema: old, safety_backup: safety.clone().unwrap_or_default(), tables_restored: staged.len() })
})
}
@@ -433,33 +475,15 @@ mod tests {
}
#[test]
fn backup_deletion_obeys_the_installation_lock() {
let (_d, root, meta) = setup();
let point = create(&root, &meta, Kind::Config, Trigger::Manual, None, &|_| {}).unwrap();
let lock = crate::update::operation_lock(&meta).unwrap();
assert!(delete(&meta, &point.id).is_err());
assert!(get(&meta, &point.id).is_ok());
drop(lock);
delete(&meta, &point.id).unwrap();
assert!(get(&meta, &point.id).is_err());
}
#[test]
fn damaged_configuration_is_detected_before_restore_and_copies_are_retained() {
fn corrupt_update_journal_preserves_available_backups() {
let (_d, root, meta) = setup();
let point = create(&root, &meta, Kind::Config, Trigger::Automatic, None, &|_| {}).unwrap();
let file = point_dir(&meta, &point.id).unwrap().join("files/Core/configs/worldserver.conf");
fs::write(&file, b"corrupted").unwrap();
assert!(!verify(&meta, &point.id).unwrap().ok);
let original = fs::read(root.join("Core/configs/worldserver.conf")).unwrap();
assert!(restore_configs(&root, &meta, &point.id).is_err());
assert_eq!(fs::read(root.join("Core/configs/worldserver.conf")).unwrap(), original);
assert_eq!(list(&meta).len(), 1);
fs::create_dir_all(meta.join("updates/broken")).unwrap();
fs::write(meta.join("updates/broken/txn.json"), b"{damaged").unwrap();
let updates = meta.join("updates").join("interrupted");
fs::create_dir_all(&updates).unwrap();
fs::write(updates.join("txn.json"), b"{damaged").unwrap();
assert!(delete(&meta, &point.id).is_err());
prune_automatic(&meta, 0);
assert!(file.exists());
assert!(get(&meta, &point.id).is_ok());
}
#[test]
+6 -1
View File
@@ -89,6 +89,9 @@ pub(crate) fn credentials(root: &Path) -> Result<(String, String)> {
}
impl Db {
pub(crate) fn native_root(&self) -> Option<PathBuf> {
if self.container.is_some() { None } else { self.bin.parent().and_then(|p| p.parent()).map(Path::to_path_buf) }
}
pub fn from_repack(root: &Path, account: Account) -> Result<Db> {
let creds: Credentials = fsx::read_json(&root.join("Settings/database.json"))
.map_err(|_| Error::Invalid("The database settings of this server could not be read.".into()))?;
@@ -265,7 +268,7 @@ impl Db {
let file = File::create(out)?;
let mut enc = zstd::Encoder::new(BufWriter::new(file), 3)?;
let copy = std::io::copy(&mut stdout, &mut enc);
let finish = enc.finish().and_then(|mut w| w.flush());
let finish = enc.finish().and_then(|mut w| { w.flush()?; w.get_ref().sync_all() });
let status = child.wait()?;
let stderr_bytes = err_thread.join().unwrap_or_default();
if !status.success() {
@@ -280,6 +283,8 @@ impl Db {
/// Run a plain SQL file against `schema`; the first error aborts and is returned.
pub fn run_sql_file(&self, schema: &str, file: &Path) -> Result<()> {
let injected = if let Some(root) = self.native_root() { crate::update_fault::failing_sql(&root, file)? } else { None };
let file = injected.as_ref().map(|f| f.path()).unwrap_or(file);
let schema = self.realm_schema(schema);
if !ident_ok(schema) {
return Err(Error::Invalid("bad schema name".into()));
+8
View File
@@ -249,6 +249,14 @@ pub fn export_package(root: &Path, meta_dir: &Path, manager_log: &Path, meta: &I
if let Ok(b) = fs::read(meta_dir.join("logs/database-checks.json")) {
add("database-checks.json", redact(&String::from_utf8_lossy(&b)).as_bytes())?;
}
if let Ok(b) = fs::read(meta_dir.join("logs/update-result.json")) {
add("update-result.json", redact(&String::from_utf8_lossy(&b)).as_bytes())?;
}
if let Ok(Some(txn)) = crate::update::latest(meta_dir) {
if let Ok(b) = fs::read(meta_dir.join("updates").join(&txn.id).join("diagnostic.json")) {
add("update-diagnostic.json", redact(&String::from_utf8_lossy(&b)).as_bytes())?;
}
}
zip.finish().map_err(|e| Error::Invalid(e.to_string()))?;
Ok(n)
}
+37 -44
View File
@@ -31,9 +31,8 @@ impl Verb {
}
}
fn timeout(self, root: &Path) -> Duration {
fn timeout(self) -> Duration {
match self {
Verb::StartAll | Verb::StartWorld if squid_enabled(root) => Duration::from_secs(2700),
Verb::StartAll | Verb::StartWorld => Duration::from_secs(420),
Verb::StartMysql => Duration::from_secs(120),
Verb::StopAll => Duration::from_secs(240),
@@ -41,14 +40,6 @@ impl Verb {
}
}
fn squid_enabled(root: &Path) -> bool {
let active = root.join("Core/configs/modules/playerbots.conf");
let path = if active.exists() { active } else { root.join("Core/configs/modules/playerbots.conf.dist") };
std::fs::read(path).ok().and_then(|bytes| crate::config::parser::ConfFile::parse_bytes(&bytes).ok())
.is_some_and(|config| config.get("AiPlayerbot.Enabled").is_none_or(|value|
!matches!(value.trim().trim_matches('"').to_ascii_lowercase().as_str(), "0" | "false" | "no" | "off")))
}
#[derive(Debug, Clone, Serialize)]
pub struct DriverOutcome {
pub ok: bool,
@@ -90,20 +81,41 @@ fn launcher(root: &Path) -> Result<(PathBuf, PathBuf)> {
/// Run a launcher verb to completion (blocking; call from a worker thread).
pub fn run(root: &Path, verb: Verb) -> Result<DriverOutcome> {
run_inner(root, verb, false)
run_inner(root, verb, false, false)
}
pub(crate) fn validate_update(root: &Path) -> Result<DriverOutcome> {
run_inner(root, Verb::StartAll, true)
run_inner(root, Verb::StartAll, true, true)
}
fn run_inner(root: &Path, verb: Verb, validating_update: bool) -> Result<DriverOutcome> {
pub(crate) fn start_after_update(root: &Path) -> Result<DriverOutcome> {
run_inner(root, Verb::StartAll, true, false)
}
pub(crate) fn validate_secondary(root: &Path) -> Result<DriverOutcome> {
run_inner(root, Verb::StartWorld, true, true)
}
/// Validate without accepting game connections or submitting reports. Child supervisors inherit the flag.
pub(crate) fn offline_launcher(text: &str) -> Result<String> {
let normalized = text.replace("\r\n", "\n");
let text = normalized.as_str();
if text.contains("# coa-offline-validation") { return Ok(text.into()); }
if !text.contains("def spawn(name, command, cwd, log):") || !text.contains("def relay_worker():") {
return Err(Error::Invalid("This launcher cannot isolate an update validation. Update was not applied.".into()));
}
let spawn = "def spawn(name, command, cwd, log):\n # coa-offline-validation\n if os.environ.get('COA_UPDATE_VALIDATION') == '1':\n for filename in ('worldserver.conf', 'authserver.conf'):\n path = ROOT / 'Core/configs' / filename\n if path.exists():\n text = path.read_text(encoding='utf-8-sig')\n for key, value in (('BindIP', '\"127.0.0.1\"'), ('Ra.IP', '\"127.0.0.1\"'), ('SOAP.Enabled', '0')):\n text = re.sub(r'(?m)^\\s*' + re.escape(key) + r'\\s*=.*$', '', text)\n text += '\\n' + key + ' = ' + value + '\\n'\n path.write_text(text, encoding='utf-8')\n";
let relay = "def relay_worker():\n if os.environ.get('COA_UPDATE_VALIDATION') == '1':\n save_process('relay-ready', os.getpid())\n while not (STATE / 'stop-relay').exists():\n time.sleep(0.5)\n return\n";
Ok(text.replacen("def spawn(name, command, cwd, log):\n", spawn, 1).replacen("def relay_worker():\n", relay, 1))
}
fn run_inner(root: &Path, verb: Verb, validating_update: bool, offline: bool) -> Result<DriverOutcome> {
let root = fsx::canonicalize_lenient(root)?;
let _update_lock = if !validating_update && matches!(verb, Verb::StartAll | Verb::StartWorld) {
Some(crate::update::operation_lock(&crate::registry::metadata_dir_for(&root)?)?)
} else { None };
if !validating_update && matches!(verb, Verb::StartAll | Verb::StartWorld) {
crate::update::ensure_recovered(&crate::registry::metadata_dir_for(&root)?)?;
crate::update::recover_before_start(&root, &crate::registry::metadata_dir_for(&root)?)?;
}
if matches!(verb, Verb::StartAll | Verb::StartWorld) { crate::modules::ensure_bot_exclusivity(&root)?; }
if crate::docker::is_docker(&root) {
@@ -124,7 +136,8 @@ fn run_inner(root: &Path, verb: Verb, validating_update: bool) -> Result<DriverO
if matches!(verb, Verb::StartAll | Verb::StartWorld) { crate::modules::ensure_bot_exclusivity(&root)?; }
let (python, script) = launcher(&root)?;
let original = std::fs::read_to_string(&script)?;
let patched = patch_launcher_imports(&original)?;
let imported = patch_launcher_imports(&original)?;
let patched = if offline { offline_launcher(&imported)? } else { imported };
if original != patched {
fsx::atomic_write(&script, patched.as_bytes())?;
if let Ok(dir) = crate::registry::metadata_dir_for(&root) {
@@ -137,8 +150,10 @@ fn run_inner(root: &Path, verb: Verb, validating_update: bool) -> Result<DriverO
}
}
let mut cmd = Command::new(&python);
cmd.arg("-B").arg("-c").arg(LAUNCH_SCRIPT).arg(&script).arg(verb.arg())
let launch = if offline && crate::update_fault::python_failure(&root) { "raise RuntimeError('Injected disposable-fixture Python failure')" } else { LAUNCH_SCRIPT };
cmd.arg("-B").arg("-c").arg(launch).arg(&script).arg(verb.arg())
.current_dir(&root).stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::piped());
if offline { cmd.env("COA_UPDATE_VALIDATION", "1"); }
#[cfg(windows)]
{
use std::os::windows::process::CommandExt;
@@ -158,7 +173,7 @@ fn run_inner(root: &Path, verb: Verb, validating_update: bool) -> Result<DriverO
let _ = stderr.read_to_string(&mut s);
s
});
let deadline = Instant::now() + verb.timeout(&root);
let deadline = Instant::now() + verb.timeout();
let status = loop {
if let Some(st) = child.try_wait()? {
break Some(st);
@@ -188,7 +203,10 @@ fn run_inner(root: &Path, verb: Verb, validating_update: bool) -> Result<DriverO
}
};
tracing::info!(?verb, ok, ?code, "driver: launcher verb finished");
if ok && verb == Verb::StartAll { crate::multiworld::start(&root)?; }
if ok && verb == Verb::StartAll {
if offline { crate::multiworld::start_validation(&root)?; }
else { crate::multiworld::start(&root)?; }
}
Ok(DriverOutcome { ok, exit_code, code, human: code.map(ErrorCode::human), output })
}
@@ -207,24 +225,11 @@ pub(crate) fn patch_launcher_imports(text: &str) -> Result<String> {
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; }
if patch_launcher_imports(signed).and_then(|s| offline_launcher(&s)).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.filter(|c| *c != ErrorCode::Unknown)
.or_else(|| crate::health::diagnose_installation(root));
@@ -239,18 +244,6 @@ pub(crate) fn startup_failure(root: &Path, started: &DriverOutcome) -> String {
mod tests {
use super::*;
#[test]
fn large_squid_provisioning_has_time_to_finish_without_extending_shutdown() {
let folder = tempfile::tempdir().unwrap();
let modules = folder.path().join("Core/configs/modules");
std::fs::create_dir_all(&modules).unwrap();
std::fs::write(modules.join("playerbots.conf.dist"), "AiPlayerbot.Enabled = 1\n").unwrap();
assert_eq!(Verb::StartAll.timeout(folder.path()), Duration::from_secs(2700));
assert_eq!(Verb::StopAll.timeout(folder.path()), Duration::from_secs(240));
std::fs::write(modules.join("playerbots.conf"), "AiPlayerbot.Enabled = 0\n").unwrap();
assert_eq!(Verb::StartWorld.timeout(folder.path()), Duration::from_secs(420));
}
#[test]
fn translates_known_launcher_messages() {
assert_eq!(translate("RuntimeError: Port 8085 is already used. Stop the other server"), ErrorCode::PortInUse);
+5 -5
View File
@@ -148,10 +148,6 @@ pub(crate) fn bootstrap_database(root: &Path) -> Result<()> {
with_scratch_ports(root, || bootstrap_database_inner(root))
}
fn free_port() -> Result<u16> {
Ok(std::net::TcpListener::bind("127.0.0.1:0")?.local_addr()?.port())
}
/// Run `f` with the staging copy listening on unused ports, so an installation never collides with a server (or any
/// other program) already using the shipped ports. The shipped ports are put back afterwards.
pub(crate) fn with_scratch_ports<T>(root: &Path, f: impl FnOnce() -> Result<T>) -> Result<T> {
@@ -159,10 +155,14 @@ pub(crate) fn with_scratch_ports<T>(root: &Path, f: impl FnOnce() -> Result<T>)
let path = root.join("Settings/repack.json");
let original: serde_json::Value = fsx::read_json(&path)?;
let mut scratch = original.clone();
let mut listeners = Vec::new();
for k in KEYS {
scratch[k] = free_port()?.into();
let listener = std::net::TcpListener::bind("127.0.0.1:0")?;
scratch[k] = listener.local_addr()?.port().into();
listeners.push(listener);
}
fsx::atomic_write_json(&path, &scratch)?;
drop(listeners);
let result = f();
// keep whatever else changed meanwhile (console credentials), restore only the ports
let mut now: serde_json::Value = fsx::read_json(&path).unwrap_or(scratch);
+3
View File
@@ -25,6 +25,7 @@ pub mod population;
pub mod process;
pub mod manifest;
pub mod migrations;
pub mod migration_registry;
pub mod multiworld;
pub mod repair;
pub mod schema_check;
@@ -39,6 +40,8 @@ pub mod registry;
pub mod release;
pub mod release_schema;
pub mod update;
mod update_trial;
mod update_fault;
pub mod upnp;
pub mod signing;
pub mod srp6;
+33 -102
View File
@@ -35,9 +35,9 @@ pub struct LedgerRow {
/// Storage for the ledger and the ability to run a SQL file; implemented by the real database and by tests.
pub trait Store {
fn load(&self) -> Result<Vec<LedgerRow>>;
fn load_readonly(&self) -> Result<Vec<LedgerRow>> { self.load() }
fn put(&self, row: &LedgerRow) -> Result<()>;
fn run_file(&self, schema: &str, file: &Path) -> Result<()>;
fn checkpoint(&self, _point: &str) {}
}
fn hex_of(s: &str) -> String {
@@ -49,17 +49,14 @@ fn ident_ok(s: &str) -> bool {
}
impl Store for Db {
fn checkpoint(&self, point: &str) {
if let Some(root) = self.native_root() { crate::update_fault::checkpoint(&root, point); }
}
fn load(&self) -> Result<Vec<LedgerRow>> {
self.query(&format!(
"CREATE TABLE IF NOT EXISTS `{LEDGER_SCHEMA}`.`{LEDGER_TABLE}` (`db` VARCHAR(32) NOT NULL, `id` VARCHAR(190) NOT NULL, `sha256` CHAR(64) NOT NULL, `status` VARCHAR(16) NOT NULL, `applied_at` DATETIME NOT NULL, `error` TEXT NULL, `baseline` TINYINT NOT NULL DEFAULT 0, PRIMARY KEY (`db`,`id`)) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;"
))?;
self.load_readonly()
}
fn load_readonly(&self) -> Result<Vec<LedgerRow>> {
let out = if self.tables(LEDGER_SCHEMA)?.iter().any(|name| name == LEDGER_TABLE) {
self.query(&format!("SELECT `db`,`id`,`sha256`,`status`,`baseline`,COALESCE(HEX(`error`),'') FROM `{LEDGER_SCHEMA}`.`{LEDGER_TABLE}` ORDER BY `db`,`id`;"))?
} else { String::new() };
let out = self.query(&format!("SELECT `db`,`id`,`sha256`,`status`,`baseline`,COALESCE(HEX(`error`),'') FROM `{LEDGER_SCHEMA}`.`{LEDGER_TABLE}` ORDER BY `db`,`id`;"))?;
let mut rows = Vec::new();
// Files the core's own updater (or whoever prepared this database) already recorded count as applied.
for (kind, schema) in db::SCHEMAS {
@@ -155,51 +152,7 @@ fn recorded<'a>(rows: &'a [LedgerRow], m: &Migration) -> Option<&'a LedgerRow> {
}
fn hash_changed(row: &LedgerRow, m: &Migration) -> bool {
row.status == Status::Applied && row.sha256 != "0".repeat(64) && !row.sha256.eq_ignore_ascii_case(&m.sha256)
&& !m.compatible_sha256.iter().any(|hash| hash.eq_ignore_ascii_case(&row.sha256))
}
/// Inspect recorded history without creating a ledger or executing migrations.
pub fn preflight(store: &dyn Store, list: &[Migration]) -> Result<()> {
check_history(&store.load_readonly()?, list)
}
pub fn pending_count(store: &dyn Store, list: &[Migration]) -> Result<usize> {
let rows = store.load_readonly()?;
check_history(&rows, list)?;
Ok(list.iter().filter(|m| recorded(&rows, m).is_none_or(|r| r.status != Status::Applied)).count())
}
fn verified_file(m: &Migration, dir: &Path) -> Result<(&'static str, std::path::PathBuf, bool)> {
if !ident_ok(&m.id) { return Err(Error::InvalidManifest(format!("migration id {:?} is not allowed", m.id))); }
let schema = db::schema_of(&m.db)?;
let path = fsx::safe_join(dir, &format!("{}/{}.sql", m.db, m.id))?;
let bytes = std::fs::read(&path).map_err(|_| Error::Invalid(format!("migration file {} is missing", m.id)))?;
let actual = fsx::sha256_bytes(&bytes);
if !actual.eq_ignore_ascii_case(&m.sha256) { return Err(Error::HashMismatch { path: path.display().to_string(), expected: m.sha256.clone(), actual }); }
Ok((schema, path, m.destructive || looks_destructive(&String::from_utf8_lossy(&bytes))))
}
/// Check every migration artifact, including applied history, before replacing server files.
pub fn verify_files(list: &[Migration], dir: &Path) -> Result<()> {
let mut seen = std::collections::BTreeSet::new();
for m in list {
if !seen.insert((&m.db, &m.id)) { return Err(Error::InvalidManifest(format!("duplicate migration {} ({})", m.id, m.db))); }
verified_file(m, dir)?;
}
Ok(())
}
fn check_history(rows: &[LedgerRow], list: &[Migration]) -> Result<()> {
for m in list {
if recorded(rows, m).is_some_and(|r| matches!(r.status, Status::Running | Status::Failed)) {
return Err(Error::Invalid(format!("Database update {} ({}) failed or was interrupted and may be partially applied. Restore its recovery point before retrying.", m.id, m.db)));
}
if recorded(rows, m).is_some_and(|r| hash_changed(r, m)) {
return Err(Error::Invalid(format!("Applied database update {} ({}) has a different checksum. A new migration is required; it was not replayed.", m.id, m.db)));
}
}
Ok(())
row.status == Status::Applied && row.sha256 != "0".repeat(64) && !row.sha256.eq_ignore_ascii_case(&m.sha256) && !m.compatible_sha256.iter().any(|h| h.eq_ignore_ascii_case(&row.sha256))
}
/// Record migrations as already present without running them (adopting an existing server whose database
@@ -229,7 +182,14 @@ pub struct ApplyReport {
pub fn apply_pending(store: &dyn Store, list: &[Migration], dir: &Path, snapshot: &dyn Fn() -> Result<String>) -> Result<ApplyReport> {
let rows = store.load()?;
// The list order is the release's order of application (released updates, then pending, then modules).
check_history(&rows, list)?;
for m in list {
if recorded(&rows, m).is_some_and(|r| matches!(r.status, Status::Running | Status::Failed)) {
return Err(Error::Invalid(format!("Database update {} ({}) failed or was interrupted and may be partially applied. Restore its recovery point before retrying.", m.id, m.db)));
}
if recorded(&rows, m).is_some_and(|r| hash_changed(r, m)) {
return Err(Error::Invalid(format!("Applied database update {} ({}) has a different checksum. A new migration is required; it was not replayed.", m.id, m.db)));
}
}
let todo: Vec<&Migration> = list.iter().filter(|m| recorded(&rows, m).is_none_or(|r| r.status != Status::Applied)).collect();
tracing::info!(total = list.len(), pending = todo.len(), skipped = list.len() - todo.len(), "database migration plan");
@@ -237,8 +197,17 @@ pub fn apply_pending(store: &dyn Store, list: &[Migration], dir: &Path, snapshot
let mut files = Vec::new();
let mut any_destructive = false;
for m in &todo {
let (schema, path, destructive) = verified_file(m, dir)?;
any_destructive |= destructive;
if !ident_ok(&m.id) {
return Err(Error::InvalidManifest(format!("migration id {:?} is not allowed", m.id)));
}
let schema = db::schema_of(&m.db)?;
let path = fsx::safe_join(dir, &format!("{}/{}.sql", m.db, m.id))?;
let bytes = std::fs::read(&path).map_err(|_| Error::Invalid(format!("migration file {} is missing", m.id)))?;
let actual = fsx::sha256_bytes(&bytes);
if !actual.eq_ignore_ascii_case(&m.sha256) {
return Err(Error::HashMismatch { path: path.display().to_string(), expected: m.sha256.clone(), actual });
}
any_destructive |= m.destructive || looks_destructive(&String::from_utf8_lossy(&bytes));
files.push((*m, schema, path));
}
@@ -252,10 +221,13 @@ pub fn apply_pending(store: &dyn Store, list: &[Migration], dir: &Path, snapshot
for (m, schema, path) in files {
tracing::info!(migration = %m.id, database = %m.db, "database migration starting");
store.put(&LedgerRow { db: m.db.clone(), id: m.id.clone(), sha256: m.sha256.clone(), status: Status::Running, error: Some("Interrupted SQL must be recovered before replay.".into()), baseline: false })?;
store.checkpoint(&format!("before-sql:{}", m.id));
match store.run_file(schema, &path) {
Ok(()) => {
store.checkpoint(&format!("after-sql:{}", m.id));
store.put(&LedgerRow { db: m.db.clone(), id: m.id.clone(), sha256: m.sha256.clone(), status: Status::Applied, error: None, baseline: false })?;
report.applied.push(m.id.clone());
store.checkpoint(&format!("recorded-sql:{}", m.id));
tracing::info!(migration = %m.id, database = %m.db, "database migration applied");
}
Err(e) => {
@@ -340,57 +312,16 @@ mod tests {
}
#[test]
fn staged_files_reject_missing_corrupt_duplicate_and_invalid_migrations() {
let (dir, list) = setup(&[("characters", "repair", "SELECT 1;\n")]);
verify_files(&list, dir.path()).unwrap();
let mut bad = list.clone();
bad[0].id = "../outside".into();
assert!(verify_files(&bad, dir.path()).is_err());
bad = list.clone();
bad.push(list[0].clone());
assert!(verify_files(&bad, dir.path()).is_err());
std::fs::write(dir.path().join("characters/repair.sql"), b"SELECT 2;\n").unwrap();
assert!(verify_files(&list, dir.path()).is_err());
std::fs::remove_file(dir.path().join("characters/repair.sql")).unwrap();
assert!(verify_files(&list, dir.path()).is_err());
}
#[test]
fn preflight_uses_readonly_history_and_rejects_conflicts_without_writes() {
struct ReadOnly<'a>(&'a Mem);
impl Store for ReadOnly<'_> {
fn load(&self) -> Result<Vec<LedgerRow>> { panic!("preflight must use readonly access") }
fn load_readonly(&self) -> Result<Vec<LedgerRow>> { self.0.load() }
fn put(&self, _: &LedgerRow) -> Result<()> { panic!("preflight must not rewrite history") }
fn run_file(&self, _: &str, _: &Path) -> Result<()> { panic!("preflight must not run SQL") }
}
let (_d, list) = setup(&[("characters", "repair", "SELECT 1;\n")]);
for state in [Status::Applied, Status::Running, Status::Failed] {
let store = Mem::default();
store.rows.borrow_mut().push(LedgerRow { db: "characters".into(), id: "repair".into(), sha256: "a".repeat(64), status: state, error: None, baseline: false });
assert!(preflight(&ReadOnly(&store), &list).is_err());
assert_eq!(store.rows.borrow()[0].sha256, "a".repeat(64));
assert_eq!(store.rows.borrow()[0].status, state);
}
}
#[test]
fn published_compatibility_preserves_history_and_never_replays_sql() {
fn only_explicit_published_compatibility_skips_changed_hash_without_rewriting_history() {
let (d, mut list) = setup(&[("characters", "repair", "SELECT 1;\n")]);
let store = Mem::default();
let old = fsx::sha256_bytes(b"SELECT 1;\r\n");
store.rows.borrow_mut().push(LedgerRow { db: "characters".into(), id: "repair".into(), sha256: old.clone(), status: Status::Applied, error: None, baseline: false });
let previous = fsx::sha256_bytes(b"SELECT 1;\r\n");
store.rows.borrow_mut().push(LedgerRow { db: "characters".into(), id: "repair".into(), sha256: previous.clone(), status: Status::Applied, error: None, baseline: false });
assert!(apply_pending(&store, &list, d.path(), &no_snapshot).is_err());
list[0].compatible_sha256.push(old.clone());
assert_eq!(status(&store, &list).unwrap()[0].status, Status::Applied);
list[0].compatible_sha256.push(previous.clone());
assert!(apply_pending(&store, &list, d.path(), &no_snapshot).unwrap().applied.is_empty());
assert!(store.ran.borrow().is_empty());
assert_eq!(store.rows.borrow()[0].sha256, old);
store.rows.borrow_mut()[0].status = Status::Running;
assert!(apply_pending(&store, &list, d.path(), &no_snapshot).is_err());
store.rows.borrow_mut()[0].status = Status::Failed;
assert!(apply_pending(&store, &list, d.path(), &no_snapshot).is_err());
assert!(store.ran.borrow().is_empty());
assert_eq!(store.rows.borrow()[0].sha256, previous);
}
#[test]
+9 -1
View File
@@ -125,6 +125,14 @@ fn secondary_launcher(source: &str) -> Result<String> {
}
pub fn start(main: &Path) -> Result<()> {
start_inner(main, false)
}
pub(crate) fn start_validation(main: &Path) -> Result<()> {
start_inner(main, true)
}
fn start_inner(main: &Path, offline: bool) -> Result<()> {
if !realms::state(main)?.simultaneous { return Ok(()); }
if is_running(main) {
let second = root(main);
@@ -132,7 +140,7 @@ pub fn start(main: &Path) -> Result<()> {
return Err(Error::Invalid("The second realm is still starting or stopping.".into()));
}
let second = prepare(main)?;
let out = driver::run(&second, Verb::StartWorld)?;
let out = if offline { driver::validate_secondary(&second)? } else { driver::run(&second, Verb::StartWorld)? };
if !out.ok { return Err(Error::Invalid(format!("The second realm did not start: {}", out.output))); }
Ok(())
}
+75 -5
View File
@@ -4,6 +4,8 @@
use std::fs;
use std::io::Read;
use std::path::{Path, PathBuf};
use base64::{engine::general_purpose::STANDARD, Engine};
use serde::{Deserialize, Serialize};
use crate::download::{self, Cancel, Job, Progress};
use crate::error::{Error, Result};
@@ -20,6 +22,77 @@ pub enum Source {
Dir(PathBuf),
}
#[derive(Debug, Serialize, Deserialize)]
pub struct Channel {
pub schema: u32,
pub version: String,
pub release: String,
pub manifest_sha256: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub acceptance_sha256: Option<String>,
}
#[derive(Serialize, Deserialize)]
pub struct SignedChannel {
pub payload: String,
pub signature: String,
}
pub fn verify_channel(bytes: &[u8], trusted_key: &str) -> Result<Channel> {
let signed: SignedChannel = serde_json::from_slice(bytes).map_err(|e| Error::InvalidManifest(e.to_string()))?;
let payload = STANDARD.decode(&signed.payload).map_err(|e| Error::InvalidManifest(e.to_string()))?;
signing::verify(&payload, &signed.signature, trusted_key)?;
let pointer: Channel = serde_json::from_slice(&payload).map_err(|e| Error::InvalidManifest(e.to_string()))?;
let required = format!("https://github.com/Corfirean/coa-server-build/releases/download/server-{}/", pointer.version);
if pointer.schema != 1 || crate::manifest::parse_version(&pointer.version).is_none() || pointer.release != required {
return Err(Error::InvalidManifest("Channel does not point to an immutable server release.".into()));
}
Ok(pointer)
}
/// A channel is one atomically replaced signed envelope. Its target is immutable.
pub struct PinnedPackage {
pub source: Source,
pub manifest: Manifest,
pub bytes: Vec<u8>,
pub signature: Vec<u8>,
}
pub fn fetch_package(source: &Source, trusted_key: &str) -> Result<PinnedPackage> {
let channel = match source {
Source::Dir(d) if !d.join("channel.json").exists() => None,
_ => match fetch_small(source, "channel.json") {
Ok(bytes) => Some(bytes),
Err(Error::PackageNotPublished(_)) => None,
Err(e) => return Err(e),
},
};
let (mut resolved, expected) = if let Some(bytes) = channel {
let pointer = verify_channel(&bytes, trusted_key)?;
(Source::Url(pointer.release.clone()), Some(pointer))
} else { (source.clone(), None) };
let mut bytes = fetch_small(&resolved, "manifest.json")?;
let mut signature = fetch_small(&resolved, "manifest.json.sig")?;
signing::verify(&bytes, &String::from_utf8_lossy(&signature), trusted_key)?;
let manifest = Manifest::parse(&bytes)?;
// Legacy moving channels are pinned by matching their signed manifest to the immutable tag.
if matches!(&resolved, Source::Url(url) if matches!(url.trim_end_matches('/'), "https://github.com/Corfirean/coa-server-build/releases/download/stable" | "https://github.com/Corfirean/coa-server-build/releases/download/edge")) {
resolved = Source::Url(format!("https://github.com/Corfirean/coa-server-build/releases/download/server-{}/", manifest.version));
let immutable = fetch_small(&resolved, "manifest.json")?;
let sig = fetch_small(&resolved, "manifest.json.sig")?;
signing::verify(&immutable, &String::from_utf8_lossy(&sig), trusted_key)?;
if immutable != bytes { return Err(Error::InvalidManifest("Moving channel differs from its immutable release.".into())); }
bytes = immutable;
signature = sig;
}
if let Some(pointer) = expected {
if pointer.version != manifest.version || pointer.manifest_sha256 != fsx::sha256_bytes(&bytes) {
return Err(Error::InvalidManifest("Immutable release does not match the signed channel.".into()));
}
}
Ok(PinnedPackage { source: resolved, manifest, bytes, signature })
}
/// Read a small file (manifest, signature) from the source.
pub fn fetch_small(source: &Source, name: &str) -> Result<Vec<u8>> {
match source {
@@ -44,11 +117,8 @@ pub fn fetch_small(source: &Source, name: &str) -> Result<Vec<u8>> {
/// Download and verify the manifest. Returns the parsed manifest and its exact bytes.
pub fn fetch_manifest(source: &Source, trusted_key: &str) -> Result<(Manifest, Vec<u8>)> {
let bytes = fetch_small(source, "manifest.json")?;
let sig = String::from_utf8_lossy(&fetch_small(source, "manifest.json.sig")?).into_owned();
signing::verify(&bytes, &sig, trusted_key)?;
let manifest = Manifest::parse(&bytes)?;
Ok((manifest, bytes))
let pinned = fetch_package(source, trusted_key)?;
Ok((pinned.manifest, pinned.bytes))
}
/// Make every archive part available in a verified folder: a local source is used in place, a remote one is
+10 -20
View File
@@ -287,35 +287,25 @@ pub fn prepare_launcher(root: &Path) -> Result<()> {
Ok(())
}
const LAUNCHER_REALM_REPLACEMENTS: &[(&str, &str)] = &[
("(\"WorldDatabaseInfo\", \"acore_world\")", "(\"WorldDatabaseInfo\", \"acore_world_wildcard\" if coa_realm() == 'wildcard' else \"acore_world\")"),
("(\"CharacterDatabaseInfo\", \"acore_characters\")", "(\"CharacterDatabaseInfo\", \"acore_characters_wildcard\" if coa_realm() == 'wildcard' else \"acore_characters\")"),
("SET name='AzerothCore',address=", "SET name='{coa_realm_name()}',address="),
("WHERE id=1;", "WHERE id={coa_realm_id()};"),
("mysql(\"UPDATE acore_auth.realmlist SET flag=0", "mysql(f\"UPDATE acore_auth.realmlist SET flag=0"),
];
const LAUNCHER_REALM_INSERT: &str = "# coa-manager-realm-profiles-v1\ndef coa_realm():\n path = ROOT / 'Settings/realm-profile.json'\n return json.loads(path.read_text(encoding='utf-8')).get('active', 'coa') if path.exists() else 'coa'\n\ndef coa_realm_id():\n return 2 if coa_realm() == 'wildcard' else 1\n\ndef coa_realm_name():\n return 'Wildcard' if coa_realm() == 'wildcard' else 'Conquest of Azeroth'\n\n";
pub(crate) fn patch_launcher(source: &str) -> Result<String> {
if source.contains("# coa-manager-realm-profiles-v1") { return Ok(source.into()); }
let replacements = [
("(\"WorldDatabaseInfo\", \"acore_world\")", "(\"WorldDatabaseInfo\", \"acore_world_wildcard\" if coa_realm() == 'wildcard' else \"acore_world\")"),
("(\"CharacterDatabaseInfo\", \"acore_characters\")", "(\"CharacterDatabaseInfo\", \"acore_characters_wildcard\" if coa_realm() == 'wildcard' else \"acore_characters\")"),
("SET name='AzerothCore',address=", "SET name='{coa_realm_name()}',address="),
("WHERE id=1;", "WHERE id={coa_realm_id()};"),
("mysql(\"UPDATE acore_auth.realmlist SET flag=0", "mysql(f\"UPDATE acore_auth.realmlist SET flag=0"),
];
let mut out = source.to_string();
for &(from, to) in LAUNCHER_REALM_REPLACEMENTS {
for (from, to) in replacements {
if !out.contains(from) { return Err(Error::Invalid("This launcher does not support realm profiles. Update the server package first.".into())); }
out = out.replace(from, to);
}
let insert = "# coa-manager-realm-profiles-v1\ndef coa_realm():\n path = ROOT / 'Settings/realm-profile.json'\n return json.loads(path.read_text(encoding='utf-8')).get('active', 'coa') if path.exists() else 'coa'\n\ndef coa_realm_id():\n return 2 if coa_realm() == 'wildcard' else 1\n\ndef coa_realm_name():\n return 'Wildcard' if coa_realm() == 'wildcard' else 'Conquest of Azeroth'\n\n";
// Insert before the entry point so ROOT, json and functions are all defined when called.
let marker = "if __name__ == \"__main__\":";
if !out.contains(marker) { return Err(Error::Invalid("Unrecognised server launcher entry point.".into())); }
Ok(out.replace(marker, &format!("{LAUNCHER_REALM_INSERT}{marker}")))
}
/// Reverse only our exact realm transformation; callers must verify the recovered original hash.
pub(crate) fn unpatch_launcher(source: &str) -> Option<String> {
if !source.contains(LAUNCHER_REALM_INSERT) { return None; }
let mut original = source.replacen(LAUNCHER_REALM_INSERT, "", 1);
for &(from, to) in LAUNCHER_REALM_REPLACEMENTS { original = original.replace(to, from); }
patch_launcher(&original).ok().filter(|patched| patched == source).map(|_| original)
Ok(out.replace(marker, &format!("{insert}{marker}")))
}
pub fn before_start(root: &Path) -> Result<()> {
+5 -4
View File
@@ -13,6 +13,7 @@ use crate::package::{self, BuildOptions};
#[derive(Debug, Clone)]
pub struct SqlFile {
pub compatible_sha256: Vec<String>,
pub db: String,
pub id: String,
/// Path relative to the checkout it came from (used only for ordering and display).
@@ -49,7 +50,7 @@ pub fn collect_core_sql(core: &Path) -> Result<Vec<SqlFile>> {
let mut out = Vec::new();
let mut push = |db: &str, id: String, abs: PathBuf, origin: String| -> Result<()> {
let sha256 = fsx::sha256_file(&abs)?;
out.push(SqlFile { db: db.into(), id, origin, abs, sha256 });
out.push(SqlFile { compatible_sha256: vec![], db: db.into(), id, origin, abs, sha256 });
Ok(())
};
for (kind, dirs) in [("auth", ["db_auth", "pending_db_auth"]), ("characters", ["db_characters", "pending_db_characters"]), ("world", ["db_world", "pending_db_world"])] {
@@ -92,13 +93,13 @@ pub fn collect_bots_sql(bots: &Path) -> Result<Vec<SqlFile>> {
let mut out = Vec::new();
for f in sql_in(&bots.join("dist/sql")) {
let stem = f.file_stem().unwrap().to_string_lossy().into_owned();
out.push(SqlFile { db: "characters".into(), id: format!("mod_coa_playerbots__{stem}"), origin: format!("dist/sql/{stem}.sql"), sha256: fsx::sha256_file(&f)?, abs: f });
out.push(SqlFile { compatible_sha256: vec![], db: "characters".into(), id: format!("mod_coa_playerbots__{stem}"), origin: format!("dist/sql/{stem}.sql"), sha256: fsx::sha256_file(&f)?, abs: f });
}
Ok(out)
}
fn to_migrations(files: &[SqlFile]) -> Vec<Migration> {
files.iter().map(|f| Migration { compatible_sha256: vec![], id: f.id.clone(), db: f.db.clone(), sha256: f.sha256.clone(), destructive: false }).collect()
files.iter().map(|f| Migration { compatible_sha256: f.compatible_sha256.clone(), id: f.id.clone(), db: f.db.clone(), sha256: f.sha256.clone(), destructive: false }).collect()
}
pub struct UpdateParams<'a> {
@@ -226,7 +227,7 @@ mod tests {
write(&tree, "Core/newlib.dll", "n");
write(&tree, crate::schema_check::CONTRACT, "same contract");
write(&sqldir, "world.sql", "SELECT 1;");
let sql = vec![SqlFile { db: "world".into(), id: "m1".into(), origin: "x".into(), abs: sqldir.join("world.sql"), sha256: fsx::sha256_file(&sqldir.join("world.sql")).unwrap() }];
let sql = vec![SqlFile { compatible_sha256: vec![], db: "world".into(), id: "m1".into(), origin: "x".into(), abs: sqldir.join("world.sql"), sha256: fsx::sha256_file(&sqldir.join("world.sql")).unwrap() }];
let m = pack_update(&UpdateParams { tree: &tree, base_manifest: &base, sql: &sql, out: &upd_out, version: "1.1.0".into(), core_commit: Some("a".repeat(40)), bots_commit: Some("b".repeat(40)), part_size: 1 << 20 }, &|_| {}).unwrap();
let paths: Vec<&str> = m.files.iter().map(|f| f.path.as_str()).collect();
assert!(paths.contains(&"Core/worldserver.exe") && paths.contains(&"Core/newlib.dll"));
+2 -2
View File
@@ -16,7 +16,7 @@ pub fn collect(core: &Path, bots: Option<&Path>, repairs: Option<&Path>) -> Resu
paths.sort();
for path in paths.into_iter().filter(|p| p.extension().is_some_and(|e| e == "sql")) {
let stem = path.file_stem().unwrap().to_string_lossy();
files.push(SqlFile { db: kind.into(), id: format!("manager_repair__{stem}"), origin: format!("{kind}/{stem}.sql"), sha256: fsx::sha256_file(&path)?, abs: path });
files.push(SqlFile { compatible_sha256: vec![], db: kind.into(), id: format!("manager_repair__{stem}"), origin: format!("{kind}/{stem}.sql"), sha256: fsx::sha256_file(&path)?, abs: path });
}
}
}
@@ -47,7 +47,7 @@ pub fn capture_release(fixture: &Path, tree: &Path, sql: &[SqlFile]) -> Result<(
return Err(Error::Invalid("Refusing to apply release SQL to a non-fixture server.".into()));
}
let staging = tempfile::tempdir()?;
let migrations: Vec<_> = sql.iter().map(|f| Migration { compatible_sha256: vec![], db: f.db.clone(), id: f.id.clone(), sha256: f.sha256.clone(), destructive: false }).collect();
let migrations: Vec<_> = sql.iter().map(|f| Migration { compatible_sha256: f.compatible_sha256.clone(), db: f.db.clone(), id: f.id.clone(), sha256: f.sha256.clone(), destructive: false }).collect();
for file in sql {
let path = fsx::safe_join(staging.path(), &format!("{}/{}.sql", file.db, file.id))?;
fsx::atomic_write(&path, &std::fs::read(&file.abs)?)?;
File diff suppressed because it is too large. Load diff
+3
View File
@@ -7,4 +7,7 @@ license.workspace = true
[dependencies]
coa-core = { path = "../coa-core" }
serde_json = "1"
base64 = "0.22"
ed25519-dalek = "2"
tempfile = "3"
chrono = { version = "0.4", default-features = false, features = ["clock", "std"] }
+63 -2
View File
@@ -46,6 +46,65 @@ fn run() -> Result<(), String> {
let e = |x: coa_core::Error| x.to_string();
let part = a.get("part-size").and_then(|v| v.parse().ok()).unwrap_or(DEFAULT_PART_SIZE);
match cmd.as_str() {
"verify-registry" => {
let sql = coa_core::migration_registry::reconcile(&PathBuf::from(need(&a, "registry")?), Vec::new()).map_err(e)?;
println!("Verified {} historical migrations, order and signed byte variants", sql.len());
}
"resolve" => {
let package = coa_core::pkgsource::fetch_package(&coa_core::pkgsource::Source::Url(need(&a, "source")?.clone()), coa_core::signing::EMBEDDED_PUBLIC_KEY).map_err(e)?;
coa_core::fsx::atomic_write(&PathBuf::from(need(&a, "out")?), &package.bytes).map_err(e)?;
}
"extract-game-data" => {
let source = PathBuf::from(need(&a, "package")?);
let package = coa_core::pkgsource::fetch_package(&coa_core::pkgsource::Source::Dir(source.clone()), coa_core::signing::EMBEDDED_PUBLIC_KEY).map_err(e)?;
if !package.manifest.files.iter().any(|f| f.path.starts_with("Data/")) { return Err("Signed base has no game data.".into()); }
coa_core::package::extract_selected(&source, &package.manifest, &PathBuf::from(need(&a, "fixture")?), &|p| p.starts_with("Data/"), &|_, _| {}).map_err(e)?;
}
"repackage" => {
let source = PathBuf::from(need(&a, "package")?);
let pinned = coa_core::pkgsource::fetch_package(&coa_core::pkgsource::Source::Dir(source.clone()), coa_core::signing::EMBEDDED_PUBLIC_KEY).map_err(e)?;
let work = tempfile::tempdir().map_err(|e| e.to_string())?;
coa_core::package::extract(&source, &pinned.manifest, work.path(), &|_, _| {}).map_err(e)?;
let mut sql: Vec<_> = pinned.manifest.migrations.iter().map(|m| coa_core::release::SqlFile {
compatible_sha256: m.compatible_sha256.clone(), db: m.db.clone(), id: m.id.clone(), sha256: m.sha256.clone(), origin: "signed package".into(), abs: work.path().join("_migrations").join(&m.db).join(format!("{}.sql", m.id)),
}).collect();
let repairs = PathBuf::from(need(&a, "repairs")?);
for repair in coa_core::release_schema::collect(&work.path().join("no-core"), None, Some(&repairs)).map_err(e)? {
if !sql.iter().any(|m| m.db == repair.db && m.id == repair.id) { sql.push(repair); }
}
let sql = coa_core::migration_registry::reconcile(&PathBuf::from(need(&a, "registry")?), sql).map_err(e)?;
let migrations = sql.iter().map(|m| coa_core::manifest::Migration { compatible_sha256: m.compatible_sha256.clone(), db: m.db.clone(), id: m.id.clone(), sha256: m.sha256.clone(), destructive: false }).collect();
for file in &sql { coa_core::fsx::atomic_write(&work.path().join("_migrations").join(&file.db).join(format!("{}.sql", file.id)), &std::fs::read(&file.abs).map_err(|e| e.to_string())?).map_err(e)?; }
let out = PathBuf::from(need(&a, "out")?);
let opts = BuildOptions { kind: Kind::Update, version: need(&a, "version")?.clone(), core_commit: pinned.manifest.core.commit, bots_commit: pinned.manifest.bots.and_then(|b| b.commit), built_at: chrono_now(), part_size: part, migrations };
let mut manifest = build(work.path(), &out, &opts, &|s| eprintln!("{s}")).map_err(e)?;
manifest.min_manager_version = coa_core::MANAGER_VERSION.into();
coa_core::fsx::atomic_write_json(&out.join("manifest.json"), &manifest).map_err(e)?;
}
"archive-migrations" => {
coa_core::migration_registry::import(&PathBuf::from(need(&a, "package")?), &PathBuf::from(need(&a, "registry")?), coa_core::signing::EMBEDDED_PUBLIC_KEY).map_err(e)?;
println!("Published migration bytes and compatibility archived");
}
"verify-channel" => {
let pointer = coa_core::pkgsource::verify_channel(&std::fs::read(need(&a, "file")?).map_err(|e| e.to_string())?, coa_core::signing::EMBEDDED_PUBLIC_KEY).map_err(e)?;
let dir = PathBuf::from(need(&a, "dir")?);
let manifest: Manifest = coa_core::fsx::read_json(&dir.join("manifest.json")).map_err(e)?;
if manifest.version != pointer.version || coa_core::fsx::sha256_file(&dir.join("manifest.json")).map_err(e)? != pointer.manifest_sha256 || pointer.acceptance_sha256.as_deref() != Some(&coa_core::fsx::sha256_file(&dir.join("acceptance.json")).map_err(e)?) {
return Err("Signed channel differs from the tested package/report".into());
}
}
"channel" => {
use base64::{engine::general_purpose::STANDARD, Engine};
use ed25519_dalek::{Signer, SigningKey};
let dir = PathBuf::from(need(&a, "dir")?);
let pinned = coa_core::pkgsource::fetch_package(&coa_core::pkgsource::Source::Dir(dir.clone()), coa_core::signing::EMBEDDED_PUBLIC_KEY).map_err(e)?;
let pointer = coa_core::pkgsource::Channel { schema: 1, version: pinned.manifest.version.clone(), release: format!("https://github.com/Corfirean/coa-server-build/releases/download/server-{}/", pinned.manifest.version), manifest_sha256: coa_core::fsx::sha256_bytes(&pinned.bytes), acceptance_sha256: Some(coa_core::fsx::sha256_file(&dir.join("acceptance.json")).map_err(e)?) };
let payload = serde_json::to_vec(&pointer).map_err(|e| e.to_string())?;
let seed: [u8; 32] = STANDARD.decode(signing_key()?.trim()).map_err(|e| e.to_string())?.try_into().map_err(|_| "Wrong signing key length")?;
let signed = coa_core::pkgsource::SignedChannel { payload: STANDARD.encode(&payload), signature: STANDARD.encode(SigningKey::from_bytes(&seed).sign(&payload).to_bytes()) };
coa_core::signing::verify_embedded(&payload, &signed.signature).map_err(e)?;
coa_core::fsx::atomic_write_json(&PathBuf::from(need(&a, "out")?), &signed).map_err(e)?;
}
"extract-schema-base" => {
coa_core::release_schema::extract_base(
&PathBuf::from(need(&a, "package")?), &PathBuf::from(need(&a, "fixture")?),
@@ -59,7 +118,8 @@ fn run() -> Result<(), String> {
if let Some(core) = a.get("core") {
let bots = a.get("bots").map(PathBuf::from);
let repairs = a.get("repairs").map(PathBuf::from);
let sql = coa_core::release_schema::collect(&PathBuf::from(core), bots.as_deref(), repairs.as_deref()).map_err(e)?;
let mut sql = coa_core::release_schema::collect(&PathBuf::from(core), bots.as_deref(), repairs.as_deref()).map_err(e)?;
if let Some(registry) = a.get("registry") { sql = coa_core::migration_registry::reconcile(&PathBuf::from(registry), sql).map_err(e)?; }
coa_core::release_schema::capture_release(&repack, &tree, &sql).map_err(e)?;
} else {
coa_core::backup::with_database(&repack, |db| coa_core::schema_check::capture(db, &tree)).map_err(e)?;
@@ -77,7 +137,8 @@ fn run() -> Result<(), String> {
coa_core::schema_check::require_release_contract(&PathBuf::from(need(&a, "tree")?)).map_err(e)?;
let bots = a.get("bots").map(PathBuf::from);
let repairs = a.get("repairs").map(PathBuf::from);
let sql = coa_core::release_schema::collect(&PathBuf::from(need(&a, "core")?), bots.as_deref(), repairs.as_deref()).map_err(e)?;
let mut sql = coa_core::release_schema::collect(&PathBuf::from(need(&a, "core")?), bots.as_deref(), repairs.as_deref()).map_err(e)?;
if let Some(registry) = a.get("registry") { sql = coa_core::migration_registry::reconcile(&PathBuf::from(registry), sql).map_err(e)?; }
let out = PathBuf::from(need(&a, "out")?);
let m = pack_update(
&UpdateParams { tree: &PathBuf::from(need(&a, "tree")?), base_manifest: &base, sql: &sql, out: &out, version: need(&a, "version")?.clone(), core_commit: a.get("core-commit").cloned(), bots_commit: a.get("bots-commit").cloned(), part_size: part },
+94
View File
@@ -0,0 +1,94 @@
# Reliable updates and Windows acceptance
An operation resolves one signed manifest and immutable release before downloading its
archive. The same verified bytes are used for the private trial and the real application.
The installation lock covers stop, snapshot, trial, application, validation and recovery.
Native Windows installations with the bundled Python and MySQL runtime are supported;
Docker and unrecognised launchers are rejected before applying files.
The manager measures the installation and database directories, checks free space and
allocates recovery reserves. The private copy contains independent runtime, configuration,
game-data and database files. It imports the verified original recovery point, runs the
candidate SQL and uses loopback ports for startup. The known launcher reporting relay is
disabled during validation. No junctions or hardlinks are created.
Transactions keep the exact manifest hash, original running state, protected generated
files, database recovery point and individual file operations. SQL has its own migration
ledger. Stop, snapshot and trial have separate durable states. The original failure stage
is retained when the current state changes to recovery or recovered.
Interrupted SQL is restored, never automatically repeated. Windows file replacement
uses a synced temporary file and MoveFileExW with WRITE_THROUGH, including long paths.
Recovery is repeatable and does not require backing up the damaged state. Corrupt journals
or snapshots block startup and preserve available copies.
Recovery verifies the original dump before importing it into a private recovery schema,
then compares the live database with a deterministic dump of that schema. This accounts
for MySQL's normalisation of character-set declarations while checking schema and rows.
Configuration backups carry individual content hashes. Legacy update snapshots without
those hashes require manual inspection rather than an unverified automatic restore.
Database dumps and configuration copies are flushed to disk before the snapshot is usable.
A committed operation interrupted before admission
resumes startup without undoing the committed database. Diagnostic JSON is saved locally;
database passwords are removed and reports leave the machine only through explicit export.
## Migration publication
`coa-release archive-migrations --package DIR --registry DIR` verifies the released
signature and preserves original SQL bytes, fixed order, hashes and signed provenance.
Only byte variants differing in UTF-8 BOM or line endings can share an ID. Other changes
fail the build and need a new migration ID. Compatibility hashes are included in the signed
manifest, leaving existing ledger checksums unchanged.
Published packages use `server-VERSION` releases. Channels contain one signed envelope;
it binds the immutable manifest and acceptance report hashes. Stable is switched only
after package verification and acceptance. Never replace assets of an existing immutable
release or rewrite historical registry SQL.
## Disposable acceptance fixture
Run `tools/update-chaos-gate.ps1 -BasePackage DIR -CandidatePackage DIR -Target NEW_PATH`
on Windows. NEW_PATH must start with `coa-schema-fixture-chaos-`; the harness creates
both disposable markers itself. Base and candidate signatures are required. The harness
extracts game data independently and seeds an account, character and inventory item.
Optional `-DataSource DIR` reads an existing game-data folder without modifying it.
Crash injection is compiled only with `coa-core/testkit` and additionally requires the
disposable marker. `COA_UPDATE_CRASH_AT` terminates the test process with exit 91 at a
named checkpoint. Production builds do not enable this mechanism. The harness exercises
file journaling, SQL phases, commit and repeated recovery interruption. Backups and failed
trial copies remain available for diagnosis.
The release jobs must run on a Windows worker with enough free space for the actual
signed base, private copy, full snapshots and recovery reserves. Insufficient space is a
test failure, not permission to bypass acceptance.
The workflows require a dedicated runner labelled `coa-update-acceptance` (Windows,
X64). Provision at least 300 GB of free workspace and 16 GB of RAM for the retained
ten-scenario matrix, plus the normal Rust/Tauri build prerequisites. The timeout is
24 hours: full snapshot, import and recovery checks take minutes per injected fault.
A default hosted runner's disk and four-hour budget are insufficient for this gate.
`tools/update-chaos-matrix.ps1` runs separate fixtures for CoA, Wildcard, both worlds,
SQUID and imported installations. With `-PreviousPackage`, it also runs each mode from
that signed previous release. Its acceptance report binds every scenario to the same
candidate manifest hash and manager source commit. Publication requires all ten scenarios.
It also requires every mandatory fault class in each scenario's coverage record. Missing
coverage produces an `incomplete` report and fails publication. The current harness still
lacks real disk exhaustion, denied writes, database-child and new-server crash coverage,
OS network containment and coverage of every file-operation phase.
The gate includes real occupied ports and locked files, a Python startup failure, and SQL
that creates and populates a table before failing. These faults must preserve seeded
accounts, characters and inventory in every applicable database.
Validation currently isolates listeners on loopback and disables the recognised reporting
relay. It does not enforce an operating-system firewall against arbitrary outbound actions
in custom binaries; additional network containment is required for that release criterion.
## Release acceptance still required
Unit tests and compilation do not establish the full release criterion. Record results
for exact package and installer hashes, previous supported releases and skipped versions,
CoA/Wildcard/both/SQUID, imported repacks and modified configurations. Exercise occupied
ports/files, partial DDL, disk exhaustion, write errors, corrupt packages/journals/backups,
Python failure and server crashes. Verify schema, all player data, migration history,
metadata and startup after every injected failure. A passing subset must not be described
as completion of this matrix or as a guarantee against all possible failures.
+61
View File
@@ -0,0 +1,61 @@
# Local update validation, 2026-10-05
These results are a partial validation record, not a release acceptance report.
Tests use the independently copied, doubly marked disposable fixture
`C:\games\coa-schema-fixture-chaos-20261005-v1`. User installations are not modified.
Candidate: `0.261005.24`, signed manifest SHA-256
`1284b1273815209c9621b6d173a2211bae316f33462ccbe8b578e53b8d26fb5b`.
Published migration provenance was verified for `0.261005.0` and `0.261005.22`.
Their disputed repair differs only by line endings; both published hashes are retained.
Completed real-runtime checks:
- Base-to-candidate update, isolated trial, SQL, startup and commit.
- Repeat candidate application without replaying applied migrations.
- CoA and Wildcard together, including both world processes and player databases.
- Hard process termination after stop and after corrective SQL.
- Repeated recovery interruption after database restoration, followed by successful recovery.
- Occupied world port and exclusively locked configuration-default file, rejected before stop.
- Partial DDL and inserted data followed by invalid SQL in the live corrective migration.
Automatic rollback completed and removed the injected table.
- Bundled Python failure during live startup after a successful private two-world trial.
Automatic recovery passed exact pre-operation file and installation-metadata hashes,
restored all six databases, and preserved seeded accounts, characters and inventory.
- Modified user template values survived recovery. The fixture changes the template,
not the launcher-generated active file; this corrected an initial harness assertion.
- A modified manifest with its original signature was rejected before application.
- Hard termination immediately after recording a complete snapshot, followed by separately
corrupted transaction JSON and compressed character database archive. Both recovery
attempts refused without starting services or changing the world executable/installation
metadata. After removing the injected corruption, rollback completed and preserved the
seeded accounts, characters and inventory in both worlds.
- A live Python failure with both worlds originally running restored their ready state,
all six databases, player data, configuration and installation metadata. An initial
strict comparison exposed realm-profile regeneration after restart; the final protection
pass was corrected and the real-runtime case passed on repetition. Test processes were
explicitly stopped after verification.
Checks compare restored database content and preserve a seeded account, character and
inventory item in each applicable realm. Recovery also checks original file hashes and
installation metadata. The core unit suite passed 260 tests; frontend build and translation
validation passed. Changes after these runs require the relevant checks again.
The full 260-test run used `--test-threads=1`. A parallel run during native database
recovery encountered connection resets in two existing RA socket tests; those failures
are recorded rather than treated as update failures or hidden by the passing rerun.
Not yet established: the complete five-mode, base/previous-release Windows matrix;
published installer execution against fixtures; actual disk exhaustion and denied writes;
database-child termination during table swaps; every individual file mutation checkpoint;
operating-system containment of arbitrary external actions. Publication must stay blocked
until the required matrix and remaining release invariants have been demonstrated.
The matrix report now explicitly records fault coverage. Missing mandatory fault classes
produce an `incomplete` report and fail the gate, even when every scenario that was executed
passed. Disk exhaustion, denied writes, database-child and new-server crashes,
network containment and all file-operation phases still require actual evidence. Snapshot
corruption guards now have real-runtime coverage. The later backup-metadata hash and
backup-retention guards require their own runtime injection checks before release.
Infrastructure inspection found zero registered repository runners for both projects.
The dedicated Windows acceptance runner must be provisioned before these workflows can run.
+3
View File
@@ -0,0 +1,3 @@
[toolchain]
channel = "1.98.1"
profile = "minimal"
+27 -11
View File
@@ -697,7 +697,28 @@ async fn check_update(state: State<'_, AppState>, id: String, source: Option<Str
#[tauri::command]
fn pending_update(state: State<'_, AppState>, id: String) -> std::result::Result<Option<update::Txn>, UiError> {
let root = path_of(&state, &id)?;
Ok(update::pending_checked(&meta_dir(&root)?)?)
let dir = meta_dir(&root)?;
let latest = update::latest(&dir)?;
Ok(update::unfinished(&dir).or_else(|| latest.filter(|t| t.state == update::State::Committed && t.server_stopped)))
}
#[tauri::command]
async fn recover_update(state: State<'_, AppState>, id: String) -> std::result::Result<Option<update::Txn>, UiError> {
let root = path_of(&state, &id)?;
let _guard = BusyGuard::acquire(&state, &id)?;
blocking(move || update::recover(&root, &meta_dir(&root)?)).await.map_err(UiError::from)
}
#[tauri::command]
fn last_update(state: State<'_, AppState>, id: String) -> std::result::Result<Option<update::Txn>, UiError> {
let root = path_of(&state, &id)?;
Ok(update::latest(&meta_dir(&root)?)?)
}
#[tauri::command]
fn last_update_result(state: State<'_, AppState>, id: String) -> std::result::Result<Option<update::ExecutionResult>, UiError> {
let root = path_of(&state, &id)?;
Ok(update::last_execution_result(&meta_dir(&root)?)?)
}
#[tauri::command]
@@ -707,22 +728,14 @@ async fn apply_update(
id: String,
source: Option<String>,
resolutions: BTreeMap<String, Resolution>,
) -> std::result::Result<update::Outcome, UiError> {
) -> std::result::Result<update::ExecutionResult, UiError> {
let root = path_of(&state, &id)?;
let src = update_source(source);
let _guard = BusyGuard::acquire(&state, &id)?;
blocking(move || {
let (dir, _) = install_meta(&root)?;
// Files cannot be replaced while the server runs: stop it first (gracefully), like the Stop button.
let observed = coa_core::process::observe(&root, &layout::read_ports(&root));
if observed.world.state != coa_core::process::ServiceState::Stopped || observed.auth.state != coa_core::process::ServiceState::Stopped || coa_core::multiworld::is_running(&root) {
let out = driver::run(&root, Verb::StopAll)?;
if !out.ok {
return Err(Error::Invalid("The server could not be stopped, so the update was not started.".into()));
}
}
let env = update::RepackEnv { root: &root, meta_dir: &dir };
update::apply(
update::execute(
&update::Params { root: &root, meta_dir: &dir, source: src, trusted_key: coa_core::signing::EMBEDDED_PUBLIC_KEY, cancel: Cancel::default(), resolutions, env: &env, fail_after_ops: None },
&|step, percent| {
let _ = app.emit("update-progress", serde_json::json!({ "step": step, "percent": percent }));
@@ -1569,6 +1582,9 @@ pub fn run() {
create_account,
check_update,
pending_update,
recover_update,
last_update,
last_update_result,
apply_update,
rollback_update,
retry_update_validation,
+3 -2
View File
@@ -46,8 +46,9 @@ export {};
if(cmd==="preview_preset"){const a=args;const sc=a.scope==="server"?serverSchema:botsSchema;const pr=(a.scope==="server"?serverPresets:botsPresets).presets as any[];const p=pr.find(x=>x.id===a.preset)??{id:a.preset??"defaults",title:"Recommended defaults",description:"Every setting returns to its default value."};const st=(sc.settings as any[]).filter(x=>x.type==="int"||x.type==="float"||x.type==="enum").slice(0,3);return {id:p.id,title:p.title,description:p.description,changes:st.map(x=>({key:x.key,title:x.title,from:x.default,to:x.type==="enum"?(x.options?.[1]?.value??x.default):(Number(x.default)||1)*2,dangerous:false}))};}
if(cmd==="companion_sizes") return {hardware:{cores:16,ram_gb:31,free_ram_gb:12},sizes:[{id:"small",title:"Small",bots:50,warning:null},{id:"medium",title:"Medium",bots:250,warning:null},{id:"large",title:"Large",bots:500,warning:"500 companions may need more CPU and memory than this computer has (8 cores, 16 GB)."}]};
if(cmd==="add_companions"){const base=(window as any).__bots??85;(window as any).__target=base+args.count;return {spawned:"queued",created:null,baseline:base};}
if(cmd==="check_update") return {from_version:(window as any).__updated?"0.261001.8":"0.260930.5",to_version:"0.261001.8",items:[],conflicts:[],migrations:5,pending_migrations:(window as any).__updated?0:5,download_bytes:6000000};
if(cmd==="apply_update"){const w=window as any;for(let i=1;i<=8;i++){await new Promise((r: any)=>setTimeout(r,700));(w.__handlers?.["update-progress"]??[]).forEach((h: any)=>h({event:"update-progress",id:1,payload:{step:i<4?"Downloading the update":i<7?"Applying the update":"Finishing",percent:i*12}}));}(window as any).__updated=true;return {txn:{state:"committed",to_version:"0.261001.8"},migrations:null};}
if(cmd==="check_update") return {from_version:(window as any).__updated?"0.261001.8":"0.260930.5",to_version:"0.261001.8",items:[],conflicts:[],migrations:5,download_bytes:6000000};
if(cmd==="apply_update"){const w=window as any;for(let i=1;i<=8;i++){await new Promise((r: any)=>setTimeout(r,700));(w.__handlers?.["update-progress"]??[]).forEach((h: any)=>h({event:"update-progress",id:1,payload:{step:i<4?"Downloading the update":i<7?"Applying the update":"Finishing",percent:i*12}}));}(window as any).__updated=true;return {disposition:"updated",txn:{state:"committed",to_version:"0.261001.8"},message:null};}
if(cmd==="pending_update" || cmd==="last_update" || cmd==="last_update_result" || cmd==="recover_update") return null;
if(cmd==="get_population"){if(!running) return null;let b=(window as any).__bots??85;const t=(window as any).__target??0;if(t>b){b=Math.min(t,b+25);(window as any).__bots=b;}return {online_total:b,bots_online:Math.max(0,b-7),players_online:0,bots_total:b};}
if(cmd==="get_performance") return running?{mean_ms:14,median_ms:15,p95_ms:24,p99_ms:30,max_ms:61,ticks_per_sec:71.4}:null;
if(cmd==="run_diagnostics") return {problems:2,checks:[{id:"files",title:"Server files",level:"ok",detail:"All expected server parts were found."},{id:"world",title:"World server",level:"warn",detail:"Not running."},{id:"disk",title:"Free disk space",level:"warn",detail:"Only 3 GB free; backups and updates need room."},{id:"exposure",title:"Private services",level:"ok",detail:"Database and server console are not reachable from the network."}]};
+1
View File
@@ -371,6 +371,7 @@ const de: Partial<Record<keyof typeof en, string>> = {
"upd.backNote": "Die Rückkehr stellt Dateien und Einstellungen wieder her. Wurden Datenbankupdates begonnen, werden auch alle Datenbanken aus der Sicherung vor dem Update wiederhergestellt. Späterer Fortschritt geht verloren.",
"upd.goBackTo": "Zu Version {v} zurückkehren",
"upd.goBackBefore": "Zur Version vor dem Update zurückkehren",
"upd.autoRestored": "Die Aktualisierung ist fehlgeschlagen. Der vorherige Server wurde automatisch wiederhergestellt.",
"upd.title": "Server-Updates",
"upd.text": "Updates werden auf Echtheit geprüft, vorher gesichert und können rückgängig gemacht werden.",
"upd.check": "Nach Updates suchen",
+1
View File
@@ -404,6 +404,7 @@ const en = {
"upd.backNote": "Going back restores files and settings. If database updates started, it also restores all databases to the backup taken before the update. Later progress will be lost.",
"upd.goBackTo": "Go back to version {v}",
"upd.goBackBefore": "Go back to the version before the update",
"upd.autoRestored": "The update failed validation. Your previous server was restored automatically.",
"upd.title": "Server updates",
"upd.text": "Updates are checked for authenticity, backed up first, and can be undone.",
"upd.check": "Check for updates",
+1
View File
@@ -371,6 +371,7 @@ const es: Partial<Record<keyof typeof en, string>> = {
"upd.backNote": "Volver restaura los archivos y los ajustes. Si comenzaron las actualizaciones de las bases de datos, también se restauran todas las bases desde la copia anterior a la actualización. Se perderá el progreso posterior.",
"upd.goBackTo": "Volver a la versión {v}",
"upd.goBackBefore": "Volver a la versión anterior a la actualización",
"upd.autoRestored": "La actualización falló. El servidor anterior se restauró automáticamente.",
"upd.title": "Actualizaciones del servidor",
"upd.text": "Las actualizaciones se comprueban, se respaldan antes y se pueden deshacer.",
"upd.check": "Buscar actualizaciones",
+1
View File
@@ -371,6 +371,7 @@ const fr: Partial<Record<keyof typeof en, string>> = {
"upd.backNote": "Le retour restaure les fichiers et les paramètres. Si la mise à jour des bases a commencé, toutes les bases sont aussi restaurées depuis la sauvegarde précédant la mise à jour. La progression ultérieure sera perdue.",
"upd.goBackTo": "Revenir à la version {v}",
"upd.goBackBefore": "Revenir à la version d’avant la mise à jour",
"upd.autoRestored": "La mise à jour a échoué. Le serveur précédent a été restauré automatiquement.",
"upd.title": "Mises à jour du serveur",
"upd.text": "Les mises à jour sont vérifiées, sauvegardées au préalable et peuvent être annulées.",
"upd.check": "Rechercher des mises à jour",
+1
View File
@@ -402,6 +402,7 @@ const ru: Partial<Record<keyof typeof en, string>> = {
"upd.backNote": "Возврат восстанавливает файлы и настройки. Если обновление баз уже началось, все базы также восстанавливаются из копии перед обновлением. Более поздний прогресс будет потерян.",
"upd.goBackTo": "Вернуться к версии {v}",
"upd.goBackBefore": "Вернуться к версии до обновления",
"upd.autoRestored": "Обновление не прошло проверку. Прежний сервер автоматически восстановлен.",
"upd.title": "Обновления сервера",
"upd.text": "Подлинность обновлений проверяется, перед ними делается резервная копия, и их можно отменить.",
"upd.check": "Проверить обновления",
+1
View File
@@ -383,6 +383,7 @@ const zh = {
"upd.backNote": "回滚将恢复文件和设置。如果数据库更新已开始,所有数据库也将从更新前的备份恢复。之后的进度将丢失。",
"upd.goBackTo": "回滚至版本 {v}",
"upd.goBackBefore": "回滚至更新前的版本",
"upd.autoRestored": "更新验证失败。之前的服务器已自动恢复。",
"upd.title": "服务器更新",
"upd.text": "更新均经过真实性签名校验,并在执行前自动备份,随时可安全撤销。",
"upd.check": "检查更新",
+17 -3
View File
@@ -95,6 +95,12 @@ export interface UiError {
fields?: FieldError[];
}
export interface UpdateExecutionResult {
disposition: "updated" | "rejected" | "restored" | "recovery-required";
txn: UpdateTxn | null;
message: string | null;
}
export type Scope = "bots" | "server";
export type Restart = "runtime" | "world" | "full";
export type JsonValue = string | number | boolean;
@@ -270,18 +276,23 @@ export interface UpdatePreview {
items: UpdatePlanItem[];
conflicts: string[];
migrations: number;
pending_migrations?: number;
download_bytes: number;
}
export interface UpdateTxn {
id: string;
state: "prepared" | "applying" | "applied" | "needs-decision" | "committed" | "rolled-back" | "failed";
state: "prepared" | "stopping" | "snapshotting" | "trialing" | "applying" | "applied" | "migrating" | "validating" | "committing" | "restoring" | "needs-decision" | "committed" | "rolled-back" | "failed";
failure_stage?: UpdateTxn["state"];
from_version: string | null;
to_version: string;
recovery_point: string | null;
databases_started: boolean;
message: string | null;
outcome?: "updated" | "rejected" | "restored" | "recovery-required" | null;
manifest_sha256?: string | null;
was_running?: boolean;
recovery_verified?: boolean;
trial_completed?: boolean;
}
export interface Population {
@@ -430,8 +441,11 @@ export const api = {
invoke<void>("create_account", { id, username, password, administrator }),
checkUpdate: (id: string, source?: string) => invoke<UpdatePreview>("check_update", { id, source: source ?? null }),
pendingUpdate: (id: string) => invoke<UpdateTxn | null>("pending_update", { id }),
lastUpdate: (id: string) => invoke<UpdateTxn | null>("last_update", { id }),
recoverUpdate: (id: string) => invoke<UpdateTxn | null>("recover_update", { id }),
applyUpdate: (id: string, resolutions: Record<string, "keep" | "replace">, source?: string) =>
invoke<{ txn: UpdateTxn }>("apply_update", { id, source: source ?? null, resolutions }),
invoke<UpdateExecutionResult>("apply_update", { id, source: source ?? null, resolutions }),
lastUpdateResult: (id: string) => invoke<UpdateExecutionResult | null>("last_update_result", { id }),
rollbackUpdate: (id: string, txn: string) => invoke<UpdateTxn>("rollback_update", { id, txn }),
retryUpdateValidation: (id: string, txn: string) => invoke<UpdateTxn>("retry_update_validation", { id, txn }),
population: (id: string) => invoke<Population | null>("get_population", { id }),
+29 -30
View File
@@ -1,7 +1,6 @@
import { useSyncExternalStore } from "react";
import { listen } from "@tauri-apps/api/event";
import { api, asUiError, type UiError, type UpdatePreview, type UpdateTxn } from "@/lib/api";
import { isUpdateCurrent } from "./serverUpdateStatus";
/**
* Server update status for the main screen and the navigation: checked when the app starts and every five minutes,
@@ -17,13 +16,11 @@ export interface ServerUpdateState {
error: string | null;
/** The full error of the last update attempt, for the Settings card. */
uiError: UiError | null;
stateError: UiError | null;
stateRevision: number;
/** How the last update ended; kept here so the Settings card can show it after the user left and came back. */
result: { committed: string } | { pending: UpdateTxn } | null;
result: { committed: string } | { pending: UpdateTxn } | { recovered: UpdateTxn } | null;
}
const EMPTY: ServerUpdateState = { preview: null, available: false, checking: false, applying: false, step: null, percent: 0, error: null, uiError: null, stateError: null, stateRevision: 0, result: null };
const EMPTY: ServerUpdateState = { preview: null, available: false, checking: false, applying: false, step: null, percent: 0, error: null, uiError: null, result: null };
const states = new Map<string, ServerUpdateState>();
const listeners = new Set<() => void>();
export const CHECK_EVERY_MS = 5 * 60 * 1000;
@@ -40,10 +37,10 @@ export async function checkServerUpdate(id: string): Promise<void> {
set(id, { checking: true });
try {
const p = await api.checkUpdate(id);
set(id, { preview: p, available: !isUpdateCurrent(p), error: null });
set(id, { preview: p, available: p.to_version !== (p.from_version ?? ""), error: null });
} catch (e) {
// A cached offer is no longer safe after an update or failed recheck.
set(id, { preview: null, available: false, error: asUiError(e).human.code });
// offline or no package published: keep what we knew and stay quiet
set(id, { error: asUiError(e).human.code });
} finally {
set(id, { checking: false });
}
@@ -51,7 +48,21 @@ export async function checkServerUpdate(id: string): Promise<void> {
/** Check now and then every five minutes. Returns the function that stops it. */
export function startServerUpdatePolling(id: string): () => void {
void checkServerUpdate(id);
void (async () => {
try {
const pending = await api.pendingUpdate(id);
if (pending) {
set(id, { applying: true, step: "Recovering the interrupted update", result: null });
const recovered = await api.recoverUpdate(id);
if (recovered) set(id, { result: recovered.state === "committed" ? { committed: recovered.to_version } : { recovered } });
}
} catch (e) {
const ui = asUiError(e);
set(id, { error: ui.human.code, uiError: ui });
return;
} finally { set(id, { applying: false, step: null }); }
await checkServerUpdate(id);
})();
const t = setInterval(() => void checkServerUpdate(id), CHECK_EVERY_MS);
return () => clearInterval(t);
}
@@ -60,20 +71,6 @@ export function clearServerUpdateResult(id: string) {
set(id, { result: null, uiError: null });
}
export async function refreshServerUpdateState(id: string): Promise<UpdateTxn | null> {
try {
const pending = await api.pendingUpdate(id);
const current = get(id).result;
set(id, { stateError: null, stateRevision: get(id).stateRevision + 1,
...(pending ? { available: false, preview: null } : {}),
result: pending ? { pending } : current && "committed" in current ? current : null });
return pending;
} catch (e) {
set(id, { stateError: asUiError(e), stateRevision: get(id).stateRevision + 1, available: false, preview: null });
throw e;
}
}
/**
* Apply an update. Without options this is the main-screen button: the pending update, only when no file needs a
* decision. With options (the Settings card) the owner has already chosen what to do with each changed file and may
@@ -82,8 +79,7 @@ export async function refreshServerUpdateState(id: string): Promise<UpdateTxn |
*/
export async function applyServerUpdate(id: string, opts?: { choices: Record<string, "keep" | "replace">; source?: string }): Promise<boolean> {
const p = get(id).preview;
const current = get(id);
if (current.applying || current.stateError || (current.result && "pending" in current.result)) return false;
if (get(id).applying) return false;
if (!opts && (!p || p.conflicts.length > 0)) return false;
set(id, { applying: true, step: null, percent: 0, error: null, uiError: null, result: null });
let un: (() => void) | undefined;
@@ -94,17 +90,20 @@ export async function applyServerUpdate(id: string, opts?: { choices: Record<str
}
try {
const out = await api.applyUpdate(id, opts?.choices ?? {}, opts?.source);
set(id, { result: out.txn.state === "committed" ? { committed: out.txn.to_version ?? "" } : { pending: out.txn } });
return true;
if (out.disposition === "updated" && out.txn) {
set(id, { result: { committed: out.txn.to_version } });
return true;
}
if (out.txn) set(id, { result: out.disposition === "restored" ? { recovered: out.txn } : { pending: out.txn } });
const ui = asUiError(out.message ?? out.disposition);
set(id, { error: ui.human.code, uiError: ui });
return false;
} catch (e) {
const ui = asUiError(e);
set(id, { error: ui.human.code, uiError: ui });
return false;
} finally {
un?.();
try {
await refreshServerUpdateState(id);
} catch { /* The state error remains visible and prevents another apply. */ }
set(id, { applying: false });
void checkServerUpdate(id);
}
-7
View File
@@ -1,7 +0,0 @@
import type { UpdatePreview } from "./api";
export function isUpdateCurrent(preview: UpdatePreview): boolean {
return preview.from_version === preview.to_version
&& preview.items.every((item) => item.action === "skip")
&& (preview.pending_migrations ?? (preview.migrations === 0 ? 0 : undefined)) === 0;
}
+30 -45
View File
@@ -1,8 +1,7 @@
import { useEffect, useState } from "react";
import { open } from "@tauri-apps/plugin-dialog";
import { ChevronDown, ChevronRight, Loader2 } from "lucide-react";
import { applyServerUpdate, clearServerUpdateResult, refreshServerUpdateState, useServerUpdate } from "@/lib/serverUpdate";
import { isUpdateCurrent } from "@/lib/serverUpdateStatus";
import { applyServerUpdate, clearServerUpdateResult, useServerUpdate } from "@/lib/serverUpdate";
import { api, asUiError, type UiError, type UpdatePreview, type UpdateTxn } from "@/lib/api";
import { Button } from "@/components/ui/button";
import { Card } from "@/components/ui/card";
@@ -24,14 +23,12 @@ export function SettingsHome({ serverId }: { serverId: string }) {
const human = useHuman();
const [preview, setPreview] = useState<UpdatePreview | null>(null);
const [pending, setPending] = useState<UpdateTxn | null>(null);
const [pendingChecked, setPendingChecked] = useState(false);
const [pendingStateError, setPendingStateError] = useState<UiError | null>(null);
const [localBusy, setBusy] = useState<"check" | "rollback" | "retry" | null>(null);
// an update keeps running in the background when this tab is left, so its state is the shared one
const busy = upd.applying ? "update" : localBusy;
const progress = upd.applying ? { step: upd.step ?? "Starting", percent: upd.percent } : null;
const [localError, setError] = useState<UiError | null>(null);
const error = pendingStateError ?? localError ?? upd.uiError;
const error = localError ?? upd.uiError;
const [localDone, setDone] = useState<string | null>(null);
const done = upd.result && "committed" in upd.result ? t("upd.updatedTo", { v: upd.result.committed }) : localDone;
const [choices, setChoices] = useState<Record<string, "keep" | "replace">>({});
@@ -39,36 +36,27 @@ export function SettingsHome({ serverId }: { serverId: string }) {
const [source, setSource] = useState("");
useEffect(() => {
let active = true;
setPendingChecked(false);
setPending(null);
setPreview(null);
setPendingStateError(null);
void api.pendingUpdate(serverId).then((txn) => {
if (active) { setPending(txn); setPendingChecked(true); }
}).catch((e) => { if (active) setPendingStateError(asUiError(e)); });
return () => { active = false; };
void api.pendingUpdate(serverId).then(setPending).catch((e) => setError(asUiError(e)));
void api.lastUpdateResult(serverId).then(async (result) => {
const txn = result?.txn ?? await api.lastUpdate(serverId);
if (result?.disposition === "rejected" || result?.disposition === "recovery-required") {
setDone(null);
if (result.message) setError(asUiError(result.message));
} else if (txn?.outcome === "restored" && txn.recovery_verified) setDone(t("upd.autoRestored"));
else if (result?.disposition === "updated" && txn) setDone(t("upd.updatedTo", { v: txn.to_version }));
}).catch((e) => setError(asUiError(e)));
}, [serverId]);
// Every finished attempt refreshes the disk state, including failures in the background.
// the update finished (possibly while another tab was open): drop the stale preview, show what is left to decide
useEffect(() => {
if (!upd.stateRevision) return;
if (!upd.result) return;
setPreview(null);
setPendingChecked(!upd.stateError);
setPendingStateError(upd.stateError);
if (!upd.stateError) setPending(upd.result && "pending" in upd.result ? upd.result.pending : null);
}, [upd.stateRevision, serverId]);
async function refreshPending() {
setPendingChecked(false);
try {
const txn = await refreshServerUpdateState(serverId);
setPending(txn);
setPendingStateError(null);
setPendingChecked(true);
return txn;
} catch (e) { setPendingStateError(asUiError(e)); throw e; }
}
if ("pending" in upd.result) setPending(upd.result.pending);
else {
if ("recovered" in upd.result && upd.result.recovered.recovery_verified) setDone(t("upd.autoRestored"));
void api.pendingUpdate(serverId).then(setPending).catch((e) => setError(asUiError(e)));
}
}, [upd.result, serverId]);
async function check() {
setBusy("check");
@@ -77,8 +65,6 @@ export function SettingsHome({ serverId }: { serverId: string }) {
clearServerUpdateResult(serverId);
setPreview(null);
try {
const txn = await refreshPending();
if (txn) return;
const p = await api.checkUpdate(serverId, source.trim() || undefined);
setPreview(p);
setChoices(Object.fromEntries(p.conflicts.map((c) => [c, "keep" as const])));
@@ -90,10 +76,12 @@ export function SettingsHome({ serverId }: { serverId: string }) {
}
async function update() {
if (!pendingChecked || pendingStateError || pending) return;
setError(null);
setDone(null);
await applyServerUpdate(serverId, { choices, source: source.trim() || undefined });
const txn = await api.lastUpdate(serverId).catch(() => null);
if (txn?.outcome === "restored" && txn.recovery_verified) setDone(t("upd.autoRestored"));
setPending(await api.pendingUpdate(serverId).catch(() => null));
}
async function rollback(txn: UpdateTxn) {
@@ -107,7 +95,6 @@ export function SettingsHome({ serverId }: { serverId: string }) {
} catch (e) {
setError(asUiError(e));
} finally {
try { await refreshPending(); } catch { /* Keep the disk-state error visible. */ }
setBusy(null);
}
}
@@ -124,10 +111,7 @@ export function SettingsHome({ serverId }: { serverId: string }) {
clearServerUpdateResult(serverId);
} else setPending(result);
} catch (e) { setError(asUiError(e)); }
finally {
try { await refreshPending(); } catch { /* Keep the disk-state error visible. */ }
setBusy(null);
}
finally { setBusy(null); }
}
async function browse() {
@@ -195,27 +179,28 @@ export function SettingsHome({ serverId }: { serverId: string }) {
</div>
)}
{done && pendingChecked && !pendingStateError && <p className="mt-4 text-sm text-ok" role="status">{done}</p>}
{done && <p className="mt-4 text-sm text-ok" role="status">{done}</p>}
{error && (
<p className="mt-4 text-sm text-bad" role="alert">
{error.human.code === "unknown" ? error.technical : human(error.human).message}
</p>
)}
{preview && isUpdateCurrent(preview) && (
{preview && preview.from_version === preview.to_version && preview.items.every((i) => i.action === "skip") && (
// The same version with no file to change: the database scripts of this package are all in the ledger already.
<div className="mt-5 border-t border-line pt-4">
<p className="font-medium text-ok" role="status">{t("upd.current", { v: preview.to_version })}</p>
</div>
)}
{preview && !isUpdateCurrent(preview) && (
{preview && !(preview.from_version === preview.to_version && preview.items.every((i) => i.action === "skip")) && (
<div className="mt-5 border-t border-line pt-4">
<p className="font-medium">
{preview.from_version ? t("upd.availableFrom", { to: preview.to_version, from: preview.from_version }) : t("upd.available", { to: preview.to_version })}
</p>
<p className="mt-1 text-sm text-muted">
{(preview.pending_migrations ?? preview.migrations) > 0
? t("upd.summaryDb", { size: mb(preview.download_bytes), files: preview.items.filter((i) => i.action !== "skip").length, db: preview.pending_migrations ?? preview.migrations })
{preview.migrations > 0
? t("upd.summaryDb", { size: mb(preview.download_bytes), files: preview.items.filter((i) => i.action !== "skip").length, db: preview.migrations })
: t("upd.summary", { size: mb(preview.download_bytes), files: preview.items.filter((i) => i.action !== "skip").length })}
</p>
<ul className="mt-3 max-h-56 divide-y divide-line overflow-auto text-sm">
@@ -240,7 +225,7 @@ export function SettingsHome({ serverId }: { serverId: string }) {
</li>
))}
</ul>
<Button className="mt-4" variant="primary" disabled={!!busy || !pendingChecked || !!pendingStateError || !!pending} onClick={() => void update()}>
<Button className="mt-4" variant="primary" disabled={!!busy} onClick={() => void update()}>
{busy === "update" && <Loader2 className="h-4 w-4 animate-spin" aria-hidden />}
{t("upd.now")}
</Button>
-62
View File
@@ -1,62 +0,0 @@
import assert from "node:assert/strict";
import test from "node:test";
import { registerHooks } from "node:module";
let applyFailure = false;
let stateFailure = false;
let pending = null;
const calls = [];
globalThis.__hotfixApi = {
applyUpdate: async () => { calls.push("apply"); if (applyFailure) throw new Error("SQL failure"); return { txn: { state: "committed", to_version: "2" } }; },
pendingUpdate: async () => { calls.push("disk"); if (stateFailure) throw new Error("damaged journal"); return pending; },
checkUpdate: async () => ({ from_version: "2", to_version: "2", items: [], conflicts: [], migrations: 1, pending_migrations: 0 }),
};
registerHooks({ resolve(specifier, context, next) {
if (specifier === "react") return { shortCircuit: true, url: "data:text/javascript,export const useSyncExternalStore=(subscribe,getSnapshot)=>getSnapshot();" };
if (specifier === "@/lib/api") return { shortCircuit: true, url: "data:text/javascript,export const api=globalThis.__hotfixApi;export const asUiError=e=>({human:{code:'unknown'},technical:e.message});" };
if (specifier === "@tauri-apps/api/event") return { shortCircuit: true, url: "data:text/javascript,export const listen=async()=>()=>{};" };
if (specifier === "./serverUpdateStatus" && context.parentURL?.endsWith("/serverUpdate.ts")) return { shortCircuit: true, url: new URL("../src/lib/serverUpdateStatus.ts", import.meta.url).href };
return next(specifier, context);
} });
const { applyServerUpdate, refreshServerUpdateState, checkServerUpdate, useServerUpdate } = await import("../src/lib/serverUpdate.ts");
test("a failed update rereads its unfinished transaction from disk", async () => {
calls.length = 0;
applyFailure = true;
pending = { id: "interrupted", state: "failed", message: "Recovery required" };
assert.equal(await applyServerUpdate("failed-case", { choices: {} }), false);
assert.deepEqual(calls, ["apply", "disk"]);
assert.equal(await refreshServerUpdateState("failed-case"), pending);
});
test("unreadable state blocks another apply until a successful reread", async () => {
calls.length = 0;
applyFailure = false;
stateFailure = true;
await applyServerUpdate("corrupt-case", { choices: {} });
assert.equal(await applyServerUpdate("corrupt-case", { choices: {} }), false);
assert.deepEqual(calls, ["apply", "disk"]);
stateFailure = false;
pending = null;
assert.equal(await refreshServerUpdateState("corrupt-case"), null);
assert.equal(await applyServerUpdate("corrupt-case", { choices: {} }), true);
assert.deepEqual(calls, ["apply", "disk", "disk", "apply", "disk"]);
});
test("refresh after recovery returns the latest disk state, then its absence", async () => {
pending = { id: "recovery", state: "failed", message: "Restore failed at database verification" };
assert.equal(await refreshServerUpdateState("recovery-case"), pending);
pending = null;
assert.equal(await refreshServerUpdateState("recovery-case"), null);
});
test("a rejected recheck removes an earlier cached update offer", async () => {
const original = globalThis.__hotfixApi.checkUpdate;
try {
globalThis.__hotfixApi.checkUpdate = async () => ({ from_version: "0.261005.22", to_version: "0.261005.24", items: [], migrations: 1, pending_migrations: 1 });
await checkServerUpdate("stale-offer");
assert.equal(useServerUpdate("stale-offer").available, true);
globalThis.__hotfixApi.checkUpdate = async () => { throw new Error("Installed version is newer than package"); };
await checkServerUpdate("stale-offer");
assert.equal(useServerUpdate("stale-offer").available, false);
assert.equal(useServerUpdate("stale-offer").preview, null);
} finally { globalThis.__hotfixApi.checkUpdate = original; }
});
-18
View File
@@ -1,18 +0,0 @@
import assert from "node:assert/strict";
import test from "node:test";
import { isUpdateCurrent } from "../src/lib/serverUpdateStatus.ts";
const same = { from_version: "1", to_version: "1", items: [{ action: "skip" }], migrations: 10 };
test("same files and version cannot hide pending database repairs", () => {
assert.equal(isUpdateCurrent({ ...same, pending_migrations: 1 }), false);
assert.equal(isUpdateCurrent({ ...same, pending_migrations: 0 }), true);
});
test("unknown history is not presented as up to date", () => {
assert.equal(isUpdateCurrent(same), false);
assert.equal(isUpdateCurrent({ ...same, migrations: 0 }), true);
});
test("file changes and new releases remain available with no pending SQL", () => {
assert.equal(isUpdateCurrent({ ...same, pending_migrations: 0, items: [{ action: "replace" }] }), false);
assert.equal(isUpdateCurrent({ ...same, pending_migrations: 0, to_version: "2" }), false);
});
+133
View File
@@ -0,0 +1,133 @@
param(
[Parameter(Mandatory)][string]$BasePackage,
[Parameter(Mandatory)][string]$CandidatePackage,
[string]$DataSource = '',
[string]$PreviousPackage = '',
[ValidateSet('coa','wildcard','dual','squid','imported')][string]$Mode = 'coa',
[switch]$SkipBuild,
[string]$ReportFile = '',
[string]$Target = (Join-Path $env:RUNNER_TEMP ('coa-schema-fixture-chaos-' + [guid]::NewGuid().ToString('N')))
)
$ErrorActionPreference = 'Stop'
$project = Split-Path $PSScriptRoot -Parent
$tool = Join-Path $project 'target/debug/coa-release.exe'
$test = Join-Path $project 'target/debug/examples/update_acceptance_e2e.exe'
if (Test-Path -LiteralPath $Target) { throw 'Use a new disposable fixture directory.' }
if ((Split-Path $Target -Leaf) -notlike 'coa-schema-fixture-chaos-*') { throw 'Invalid disposable fixture name.' }
if (-not $SkipBuild) {
& cargo build --manifest-path "$project/Cargo.toml" -p coa-release -p coa-core --example update_acceptance_e2e --features coa-core/testkit --locked
if ($LASTEXITCODE) { throw 'Could not build acceptance tools.' }
& cargo build --manifest-path "$project/Cargo.toml" -p coa-release --locked
if ($LASTEXITCODE) { throw 'Could not build release tools.' }
}
if (-not (Test-Path -LiteralPath $tool) -or -not (Test-Path -LiteralPath $test)) { throw 'Acceptance tools are missing.' }
& $tool extract-schema-base --package $BasePackage --fixture $Target
if ($LASTEXITCODE) { throw 'Could not prepare the signed base.' }
[IO.File]::WriteAllText((Join-Path $Target '.coa-chaos-fixture'), 'disposable update chaos fixture')
# A real independent copy: a junction would allow validation to modify source data.
if ($DataSource) {
& robocopy $DataSource (Join-Path $Target 'Data') /E /R:1 /W:1 /NFL /NDL /NJH /NJS /NP | Out-Null
if ($LASTEXITCODE -ge 8) { throw 'Could not copy isolated game data.' }
} else {
& $tool extract-game-data --package $BasePackage --fixture $Target
if ($LASTEXITCODE) { throw 'Could not extract signed game data.' }
}
& $test init $Target
if ($LASTEXITCODE) { throw 'Could not initialize sentinels.' }
& $test seed-players $Target
if ($LASTEXITCODE) { throw 'Could not seed real account, character and inventory records.' }
if ($PreviousPackage) {
& $test baseline-release $Target $PreviousPackage
if ($LASTEXITCODE) { throw 'Previous published release could not be established.' }
}
& $test apply $Target $CandidatePackage
if ($LASTEXITCODE) { throw 'Candidate failed acceptance.' }
& $test prepare-mode $Target $Mode
if ($LASTEXITCODE) { throw "Could not prepare $Mode installation." }
if ($PreviousPackage) {
# Re-establish the old signed release after mode provisioning, so the actual
# upgrade below runs in this mode rather than only in the initial CoA setup.
& $test baseline-release $Target $PreviousPackage
if ($LASTEXITCODE) { throw "Previous release could not be established in $Mode mode." }
}
& $test seed-config $Target
if ($LASTEXITCODE) { throw 'Could not seed a modified user configuration.' }
& $test break-legacy-baseline $Target
if ($LASTEXITCODE) { throw 'Could not inject missing-table baseline.' }
& $test apply $Target $CandidatePackage
if ($LASTEXITCODE) { throw 'Legacy missing-table baseline was not repaired.' }
& $test verify $Target
if ($LASTEXITCODE) { throw 'Sentinels were lost.' }
foreach ($rejection in @('expect-corrupt-package','expect-locked-file','expect-occupied-port')) {
& $test $rejection $Target $CandidatePackage
if ($LASTEXITCODE) { throw "$rejection did not reject safely." }
}
$oldPythonFailure = $env:COA_UPDATE_PYTHON_FAILURE
try {
$env:COA_UPDATE_PYTHON_FAILURE = '1'
& $test expect-rejection $Target $CandidatePackage
if ($LASTEXITCODE) { throw 'Python failure was not restored.' }
} finally { $env:COA_UPDATE_PYTHON_FAILURE = $oldPythonFailure }
$oldValidation = $env:COA_UPDATE_VALIDATION
try {
$env:COA_UPDATE_VALIDATION = '1'
& $test start-fixture $Target
if ($LASTEXITCODE) { throw 'Original offline fixture could not start.' }
$env:COA_UPDATE_PYTHON_FAILURE = '1'
& $test expect-rejection $Target $CandidatePackage
if ($LASTEXITCODE) { throw 'The originally running server was not restored.' }
} finally {
$env:COA_UPDATE_PYTHON_FAILURE = $oldPythonFailure
& $test stop-fixture $Target
$stopResult = $LASTEXITCODE
$env:COA_UPDATE_VALIDATION = $oldValidation
if ($stopResult) { throw 'The offline running-state fixture could not be stopped.' }
}
$oldSqlFailure = $env:COA_UPDATE_SQL_FAILURE
try {
& $test break-legacy-baseline $Target
if ($LASTEXITCODE) { throw 'Could not prepare partial-DDL failure.' }
$env:COA_UPDATE_SQL_FAILURE = 'manager_repair__20261005_reconcile_wildcard_tables'
& $test expect-rejection $Target $CandidatePackage
if ($LASTEXITCODE) { throw 'Partial DDL/SQL failure was not restored.' }
} finally { $env:COA_UPDATE_SQL_FAILURE = $oldSqlFailure }
$oldCrash = $env:COA_UPDATE_CRASH_AT
try {
$env:COA_UPDATE_CRASH_AT = 'snapshot-recorded'
& $test apply $Target $CandidatePackage
if ($LASTEXITCODE -ne 91) { throw 'The recorded-snapshot interruption was not exercised.' }
$env:COA_UPDATE_CRASH_AT = ''
foreach ($corruption in @('expect-corrupt-journal','expect-corrupt-recovery-point')) {
& $test $corruption $Target
if ($LASTEXITCODE) { throw "Corruption guard $corruption failed." }
}
& $test rollback $Target
if ($LASTEXITCODE) { throw 'Recovery after removing injected corruption failed.' }
foreach ($point in @('stopped','snapshot','trial','before-file:0','journal-file:0','written-file:0','completed-file:0','applied','before-migrations','before-sql:manager_repair__20261005_reconcile_wildcard_tables','after-sql:manager_repair__20261005_reconcile_wildcard_tables','recorded-sql:manager_repair__20261005_reconcile_wildcard_tables','migrated','validated','before-commit','commit-metadata')) {
$env:COA_UPDATE_CRASH_AT = ''
& $test break-legacy-baseline $Target
if ($LASTEXITCODE) { throw 'Could not reset isolated baseline.' }
& $test dirty-fixture $Target $CandidatePackage
if ($LASTEXITCODE) { throw 'Could not arrange a real file replacement.' }
$env:COA_UPDATE_CRASH_AT = $point
& $test apply $Target $CandidatePackage
if ($LASTEXITCODE -ne 91) { throw "Fault point $point was not exercised (exit $LASTEXITCODE)." }
foreach ($recoveryPoint in @('restore-stopped','restore-databases','restore-files')) {
$env:COA_UPDATE_CRASH_AT = $recoveryPoint
& $test rollback $Target
# restore-databases may not be reached before any live database changes.
if ($LASTEXITCODE -notin @(0,91)) { throw "Recovery fault $recoveryPoint failed." }
if ($LASTEXITCODE -eq 0) { break }
}
$env:COA_UPDATE_CRASH_AT = ''
& $test rollback $Target
if ($LASTEXITCODE) { throw "Recovery from $point failed." }
}
} finally { $env:COA_UPDATE_CRASH_AT = $oldCrash }
$manifest = Get-Content (Join-Path $CandidatePackage 'manifest.json') -Raw | ConvertFrom-Json
$managerSource = (& git -C $project rev-parse HEAD).Trim()
if ($LASTEXITCODE -or $managerSource -notmatch '^[0-9a-f]{40}$') { throw 'Cannot identify the tested manager source.' }
$report = @{ schema = 1; version = $manifest.version; manifestSha256 = (Get-FileHash (Join-Path $CandidatePackage 'manifest.json') -Algorithm SHA256).Hash.ToLower(); manager = (Get-FileHash $test -Algorithm SHA256).Hash.ToLower(); managerSource = $managerSource; mode = $Mode; baseline = $(if ($PreviousPackage) { (Get-Content (Join-Path $PreviousPackage 'manifest.json') -Raw | ConvertFrom-Json).version } else { 'base' }); result = 'passed' }
$report.coverage = @('signed-package-corruption','locked-file','occupied-port','python-startup-failure','partial-ddl-invalid-sql','update-process-crash','recovery-process-crash','modified-config-preservation','running-state-recovery','player-data-preservation','corrupt-journal','corrupt-recovery-point')
if (-not $ReportFile) { $ReportFile = Join-Path $CandidatePackage 'acceptance.json' }
$report | ConvertTo-Json | Set-Content $ReportFile -Encoding utf8NoBOM
+81
View File
@@ -0,0 +1,81 @@
param(
[Parameter(Mandatory)][string]$BasePackage,
[Parameter(Mandatory)][string]$CandidatePackage,
[string]$PreviousPackage = '',
[string]$DataSource = '',
[ValidateRange(1,5)][int]$MaxParallel = 2,
[string]$WorkDirectory = (Join-Path $env:RUNNER_TEMP ('coa-acceptance-' + [guid]::NewGuid().ToString('N')))
)
$ErrorActionPreference = 'Stop'
$project = Split-Path $PSScriptRoot -Parent
& git -C $project diff --quiet HEAD --
if ($LASTEXITCODE) { throw 'Release acceptance requires committed manager source; tracked changes are present.' }
$untrackedSource = & git -C $project ls-files --others --exclude-standard -- crates src src-tauri tools .github
if ($LASTEXITCODE -or $untrackedSource) { throw 'Release acceptance requires committed manager source; untracked source files are present.' }
$base = (Resolve-Path -LiteralPath $BasePackage).Path
$candidate = (Resolve-Path -LiteralPath $CandidatePackage).Path
$previous = if ($PreviousPackage) { (Resolve-Path -LiteralPath $PreviousPackage).Path } else { '' }
$data = if ($DataSource) { (Resolve-Path -LiteralPath $DataSource).Path } else { '' }
if (Test-Path -LiteralPath $WorkDirectory) { throw 'Use a fresh acceptance work directory.' }
New-Item -ItemType Directory -Path $WorkDirectory | Out-Null
$work = (Resolve-Path -LiteralPath $WorkDirectory).Path
& cargo build --manifest-path "$project/Cargo.toml" -p coa-core --example update_acceptance_e2e --features testkit --locked
if ($LASTEXITCODE) { throw 'Could not build the marked-fixture acceptance tool.' }
& cargo build --manifest-path "$project/Cargo.toml" -p coa-release --locked
if ($LASTEXITCODE) { throw 'Could not build signature verification tools.' }
$queue = [Collections.Generic.Queue[object]]::new()
foreach ($mode in @('coa','wildcard','dual','squid','imported')) {
$queue.Enqueue(@{ mode=$mode; baseline='base'; previous='' })
if ($previous) { $queue.Enqueue(@{ mode=$mode; baseline='previous'; previous=$previous }) }
}
$active = [Collections.Generic.List[object]]::new()
$completed = [Collections.Generic.List[object]]::new()
try {
while ($queue.Count -or $active.Count) {
while ($queue.Count -and $active.Count -lt $MaxParallel) {
$job = $queue.Dequeue()
$name = "$($job.mode)-$($job.baseline)"
$report = Join-Path $work "$name.json"
$target = Join-Path $work "coa-schema-fixture-chaos-$name"
$arguments = @('-NoProfile','-File', ('"' + (Join-Path $PSScriptRoot 'update-chaos-gate.ps1') + '"'), '-SkipBuild', '-BasePackage', ('"' + $base + '"'), '-CandidatePackage', ('"' + $candidate + '"'), '-Target', ('"' + $target + '"'), '-Mode', $job.mode, '-ReportFile', ('"' + $report + '"'))
if ($job.previous) { $arguments += @('-PreviousPackage', ('"' + $job.previous + '"')) }
if ($data) { $arguments += @('-DataSource', ('"' + $data + '"')) }
$process = Start-Process -FilePath (Get-Process -Id $PID).Path -ArgumentList $arguments -WindowStyle Hidden -PassThru -RedirectStandardOutput (Join-Path $work "$name.log") -RedirectStandardError (Join-Path $work "$name.errors.log")
$active.Add(@{ process=$process; name=$name; report=$report })
Write-Output "Started isolated $name acceptance"
}
foreach ($job in @($active.ToArray())) {
$job.process.Refresh()
if (-not $job.process.HasExited) { continue }
$job.process.WaitForExit()
if ($job.process.ExitCode -ne 0 -or -not (Test-Path -LiteralPath $job.report)) {
throw "Acceptance $($job.name) failed. Logs and marked copies are preserved at $work."
}
$completed.Add((Get-Content -LiteralPath $job.report -Raw | ConvertFrom-Json))
$active.Remove($job) | Out-Null
Write-Output "Passed isolated $($job.name) acceptance"
}
if ($active.Count) { Start-Sleep -Seconds 1 }
}
} catch {
# Do not kill recovery processes or remove their copies. Each active fixture completes
# independently; the parent fails publication immediately.
throw
}
$manifestHash = (Get-FileHash (Join-Path $candidate 'manifest.json')).Hash.ToLower()
$manifest = Get-Content (Join-Path $candidate 'manifest.json') -Raw | ConvertFrom-Json
foreach ($result in $completed) {
if ($result.result -ne 'passed' -or $result.manifestSha256 -ne $manifestHash -or $result.version -ne $manifest.version -or $result.managerSource -ne $completed[0].managerSource) { throw 'Acceptance results refer to different source or package bytes.' }
}
$expected = if ($previous) { 10 } else { 5 }
if ($completed.Count -ne $expected) { throw 'Incomplete update acceptance matrix.' }
$requiredCoverage = @('signed-package-corruption','locked-file','occupied-port','python-startup-failure','partial-ddl-invalid-sql','update-process-crash','recovery-process-crash','modified-config-preservation','running-state-recovery','player-data-preservation','disk-exhaustion','write-denial','corrupt-journal','corrupt-recovery-point','database-process-crash','new-server-crash','network-action-containment','all-file-operation-phases')
$missingCoverage = @($requiredCoverage | Where-Object {
$required = $_
@($completed | Where-Object { $required -notin $_.coverage }).Count -gt 0
})
$combined = @{ schema=1; result=$(if ($missingCoverage.Count) { 'incomplete' } else { 'passed' }); version=$manifest.version; manifestSha256=$manifestHash; manager=$completed[0].manager; managerSource=$completed[0].managerSource; scenarios=$completed.ToArray(); missingCoverage=$missingCoverage }
$combined | ConvertTo-Json -Depth 10 | Set-Content (Join-Path $candidate 'acceptance.json') -Encoding utf8NoBOM
if ($missingCoverage.Count) { throw "Publication is blocked: release fault coverage is incomplete ($($missingCoverage -join ', ')). Scenario results were preserved." }
Write-Output "Passed all $expected update acceptance scenarios"