mirror of
https://github.com/Corfirean/coa-server-manager.git
synced 2026-11-19 03:25:56 +00:00
Compare commits
7
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
277ebba847 | ||
|
|
9a0b815937 | ||
|
|
78b84e11c2 | ||
|
|
6aea9011f9 | ||
|
|
171d9a2bf8 | ||
|
|
0d6d8a0db8 | ||
|
|
3940506987 |
No files matched your search
@@ -12,32 +12,16 @@ permissions:
|
||||
|
||||
jobs:
|
||||
installer:
|
||||
runs-on: [self-hosted, Windows, X64, coa-update-acceptance]
|
||||
timeout-minutes: 1440
|
||||
runs-on: windows-latest
|
||||
timeout-minutes: 60
|
||||
steps:
|
||||
- uses: actions/checkout@v7
|
||||
- uses: actions/setup-node@v4
|
||||
with:
|
||||
node-version: 26.10.0
|
||||
node-version: 22
|
||||
- run: npm ci
|
||||
- name: Tests
|
||||
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.' }
|
||||
run: cargo test --workspace -- --test-threads=1
|
||||
- name: Build, sign and publish
|
||||
uses: tauri-apps/tauri-action@v0
|
||||
env:
|
||||
@@ -48,29 +32,7 @@ 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: true
|
||||
releaseDraft: false
|
||||
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
@@ -521,12 +521,9 @@ dependencies = [
|
||||
name = "coa-release"
|
||||
version = "0.6.5"
|
||||
dependencies = [
|
||||
"base64 0.22.1",
|
||||
"chrono",
|
||||
"coa-core",
|
||||
"ed25519-dalek",
|
||||
"serde_json",
|
||||
"tempfile",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
|
||||
@@ -0,0 +1,104 @@
|
||||
# Urgent update hotfix
|
||||
|
||||
Deadline: 2026-10-06. This checkout starts at the exact v0.6.4 tag, commit
|
||||
6c771fa, and excludes the ongoing isolated-trial/recovery redesign.
|
||||
|
||||
The client accepts checksum compatibility only from a verified signed manifest and only
|
||||
for an Applied migration. It never updates the historical checksum, reruns historical
|
||||
SQL, or excuses a Running/Failed ledger row. A server package must explicitly list the
|
||||
verified published variants and append corrections under new migration IDs.
|
||||
|
||||
Current local evidence: the locked workspace tests passed, including 252 core tests
|
||||
run serially. Six frontend logic tests and the frontend production build passed.
|
||||
The hotfix runtime was tested against the exact signed candidate manifest on the marked
|
||||
CoA/Wildcard fixture. Both published repair checksums were accepted independently in
|
||||
both worlds, with zero migration executions, unchanged historical checksums, and unchanged
|
||||
account, character and inventory counts. The original ledger rows were restored after
|
||||
the test, and all fixture processes were stopped. A real Running or Failed repair row in
|
||||
either world was rejected before staging or creating a transaction, with unchanged world
|
||||
executable and installation metadata. Tests use independent hotfix metadata so experimental
|
||||
transaction formats are not confused with the 0.6.4 upgrade path. Windows journal writes also use flushed
|
||||
atomic replacement with long-path support. Changelog validation passed.
|
||||
|
||||
Additional guards implemented:
|
||||
|
||||
- Read migration history without creating its ledger before downloading or replacing files.
|
||||
- Reject missing journals, invalid identities, paths, hashes and inconsistent operations.
|
||||
Durable completed-cleanup markers distinguish interrupted pruning from a lost journal.
|
||||
- Preserve all backups while an update is unfinished or its journal is damaged.
|
||||
- Verify saved-file hashes and the complete database/configuration recovery point before
|
||||
stopping services or changing files/databases. New snapshots include configuration hashes;
|
||||
update journals bind their backup metadata to a hash.
|
||||
- Surface state-reading errors in Settings and disable applying until the disk state is
|
||||
successfully read. Checking again refreshes that state.
|
||||
- Verify every extracted SQL artifact before taking the update snapshot or replacing
|
||||
server files; missing files, invalid IDs, duplicate migrations and checksum disagreements
|
||||
reject the update early. SQL application repeats the integrity check immediately before use.
|
||||
- Count unapplied migrations in the active and secondary realms, counting shared auth once.
|
||||
Matching versions and files do not hide remaining database work. Preview reads history
|
||||
under the installation lock; a stopped database is temporarily started for inspection
|
||||
and stopped again when no game services are running.
|
||||
- Reread the disk state after every update/recovery attempt, including failed attempts and
|
||||
background updates. Unfinished or unreadable state blocks another application in the UI.
|
||||
- Acquire the installation lock before checking and deleting a backup.
|
||||
|
||||
Latest real-runtime test used the independently copied, doubly marked fixture
|
||||
`C:\games\coa-schema-fixture-chaos-20261005-v1` and signed candidate `0.261005.24`, manifest SHA-256
|
||||
`1284b1273815209c9621b6d173a2211bae316f33462ccbe8b578e53b8d26fb5b`.
|
||||
All 1748 SQL artifacts passed verification after authenticated archive extraction.
|
||||
Removing one repair record separately in CoA and Wildcard increased the pending count
|
||||
by exactly one; restoring its original record restored the original count. No migrations
|
||||
were executed, player counts were preserved and fixture services were stopped afterward.
|
||||
The source checkout remains uncommitted; these results are not an installer acceptance report.
|
||||
|
||||
Additional acceptance on 2026-10-06: a new independent installation/database copy at
|
||||
`C:\games\coa-schema-fixture-chaos-064-transition-20261006` received the authenticated
|
||||
published `0.261005.22` program files, original CRLF repair checksum, and a deliberately
|
||||
missing Wildcard table in both realms. The production hotfix update pipeline committed
|
||||
signed candidate `0.261005.24`, repaired both realms, passed schema checks and actual
|
||||
bundled-Python server startup, and preserved the selected account, character, item and
|
||||
inventory fields byte-for-byte. The fixture was stopped afterward. The harness explicitly
|
||||
instruments the launcher to prevent relay submissions and bind to localhost; this is not
|
||||
proof of packaged UI behavior or operating-system network containment.
|
||||
|
||||
Local installer `C:\games\source\manager-065-local-installer-20261006\CoA Server Manager_0.6.5_x64-setup.exe`
|
||||
has SHA-256 `520ee0391d923b92da0a20591e30006c048cdb60156275d7a829918bf1b77491`.
|
||||
Its updater signature and the published 0.6.4 installer's signature passed independent
|
||||
verification with the configured updater public key. Both executables extracted from
|
||||
their exact NSIS packages started, created responsive windows, and were stopped using
|
||||
an independent application/WebView profile. No installer was executed over a user's
|
||||
installation, and no UI update operation was exercised.
|
||||
|
||||
Legacy limitation: old 0.6.4 transaction copies and configuration snapshots without recorded
|
||||
hashes can be checked for presence and declared database hashes, but their original file
|
||||
contents cannot be authenticated retroactively. Missing copies block restoration. This
|
||||
hotfix does not claim that old unchecksummed copies received full integrity verification.
|
||||
|
||||
Remaining release requirements: reproduce the existing-user failures through the published
|
||||
0.6.4 interface, verify legacy unfinished transaction handling on real-runtime fixtures,
|
||||
and execute the exact installer over 0.6.4 in an isolated Windows environment with UI
|
||||
state/settings/server-list verification. Windows native UI automation is unavailable in
|
||||
this session. Packaged startup and signature checks do not satisfy that installer gate.
|
||||
No public release has been made.
|
||||
|
||||
The user subsequently exercised the packaged UI: candidate 0.261005.24 committed and
|
||||
both CoA and Wildcard were shown running. Repeat-check/restart acceptance is still pending.
|
||||
The screenshots exposed an older published package being offered after the local candidate
|
||||
was installed. Follow-up changes reject older packages before preview/database inspection
|
||||
and application and clear a cached offer after a failed recheck. All 253 core tests and
|
||||
seven frontend tests passed. The earlier installer hash above does not include this follow-up;
|
||||
a separately recorded revision is required. Native UI control was subsequently initialized
|
||||
through the deferred node_repl tool, then the user stopped automation with Escape and
|
||||
performed the UI check manually.
|
||||
|
||||
Another user repeat-check exposed the already installed launcher being offered again.
|
||||
The preview now verifies canonical launcher bytes against the current signed package,
|
||||
caches those bytes by SHA-256, and compares only recognized Manager transformations.
|
||||
The actual disposable fixture's repeat preview passed with all 104 files skipped and
|
||||
zero pending SQL. User edits, recorded custom content, and a package with different
|
||||
launcher bytes are not mistaken for that integration. All 254 core tests passed;
|
||||
the strengthened regression test and seven frontend tests also passed. The first
|
||||
preview of a managed launcher may download/extract its authenticated package to build
|
||||
the optional canonical cache. Earlier installer revisions do not include this fix.
|
||||
|
||||
Do not recommend deleting an installation or replacing its player databases.
|
||||
@@ -1,7 +0,0 @@
|
||||
---
|
||||
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.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: fixed
|
||||
audience: admins
|
||||
title: Server updates accept verified published migration variants without rerunning them
|
||||
---
|
||||
Signed updates can recognise known published checksums without changing your migration history. Interrupted or failed SQL still requires recovery before retrying.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: fixed
|
||||
audience: admins
|
||||
title: Server updates replace older launchers adapted by the Manager for Wildcard
|
||||
---
|
||||
Updates recognize the Manager’s own realm and import adjustments even when older metadata still records the original launcher. New server binaries receive their matching launcher; genuine custom edits still require your decision.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: fixed
|
||||
audience: admins
|
||||
title: Older server packages cannot replace a newer installation
|
||||
---
|
||||
Update checks stop offering stale packages after an update. To undo an update, use its recovery point instead of applying an older server package.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: fixed
|
||||
audience: admins
|
||||
title: Checking again no longer offers an already installed launcher update
|
||||
---
|
||||
The Manager recognizes its own launcher integration while still detecting user edits and changes in newer signed packages.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: fixed
|
||||
audience: admins
|
||||
title: Large SQUID database imports have more time to finish on first startup
|
||||
---
|
||||
The Manager allows up to 45 minutes when SQUID Playerbots is enabled, covering its initial database import and bot creation. Ordinary server startup and shutdown keep their existing deadlines.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: fixed
|
||||
audience: admins
|
||||
title: Update history conflicts are detected before server files change
|
||||
---
|
||||
Damaged update records block changes and remain visible. Recovery checks saved copies before restoring, and unfinished updates protect backups from deletion and cleanup.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: fixed
|
||||
audience: admins
|
||||
title: Pending database updates remain visible when the server version matches
|
||||
---
|
||||
SQL files are checked before replacing server files. Update and recovery attempts refresh their saved status, including errors. Backup deletion cannot race with an update.
|
||||
@@ -0,0 +1,38 @@
|
||||
use std::{fs, path::PathBuf};
|
||||
use coa_core::{manifest::{Kind, Manifest}, package::{self, BuildOptions}, pkgsource::{self, Source}, release, signing, Result};
|
||||
|
||||
fn main() -> Result<()> {
|
||||
let args: Vec<String> = std::env::args().skip(1).collect();
|
||||
let source = Source::Dir(args[1].clone().into());
|
||||
let (previous, _) = pkgsource::fetch_manifest(&source, signing::EMBEDDED_PUBLIC_KEY)?;
|
||||
let tree = PathBuf::from(&args[2]);
|
||||
if args[0] == "extract" {
|
||||
assert!(!tree.exists(), "Use a new release tree");
|
||||
package::extract(&PathBuf::from(&args[1]), &previous, &tree, &|_, _| {})?;
|
||||
println!("Verified and extracted {}: {} historical migrations", previous.version, previous.migrations.len());
|
||||
return Ok(());
|
||||
}
|
||||
assert_eq!(args[0], "pack");
|
||||
let out = PathBuf::from(&args[3]);
|
||||
assert!(!out.exists(), "Release addresses must be immutable");
|
||||
for migration in &previous.migrations {
|
||||
let entry = previous.files.iter().find(|file| file.path.starts_with("_migrations/") && file.sha256 == migration.sha256).expect("Historical SQL entry");
|
||||
assert_eq!(coa_core::fsx::sha256_file(&tree.join(&entry.path))?, entry.sha256, "Historical SQL changed: {}", migration.id);
|
||||
}
|
||||
let mut manifest = package::build(&tree, &out, &BuildOptions {
|
||||
kind: Kind::Update, version: args[4].clone(), core_commit: Some(args[5].clone()),
|
||||
bots_commit: previous.bots.and_then(|revision| revision.commit),
|
||||
built_at: chrono::Utc::now().to_rfc3339(), part_size: package::DEFAULT_PART_SIZE,
|
||||
migrations: previous.migrations.clone(),
|
||||
}, &|line| println!("{line}"))?;
|
||||
manifest.min_manager_version = "0.6.5".into();
|
||||
manifest.validate()?;
|
||||
coa_core::fsx::atomic_write(&out.join("manifest.json"), &serde_json::to_vec_pretty(&manifest)?)?;
|
||||
let key_path = PathBuf::from(std::env::var("USERPROFILE").unwrap()).join(".coa-manager/signing/manifest-signing.key");
|
||||
release::sign_manifest(&out, &fs::read_to_string(key_path)?)?;
|
||||
coa_core::release_schema::verify_package(&out, signing::EMBEDDED_PUBLIC_KEY)?;
|
||||
let reread: Manifest = serde_json::from_slice(&fs::read(out.join("manifest.json"))?)?;
|
||||
assert_eq!(serde_json::to_value(reread.migrations)?, serde_json::to_value(previous.migrations)?);
|
||||
println!("PASS: signed {}; all historical migration bytes, checksums, aliases and order preserved", manifest.version);
|
||||
Ok(())
|
||||
}
|
||||
@@ -0,0 +1,70 @@
|
||||
use std::path::{Path, PathBuf};
|
||||
use coa_core::{backup, driver, fsx, Result};
|
||||
|
||||
fn set(root: &Path, filename: &str, values: &[(&str, &str)]) -> Result<()> {
|
||||
let path = root.join("Core/configs/modules").join(filename);
|
||||
let mut config = coa_core::config::parser::ConfFile::parse_bytes(&std::fs::read(&path)?)?;
|
||||
for (key, value) in values { config.set(key, value, &[]); }
|
||||
fsx::atomic_write(&path, config.to_text().as_bytes())
|
||||
}
|
||||
|
||||
fn ledgers(root: &Path) -> Result<Vec<String>> {
|
||||
backup::with_database(root, |db| ["acore_playerbots", "acore_world", "acore_characters"].into_iter()
|
||||
.map(|schema| db.query(&format!("SELECT path,sha256 FROM `{schema}`.coa_squid_migrations ORDER BY path;"))).collect())
|
||||
}
|
||||
|
||||
fn exercise(root: &Path) -> Result<()> {
|
||||
let meta = coa_core::registry::metadata_dir_for(root)?;
|
||||
let point = backup::create(root, &meta, backup::Kind::Full, backup::Trigger::Manual, Some("Disposable SQUID acceptance".into()), &|stage| println!("{stage}"))?;
|
||||
assert!(backup::verify(&meta, &point.id)?.ok);
|
||||
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| -> Result<()> {
|
||||
backup::with_database(root, |db| db.query("DROP DATABASE IF EXISTS acore_playerbots;").map(|_| ()))?;
|
||||
assert!(driver::run(root, driver::Verb::StartAll)?.ok, "Disabled SQUID must start without its database");
|
||||
assert!(driver::run(root, driver::Verb::StopAll)?.ok);
|
||||
coa_core::multiworld::set_enabled(root, false)?;
|
||||
coa_core::realms::select(root, coa_core::realms::Mode::Coa)?;
|
||||
set(root, "mod_coa_playerbots.conf", &[("CoaBots.Enable", "0")])?;
|
||||
set(root, "playerbots.conf", &[("AiPlayerbot.Enabled", "1"), ("AiPlayerbot.RandomBotAutologin", "0"), ("AiPlayerbot.MinRandomBots", "0"), ("AiPlayerbot.MaxRandomBots", "0"), ("AiPlayerbot.RandomBotGuildCount", "0"), ("AiPlayerbot.RandomBotAccountCount", "0")])?;
|
||||
let started = driver::run(root, driver::Verb::StartAll)?;
|
||||
assert!(started.ok, "Fresh SQUID startup: {}", coa_core::diag::redact(&started.output));
|
||||
let before = ledgers(root)?;
|
||||
assert!(!before[0].is_empty(), "Fresh SQUID history missing");
|
||||
assert!(driver::run(root, driver::Verb::StopAll)?.ok);
|
||||
let started = driver::run(root, driver::Verb::StartAll)?;
|
||||
assert!(started.ok, "Repeated SQUID startup: {}", coa_core::diag::redact(&started.output));
|
||||
assert_eq!(ledgers(root)?, before, "SQUID replay changed its migration history");
|
||||
println!("PASS: SQUID-disabled dual startup without its database; fresh enabled SQUID import and startup; repeated startup preserves all three histories");
|
||||
Ok(())
|
||||
}));
|
||||
assert!(driver::run(root, driver::Verb::StopAll)?.ok);
|
||||
restore(root, &meta, &point)?;
|
||||
result.map_err(|_| coa_core::Error::Invalid("SQUID acceptance failed; disposable databases and configurations restored".into()))?
|
||||
}
|
||||
|
||||
fn restore(root: &Path, meta: &Path, point: &backup::RecoveryPoint) -> Result<()> {
|
||||
assert!(backup::verify(meta, &point.id)?.ok);
|
||||
assert!(driver::run(root, driver::Verb::StopAll)?.ok);
|
||||
coa_core::realms::select(root, point.realm)?;
|
||||
for component in point.components.iter().filter(|component| component.name != "configs") {
|
||||
backup::restore_database(root, meta, &point.id, &component.name)?;
|
||||
}
|
||||
backup::restore_configs(root, meta, &point.id)?;
|
||||
assert!(driver::run(root, driver::Verb::StopAll)?.ok);
|
||||
println!("PASS: disposable SQUID acceptance databases and original realm configurations restored");
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn main() -> Result<()> {
|
||||
let root = PathBuf::from(std::env::args().nth(1).unwrap());
|
||||
assert!(root.file_name().unwrap().to_string_lossy().starts_with("coa-schema-fixture-chaos-064-transition-"));
|
||||
assert_eq!(std::fs::read(root.join(".transition-fixture"))?, b"disposable published-064 transition fixture");
|
||||
assert!(!root.join("Data").symlink_metadata()?.file_type().is_symlink());
|
||||
assert!(driver::run(&root, driver::Verb::StopAll)?.ok);
|
||||
if let Some(id) = std::env::args().nth(2) {
|
||||
let meta = coa_core::registry::metadata_dir_for(&root)?;
|
||||
return restore(&root, &meta, &backup::get(&meta, &id)?);
|
||||
}
|
||||
let result = exercise(&root);
|
||||
assert!(driver::run(&root, driver::Verb::StopAll)?.ok);
|
||||
result
|
||||
}
|
||||
@@ -0,0 +1,54 @@
|
||||
use std::{collections::BTreeMap, path::PathBuf};
|
||||
use coa_core::{backup, driver, registry::MetaDir, update::{self, RepackEnv}, Result};
|
||||
|
||||
fn players(db: &coa_core::db::Db) -> Result<String> {
|
||||
db.query("SELECT CONCAT(id,':',username,':',HEX(salt),':',HEX(verifier)) FROM acore_auth.account WHERE id=900001; SELECT CONCAT(guid,':',account,':',name,':',level,':',money) FROM acore_characters.characters WHERE guid=900001; SELECT CONCAT(guid,':',itemEntry,':',owner_guid,':',enchantments) FROM acore_characters.item_instance WHERE guid=900001; SELECT CONCAT(guid,':',bag,':',slot,':',item) FROM acore_characters.character_inventory WHERE guid=900001;")
|
||||
}
|
||||
|
||||
fn exercise(root: &std::path::Path, package: &str) -> Result<()> {
|
||||
let meta_dir = coa_core::registry::metadata_dir_for(root)?;
|
||||
let (_, meta) = MetaDir::open(&meta_dir)?;
|
||||
let expected = backup::with_database(root, |db| [coa_core::realms::Mode::Coa, coa_core::realms::Mode::Wildcard].into_iter().map(|mode| players(&db.clone().for_realm(mode))).collect::<Result<Vec<_>>>())?;
|
||||
assert!(driver::run(root, driver::Verb::StopAll)?.ok);
|
||||
let source = coa_core::pkgsource::Source::Dir(package.into());
|
||||
let preview = update::preview(root, &meta, &source, coa_core::signing::EMBEDDED_PUBLIC_KEY, &BTreeMap::new())?;
|
||||
assert_eq!(preview.pending_migrations, 0, "Historical SQL must not replay");
|
||||
assert!(!preview.items.iter().any(|item| item.action == update::Action::Conflict), "Unresolved candidate files: {:?}", preview.items);
|
||||
let environment = RepackEnv { root, meta_dir: &meta_dir };
|
||||
let outcome = update::apply(&update::Params {
|
||||
root, meta_dir: &meta_dir, source, trusted_key: coa_core::signing::EMBEDDED_PUBLIC_KEY,
|
||||
resolutions: BTreeMap::new(), cancel: Default::default(), env: &environment, fail_after_ops: None,
|
||||
}, &|stage, progress| println!("{progress}% {stage}"))?;
|
||||
assert_eq!(outcome.txn.state, update::State::Committed, "{:?}", outcome.txn);
|
||||
backup::with_database(root, |db| {
|
||||
for (index, mode) in [coa_core::realms::Mode::Coa, coa_core::realms::Mode::Wildcard].into_iter().enumerate() {
|
||||
let realm = db.clone().for_realm(mode);
|
||||
assert_eq!(players(&realm)?, expected[index], "Player data changed in {mode:?}");
|
||||
let problems = coa_core::schema_check::check(&realm, root)?;
|
||||
assert!(problems.is_empty(), "{problems:?}");
|
||||
}
|
||||
Ok(())
|
||||
})?;
|
||||
let release = coa_core::squid::release(root).expect("SQUID release metadata");
|
||||
println!("SQUID metadata: {release:?}");
|
||||
assert_eq!(coa_core::squid::fields(root)?.len(), 40);
|
||||
let (_, installed) = MetaDir::open(&meta_dir)?;
|
||||
let repeated = update::preview(root, &installed, &coa_core::pkgsource::Source::Dir(package.into()), coa_core::signing::EMBEDDED_PUBLIC_KEY, &BTreeMap::new())?;
|
||||
assert_eq!(repeated.pending_migrations, 0);
|
||||
assert!(repeated.items.iter().all(|item| item.action == update::Action::Skip), "{:?}", repeated.items);
|
||||
println!("PASS: coordinated update committed, both realms started, player fields preserved, historical SQL skipped, repeated preview clean");
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn main() -> Result<()> {
|
||||
let args: Vec<String> = std::env::args().skip(1).collect();
|
||||
let root = PathBuf::from(&args[0]);
|
||||
assert!(root.file_name().unwrap().to_string_lossy().starts_with("coa-schema-fixture-chaos-064-transition-"));
|
||||
assert_eq!(std::fs::read(root.join(".transition-fixture"))?, b"disposable published-064 transition fixture");
|
||||
assert_eq!(std::fs::read(root.join(".release-schema-fixture"))?, b"disposable release-schema fixture");
|
||||
assert!(!root.join("Data").symlink_metadata()?.file_type().is_symlink());
|
||||
assert!(driver::run(&root, driver::Verb::StopAll)?.ok);
|
||||
let outcome = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| exercise(&root, &args[1])));
|
||||
assert!(driver::run(&root, driver::Verb::StopAll)?.ok, "Fixture shutdown failed");
|
||||
outcome.map_err(|_| coa_core::Error::Invalid("Disposable coordinated acceptance failed; stopped services and retained recovery copies".into()))?
|
||||
}
|
||||
@@ -0,0 +1,93 @@
|
||||
//! Verify published checksum compatibility on a disposable real database, without running SQL migrations.
|
||||
use std::{path::{Path, PathBuf}, sync::atomic::{AtomicUsize, Ordering}};
|
||||
use coa_core::{backup, db::Db, migrations::{self, LedgerRow, Status, Store}, pkgsource::{self, Source}, Result};
|
||||
|
||||
struct Observed<'a> { db: &'a Db, executions: AtomicUsize }
|
||||
impl Store for Observed<'_> {
|
||||
fn load(&self) -> Result<Vec<LedgerRow>> { self.db.load() }
|
||||
fn put(&self, row: &LedgerRow) -> Result<()> { self.db.put(row) }
|
||||
fn run_file(&self, _: &str, _: &Path) -> Result<()> {
|
||||
self.executions.fetch_add(1, Ordering::SeqCst);
|
||||
panic!("Historical SQL must never be replayed");
|
||||
}
|
||||
}
|
||||
|
||||
fn main() -> Result<()> {
|
||||
let args: Vec<_> = std::env::args().skip(1).collect();
|
||||
let root = PathBuf::from(&args[0]);
|
||||
assert!(root.file_name().unwrap().to_string_lossy().starts_with("coa-schema-fixture-chaos-"));
|
||||
assert_eq!(std::fs::read(root.join(".coa-chaos-fixture"))?, b"disposable update chaos fixture");
|
||||
assert_eq!(std::fs::read(root.join(".release-schema-fixture"))?, b"disposable release-schema fixture");
|
||||
let source = Source::Dir(PathBuf::from(&args[1]));
|
||||
let package = pkgsource::fetch_manifest(&source, coa_core::signing::EMBEDDED_PUBLIC_KEY)?.0;
|
||||
let staging = tempfile::tempdir()?;
|
||||
let parts = pkgsource::fetch_parts(&source, &package, &staging.path().join("download"), &Default::default(), &|_, _| {})?;
|
||||
coa_core::package::extract(&parts, &package, &staging.path().join("tree"), &|_, _| {})?;
|
||||
migrations::verify_files(&package.migrations, &staging.path().join("tree/_migrations"))?;
|
||||
println!("PASS: all {} signed-package SQL artifacts verified before any database mutation", package.migrations.len());
|
||||
let migration = package.migrations.iter().find(|m| m.id == "manager_repair__20261005_missing_wildcard_tables").unwrap();
|
||||
let hashes = ["c1d8dbf2271234283a48a39e4b4aea1106b83b70581f1e3c4aa9fff438e8e4d2", "9e4a36245c3f83255415c122c01f08ceb3e3b83898d3d427ac4e2fbcf61e9638"];
|
||||
for hash in hashes { assert!(migration.sha256 == hash || migration.compatible_sha256.iter().any(|h| h == hash)); }
|
||||
let fixture_meta = coa_core::registry::metadata_dir_for(&root)?;
|
||||
let test_meta = tempfile::tempdir()?;
|
||||
coa_core::fsx::atomic_write(&test_meta.path().join("install.json"), &std::fs::read(fixture_meta.join("install.json"))?)?;
|
||||
coa_core::registry::MetaDir::open(test_meta.path())?;
|
||||
std::fs::create_dir_all(test_meta.path().join("updates"))?;
|
||||
let result = backup::with_database(&root, |db| {
|
||||
let mut modes = vec![coa_core::realms::Mode::Coa];
|
||||
if coa_core::realms::state(&root)?.wildcard_created { modes.push(coa_core::realms::Mode::Wildcard); }
|
||||
for mode in modes {
|
||||
let db = db.clone().for_realm(mode);
|
||||
let saved = db.load()?.into_iter().find(|row| row.id == migration.id && row.db == migration.db).expect("Published repair must already be applied");
|
||||
assert_eq!(saved.status, Status::Applied);
|
||||
let counts = db.query("SELECT CONCAT((SELECT COUNT(*) FROM acore_characters.characters),':',(SELECT COUNT(*) FROM acore_characters.item_instance),':',(SELECT COUNT(*) FROM acore_auth.account));")?;
|
||||
let check = || -> Result<()> {
|
||||
for hash in hashes {
|
||||
db.put(&LedgerRow { sha256: hash.into(), ..saved.clone() })?;
|
||||
let observed = Observed { db: &db, executions: AtomicUsize::new(0) };
|
||||
migrations::preflight(&db, std::slice::from_ref(migration))?;
|
||||
let report = migrations::apply_pending(&observed, std::slice::from_ref(migration), &root.join(".unused-hotfix-sql"), &|| panic!("Already applied SQL needs no snapshot"))?;
|
||||
assert!(report.applied.is_empty());
|
||||
assert_eq!(observed.executions.load(Ordering::SeqCst), 0);
|
||||
assert_eq!(db.load()?.into_iter().find(|r| r.id == migration.id && r.db == migration.db).unwrap().sha256, hash);
|
||||
}
|
||||
let meta = test_meta.path();
|
||||
let file_hash = coa_core::fsx::sha256_file(&root.join("Core/worldserver.exe"))?;
|
||||
let install_hash = coa_core::fsx::sha256_file(&meta.join("install.json"))?;
|
||||
let transaction_count = std::fs::read_dir(meta.join("updates"))?.count();
|
||||
for status in [Status::Running, Status::Failed] {
|
||||
db.put(&LedgerRow { status, ..saved.clone() })?;
|
||||
let env = coa_core::update::RepackEnv { root: &root, meta_dir: meta };
|
||||
let rejected = coa_core::update::apply(&coa_core::update::Params {
|
||||
root: &root, meta_dir: meta, source: Source::Dir(PathBuf::from(&args[1])),
|
||||
trusted_key: coa_core::signing::EMBEDDED_PUBLIC_KEY, cancel: Default::default(),
|
||||
resolutions: Default::default(), env: &env, fail_after_ops: None,
|
||||
}, &|_, _| {});
|
||||
let message = rejected.unwrap_err().to_string();
|
||||
assert!(message.contains("partially applied"), "Unexpected rejection: {message}");
|
||||
assert_eq!(std::fs::read_dir(meta.join("updates"))?.count(), transaction_count);
|
||||
assert_eq!(coa_core::fsx::sha256_file(&root.join("Core/worldserver.exe"))?, file_hash);
|
||||
assert_eq!(coa_core::fsx::sha256_file(&meta.join("install.json"))?, install_hash);
|
||||
}
|
||||
db.put(&saved)?;
|
||||
let env = coa_core::update::RepackEnv { root: &root, meta_dir: meta };
|
||||
let pending_before = env.pending_migrations(&package)?;
|
||||
db.query("DELETE FROM acore_world.coa_manager_migrations WHERE db='characters' AND id='manager_repair__20261005_missing_wildcard_tables';")?;
|
||||
assert_eq!(env.pending_migrations(&package)?, pending_before + 1,
|
||||
"Missing history in either realm must remain visible even with identical server files");
|
||||
db.put(&saved)?;
|
||||
assert_eq!(env.pending_migrations(&package)?, pending_before);
|
||||
Ok(())
|
||||
};
|
||||
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(check));
|
||||
db.put(&saved)?;
|
||||
result.map_err(|_| coa_core::Error::Invalid("History regression assertion failed; the injected ledger row was restored.".into()))??;
|
||||
assert_eq!(db.query("SELECT CONCAT((SELECT COUNT(*) FROM acore_characters.characters),':',(SELECT COUNT(*) FROM acore_characters.item_instance),':',(SELECT COUNT(*) FROM acore_auth.account));")?, counts);
|
||||
println!("PASS: {} published checksums; Running/Failed rejected before staging; missing migration counted; zero SQL replays; history and player counts preserved", mode.name());
|
||||
}
|
||||
Ok(())
|
||||
});
|
||||
assert!(coa_core::driver::run(&root, coa_core::driver::Verb::StopAll)?.ok);
|
||||
result?;
|
||||
Ok(())
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
//! Read-only update preview against the marked disposable acceptance fixture.
|
||||
use std::{collections::BTreeMap,path::PathBuf};
|
||||
fn main()->coa_core::Result<()> {
|
||||
let args:Vec<_>=std::env::args().skip(1).collect();
|
||||
let root=PathBuf::from(&args[0]);
|
||||
assert!(root.file_name().unwrap().to_string_lossy().starts_with("coa-schema-fixture-chaos-064-transition-"));
|
||||
assert_eq!(std::fs::read(root.join(".transition-fixture"))?,b"disposable published-064 transition fixture");
|
||||
let meta_dir=coa_core::registry::metadata_dir_for(&root)?;
|
||||
let (_,meta)=coa_core::registry::MetaDir::open(&meta_dir)?;
|
||||
let preview=coa_core::update::preview(&root,&meta,&coa_core::pkgsource::Source::Dir(args[1].clone().into()),coa_core::signing::EMBEDDED_PUBLIC_KEY,&BTreeMap::new())?;
|
||||
assert_eq!(preview.from_version.as_deref(),Some(preview.to_version.as_str()));
|
||||
assert_eq!(preview.pending_migrations,0);
|
||||
assert!(preview.items.iter().all(|item|item.action==coa_core::update::Action::Skip),"{:?}",preview.items.iter().filter(|item|item.action!=coa_core::update::Action::Skip).collect::<Vec<_>>());
|
||||
println!("PASS: real fixture repeated preview: {} files unchanged, zero pending SQL, no update offered",preview.items.len());
|
||||
Ok(())
|
||||
}
|
||||
@@ -0,0 +1,165 @@
|
||||
//! Real signed-package transition on an independent, explicitly marked disposable copy.
|
||||
//! The Env wrapper instruments only launcher isolation; migration/backup/update code is production code.
|
||||
use std::{collections::BTreeMap, path::{Path, PathBuf}};
|
||||
use coa_core::{backup, driver, fsx, migrations, pkgsource::{self, Source}, registry::{InstallMeta, MetaDir}, update::{self, Env, RepackEnv}, Result};
|
||||
|
||||
struct Offline<'a>(RepackEnv<'a>);
|
||||
impl Env for Offline<'_> {
|
||||
fn ensure_stopped(&self) -> Result<()> { self.0.ensure_stopped() }
|
||||
fn preflight(&self, m: &coa_core::manifest::Manifest) -> Result<()> { self.0.preflight(m) }
|
||||
fn verify_snapshot(&self, id: &str) -> Result<()> { self.0.verify_snapshot(id) }
|
||||
fn snapshot(&self) -> Result<String> { self.0.snapshot() }
|
||||
fn restore_snapshot(&self, id: &str) -> Result<()> { self.0.restore_snapshot(id) }
|
||||
fn migrate(&self, m: &coa_core::manifest::Manifest, p: &Path) -> Result<migrations::ApplyReport> { self.0.migrate(m,p) }
|
||||
fn validate(&self) -> Result<()> {
|
||||
let path=self.0.root.join("Scripts/manage.py");
|
||||
let source=std::fs::read_to_string(&path)?.replace("\r\n", "\n");
|
||||
// Explicit test instrumentation prevents relay transmissions and binds services locally.
|
||||
let guarded=source.replace("def spawn(name, command, cwd, log):\n", "def spawn(name, command, cwd, log):\n for filename in ('worldserver.conf', 'authserver.conf'):\n path = ROOT / 'Core/configs' / filename\n if path.exists():\n text = path.read_text(encoding='utf-8-sig')\n for key, value in (('BindIP', '\"127.0.0.1\"'), ('Ra.IP', '\"127.0.0.1\"'), ('SOAP.Enabled', '0')):\n text = re.sub(r'(?m)^\\s*' + re.escape(key) + r'\\s*=.*$', '', text)\n text += '\\n' + key + ' = ' + value + '\\n'\n path.write_text(text, encoding='utf-8')\n").replace("def relay_worker():\n", "def relay_worker():\n save_process('relay-ready', os.getpid())\n while not (STATE / 'stop-relay').exists():\n time.sleep(0.5)\n return\n");
|
||||
assert_ne!(source,guarded,"Fixture launcher isolation failed");
|
||||
fsx::atomic_write(&path,guarded.as_bytes())?;
|
||||
self.0.validate()
|
||||
}
|
||||
}
|
||||
fn players(db: &coa_core::db::Db) -> Result<String> {
|
||||
db.query("SELECT CONCAT(id,':',username,':',HEX(salt),':',HEX(verifier)) FROM acore_auth.account WHERE id=900001; SELECT CONCAT(guid,':',account,':',name,':',level,':',money) FROM acore_characters.characters WHERE guid=900001; SELECT CONCAT(guid,':',itemEntry,':',owner_guid,':',enchantments) FROM acore_characters.item_instance WHERE guid=900001; SELECT CONCAT(guid,':',bag,':',slot,':',item) FROM acore_characters.character_inventory WHERE guid=900001;")
|
||||
}
|
||||
fn main() -> Result<()> {
|
||||
let args:Vec<_>=std::env::args().skip(1).collect();
|
||||
let root=PathBuf::from(&args[0]);
|
||||
assert!(root.file_name().unwrap().to_string_lossy().starts_with("coa-schema-fixture-chaos-064-transition-"));
|
||||
assert_eq!(std::fs::read(root.join(".transition-fixture"))?,b"disposable published-064 transition fixture");
|
||||
if args.get(3).is_some_and(|mode| mode=="legacy-recovery") {
|
||||
return run_fixture(&root,||legacy_recovery(&root));
|
||||
}
|
||||
assert!(!root.join(".transition-started").exists(),"Use a new independent fixture");
|
||||
fsx::atomic_write(&root.join(".transition-started"),b"started")?;
|
||||
let meta=coa_core::registry::metadata_dir_for(&root)?;
|
||||
assert!(!meta.exists(),"Do not reuse experimental or user metadata");
|
||||
run_fixture(&root,||exercise(&root,&meta,&args[1],&args[2]))
|
||||
}
|
||||
fn run_fixture(root:&Path,operation:impl FnOnce()->Result<()>)->Result<()> {
|
||||
let result=std::panic::catch_unwind(std::panic::AssertUnwindSafe(operation));
|
||||
assert!(driver::run(root,driver::Verb::StopAll)?.ok,"Fixture shutdown failed");
|
||||
result.map_err(|_|coa_core::Error::Invalid("Disposable acceptance assertion failed; services were stopped and recovery copies retained.".into()))?
|
||||
}
|
||||
fn legacy_recovery(root:&Path)->Result<()> {
|
||||
let meta=coa_core::registry::metadata_dir_for(root)?;
|
||||
assert!(driver::run(root,driver::Verb::StopAll)?.ok);
|
||||
let expected=backup::with_database(root,|db| [coa_core::realms::Mode::Coa,coa_core::realms::Mode::Wildcard].into_iter().map(|mode|players(&db.clone().for_realm(mode))).collect::<Result<Vec<_>>>())?;
|
||||
assert!(driver::run(root,driver::Verb::StopAll)?.ok);
|
||||
let dirs=std::fs::read_dir(meta.join("updates"))?.collect::<std::io::Result<Vec<_>>>()?;
|
||||
assert_eq!(dirs.len(),1,"Requires exactly the preceding successful disposable transition");
|
||||
let txn_dir=dirs[0].path();
|
||||
let journal=txn_dir.join("txn.json");
|
||||
let mut legacy:serde_json::Value=fsx::read_json(&journal)?;
|
||||
assert_eq!(legacy["state"],"committed");
|
||||
let point=legacy["recovery_point"].as_str().unwrap().to_string();
|
||||
let point_path=meta.join("backups").join(&point).join("backup.json");
|
||||
let mut point_json:serde_json::Value=fsx::read_json(&point_path)?;
|
||||
point_json["manager_version"]="0.6.4".into();
|
||||
for component in point_json["components"].as_array_mut().unwrap() { component.as_object_mut().unwrap().remove("file_sha256"); }
|
||||
fsx::atomic_write_json(&point_path,&point_json)?;
|
||||
legacy.as_object_mut().unwrap().remove("recovery_hashes");
|
||||
legacy.as_object_mut().unwrap().remove("databases_started");
|
||||
legacy["state"]="applied".into();
|
||||
fsx::atomic_write_json(&journal,&legacy)?;
|
||||
assert!(update::ensure_recovered(&meta).is_err(),"Legacy unfinished update must block startup");
|
||||
let id=legacy["id"].as_str().unwrap();
|
||||
let env=RepackEnv {root,meta_dir:&meta};
|
||||
println!("Recovering legacy-format transaction and recovery point on disposable installation");
|
||||
assert_eq!(update::rollback(root,&meta,id,&env)?.state,update::State::RolledBack);
|
||||
for op in legacy["ops"].as_array().unwrap() {
|
||||
let relative=op["path"].as_str().unwrap();
|
||||
if op["had_previous"]==true {
|
||||
assert_eq!(fsx::sha256_file(&fsx::safe_join(root,relative)?)?,fsx::sha256_file(&fsx::safe_join(&txn_dir.join("before"),relative)?)?,"Legacy file restoration mismatch: {relative}");
|
||||
} else { assert!(!fsx::safe_join(root,relative)?.exists()); }
|
||||
}
|
||||
assert_eq!(std::fs::read(meta.join("install.json"))?,std::fs::read(txn_dir.join("before/manager-install.json"))?);
|
||||
backup::with_database(root,|db| {
|
||||
for (index,mode) in [coa_core::realms::Mode::Coa,coa_core::realms::Mode::Wildcard].into_iter().enumerate() {
|
||||
let db=db.clone().for_realm(mode);
|
||||
assert_eq!(players(&db)?,expected[index]);
|
||||
assert_eq!(db.query("SELECT COUNT(*) FROM acore_world.coa_manager_migrations WHERE id IN ('manager_repair__20261005_reconcile_wildcard_tables','manager_repair__20261005_reconcile_missing_class_starts');")?,"0");
|
||||
assert_eq!(db.query("SELECT sha256 FROM acore_world.coa_manager_migrations WHERE id='manager_repair__20261005_missing_wildcard_tables';")?,"9e4a36245c3f83255415c122c01f08ceb3e3b83898d3d427ac4e2fbcf61e9638");
|
||||
}
|
||||
Ok(())
|
||||
})?;
|
||||
assert!(driver::run(root,driver::Verb::StopAll)?.ok);
|
||||
assert!(update::pending_checked(&meta)?.is_none());
|
||||
assert!(update::rollback(root,&meta,id,&env).is_err(),"Completed recovery must not run again");
|
||||
println!("PASS: legacy journal blocked startup; old files, metadata, migration histories and player fields restored; completed recovery rejects replay. Original baseline had a missing table, so healthy startup is not claimed after rollback.");
|
||||
Ok(())
|
||||
}
|
||||
fn exercise(root:&Path,meta:&Path,baseline:&str,candidate:&str)->Result<()> {
|
||||
let mut install:InstallMeta=fsx::read_json(&PathBuf::from("C:/games/coa-schema-fixture-chaos-20261005-v1.manager/install.json"))?;
|
||||
install.server_path=root.to_string_lossy().into_owned();
|
||||
install.id=uuid::Uuid::new_v4().to_string();
|
||||
install.manager_version="0.6.4".into();
|
||||
MetaDir::create(root,&install)?;
|
||||
// Private ports, and no inherited PID records or paths to the source database.
|
||||
let mut cfg:serde_json::Value=fsx::read_json(&root.join("Settings/repack.json"))?;
|
||||
let mut listeners=Vec::new();
|
||||
for key in ["mysqlPort","authPort","worldPort","raPort"] {
|
||||
let listener=std::net::TcpListener::bind("127.0.0.1:0")?;
|
||||
cfg[key]=listener.local_addr()?.port().into(); listeners.push(listener);
|
||||
}
|
||||
fsx::atomic_write_json(&root.join("Settings/repack.json"),&cfg)?;
|
||||
let mut profile:serde_json::Value=fsx::read_json(&root.join("Settings/realm-profile.json"))?;
|
||||
for key in ["secondary_world_port","secondary_ra_port"] {
|
||||
let listener=std::net::TcpListener::bind("127.0.0.1:0")?;
|
||||
profile[key]=listener.local_addr()?.port().into(); listeners.push(listener);
|
||||
}
|
||||
fsx::atomic_write_json(&root.join("Settings/realm-profile.json"),&profile)?;
|
||||
drop(listeners);
|
||||
let state=root.join(".state");
|
||||
if state.exists() { std::fs::remove_dir_all(&state)?; }
|
||||
let secondary_state=root.join(".realms/secondary/.state");
|
||||
if secondary_state.exists() { std::fs::remove_dir_all(&secondary_state)?; }
|
||||
let source=Source::Dir(baseline.into());
|
||||
let (manifest,_)=pkgsource::fetch_manifest(&source,coa_core::signing::EMBEDDED_PUBLIC_KEY)?;
|
||||
let temp=tempfile::tempdir()?;
|
||||
let parts=pkgsource::fetch_parts(&source,&manifest,&temp.path().join("download"),&Default::default(),&|_,_|{})?;
|
||||
let tree=temp.path().join("tree");
|
||||
coa_core::package::extract(&parts,&manifest,&tree,&|_,_|{})?;
|
||||
for file in &manifest.files {
|
||||
if file.path.starts_with("_migrations/") {continue;}
|
||||
fsx::atomic_write(&fsx::safe_join(root,&file.path)?,&std::fs::read(fsx::safe_join(&tree,&file.path)?)?)?;
|
||||
install.original_hashes.insert(file.path.clone(),file.sha256.clone());
|
||||
}
|
||||
install.core.version=Some(manifest.version);
|
||||
fsx::atomic_write_json(&meta.join("install.json"),&install)?;
|
||||
// Both worlds must remain local, including generated secondary configuration.
|
||||
for relative in ["Settings/worldserver.conf.template","Settings/authserver.conf.template"] {
|
||||
let p=root.join(relative);
|
||||
let mut conf=coa_core::config::parser::ConfFile::parse_bytes(&std::fs::read(&p)?)?;
|
||||
conf.set("BindIP","\"127.0.0.1\"",&[]); conf.set("Ra.IP","\"127.0.0.1\"",&[]); conf.set("SOAP.Enabled","0",&[]);
|
||||
fsx::atomic_write(&p,conf.to_text().as_bytes())?;
|
||||
}
|
||||
let expected=backup::with_database(root,|db| {
|
||||
let mut saved=Vec::new();
|
||||
for mode in [coa_core::realms::Mode::Coa,coa_core::realms::Mode::Wildcard] {
|
||||
let db=db.clone().for_realm(mode);
|
||||
saved.push(players(&db)?);
|
||||
db.query("DROP TABLE IF EXISTS acore_characters.coa_wildcard_skill_card; DELETE FROM acore_world.coa_manager_migrations WHERE id IN ('manager_repair__20261005_reconcile_wildcard_tables','manager_repair__20261005_reconcile_missing_class_starts'); UPDATE acore_world.coa_manager_migrations SET sha256='9e4a36245c3f83255415c122c01f08ceb3e3b83898d3d427ac4e2fbcf61e9638' WHERE id='manager_repair__20261005_missing_wildcard_tables' AND status='applied';")?;
|
||||
}
|
||||
Ok(saved)
|
||||
})?;
|
||||
let source=Source::Dir(candidate.into());
|
||||
let candidate_manifest=pkgsource::fetch_manifest(&source,coa_core::signing::EMBEDDED_PUBLIC_KEY)?.0;
|
||||
let choices:BTreeMap<_,_>=update::plan(root,&install,&candidate_manifest,&BTreeMap::new(),None)?.into_iter().filter(|p|p.action==update::Action::Conflict).map(|p|(p.path,update::Resolution::Replace)).collect();
|
||||
let env=Offline(RepackEnv{root,meta_dir:meta});
|
||||
let outcome=update::apply(&update::Params {root,meta_dir:meta,source,trusted_key:coa_core::signing::EMBEDDED_PUBLIC_KEY,cancel:Default::default(),resolutions:choices,env:&env,fail_after_ops:None},&|stage,pct|println!("{pct}% {stage}"))?;
|
||||
assert_eq!(outcome.txn.state,update::State::Committed,"{:?}",outcome.txn.message);
|
||||
backup::with_database(root,|db| {
|
||||
for (index,mode) in [coa_core::realms::Mode::Coa,coa_core::realms::Mode::Wildcard].into_iter().enumerate() {
|
||||
let db=db.clone().for_realm(mode);
|
||||
assert_eq!(players(&db)?,expected[index],"Player data changed in {}",mode.name());
|
||||
assert!(coa_core::schema_check::check(&db,root)?.is_empty());
|
||||
assert_eq!(migrations::pending_count(&db,&candidate_manifest.migrations)?,0);
|
||||
}
|
||||
Ok(())
|
||||
})?;
|
||||
println!("PASS: signed historical package to candidate; missing Wildcard table repaired in both realms; player fields and inventory preserved; schema and startup verified. Launcher isolation was test instrumentation, not packaged UI acceptance.");
|
||||
Ok(())
|
||||
}
|
||||
@@ -51,7 +51,7 @@ pub struct Component {
|
||||
pub sha256: Option<String>,
|
||||
pub tables: Option<usize>,
|
||||
pub files: Option<Vec<String>>,
|
||||
#[serde(default, skip_serializing_if = "std::collections::BTreeMap::is_empty")]
|
||||
#[serde(default)]
|
||||
pub file_sha256: std::collections::BTreeMap<String, String>,
|
||||
}
|
||||
|
||||
@@ -93,8 +93,7 @@ pub fn list(meta: &Path) -> Vec<RecoveryPoint> {
|
||||
}
|
||||
|
||||
pub fn get(meta: &Path, id: &str) -> Result<RecoveryPoint> {
|
||||
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")))?;
|
||||
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")))?;
|
||||
if point.id != id || point.schema != 1 { return Err(Error::Invalid(format!("Backup {id} has inconsistent identity or an unsupported schema."))); }
|
||||
Ok(point)
|
||||
}
|
||||
@@ -137,7 +136,6 @@ 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
|
||||
}
|
||||
|
||||
@@ -149,11 +147,10 @@ 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)?;
|
||||
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));
|
||||
let content = fs::read(&src)?;
|
||||
fsx::atomic_write(&dst, &content)?;
|
||||
bytes += content.len() as u64;
|
||||
file_sha256.insert(rel.clone(), fsx::sha256_bytes(&content));
|
||||
}
|
||||
Ok(Component { name: "configs".into(), path: "files".into(), bytes, sha256: None, tables: None, files: Some(files), file_sha256 })
|
||||
}
|
||||
@@ -255,7 +252,7 @@ pub fn create(root: &Path, meta: &Path, kind: Kind, trigger: Trigger, label: Opt
|
||||
components,
|
||||
};
|
||||
fsx::atomic_write_json(&partial.join("backup.json"), &point)?;
|
||||
fsx::durable_replace(&partial, &final_dir)?;
|
||||
fs::rename(&partial, &final_dir)?;
|
||||
tracing::info!(%id, ?kind, ?trigger, "recovery point created");
|
||||
if trigger == Trigger::Automatic {
|
||||
prune_automatic(meta, 10);
|
||||
@@ -284,8 +281,21 @@ 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) => {}
|
||||
@@ -294,14 +304,16 @@ pub fn verify(meta: &Path, id: &str) -> Result<VerifyReport> {
|
||||
},
|
||||
(None, Some(files)) => {
|
||||
for f in files {
|
||||
if !c.file_sha256.is_empty() && !c.file_sha256.contains_key(f) { problems.push(format!("configuration file {f} lacks its checksum")); }
|
||||
if !fsx::safe_join(&path, f).map(|p| p.is_file()).unwrap_or(false) {
|
||||
problems.push(format!("configuration file {f} is missing"));
|
||||
} else if let Some(expected) = c.file_sha256.get(f) {
|
||||
if fsx::sha256_file(&fsx::safe_join(&path, f)?).ok().as_deref() != Some(expected.as_str()) { problems.push(format!("configuration file {f} is damaged")); }
|
||||
let file = fsx::ensure_within(&dir, &fsx::safe_join(&path, f)?)?;
|
||||
if fsx::sha256_file(&file)?.as_str() != expected { problems.push(format!("configuration file {f} is damaged")); }
|
||||
}
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
_ => problems.push(format!("{} lacks an integrity inventory", c.name)),
|
||||
}
|
||||
}
|
||||
Ok(VerifyReport { ok: problems.is_empty(), problems })
|
||||
@@ -309,8 +321,7 @@ 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<()> {
|
||||
// A damaged journal cannot reliably identify which copies recovery needs.
|
||||
// Preserve every available point until the installation is consistent.
|
||||
let _lock = crate::update::operation_lock(meta)?;
|
||||
crate::update::ensure_recovered(meta)?;
|
||||
if crate::update::unfinished(meta).is_some_and(|t| t.recovery_point.as_deref() == Some(id)) {
|
||||
return Err(Error::Invalid("This recovery point is required by an unfinished update and cannot be deleted.".into()));
|
||||
@@ -340,20 +351,6 @@ 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.
|
||||
@@ -365,14 +362,6 @@ 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()));
|
||||
@@ -388,48 +377,21 @@ fn restore_database_inner(root: &Path, meta: &Path, id: &str, name: &str, safety
|
||||
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 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() };
|
||||
let stamp = uuid::Uuid::new_v4().simple().to_string()[..16].to_string();
|
||||
|
||||
// 1. Safety copy of the current state, so even a wrong restore is reversible.
|
||||
let safety = if safety_copy { Some(create(root, meta, Kind::Database, Trigger::BeforeRestore, Some(format!("before restoring {name} from {id}")), &|_| {})?.id) } else { None };
|
||||
let safety = create(root, meta, Kind::Database, Trigger::BeforeRestore, Some(format!("before restoring {name} from {id}")), &|_| {})?;
|
||||
|
||||
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 safety_copy && (db.schema_exists(&staging)? || db.schema_exists(&old)?) {
|
||||
if 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()) {
|
||||
@@ -449,11 +411,7 @@ fn restore_database_inner(root: &Path, meta: &Path, id: &str, name: &str, safety
|
||||
renames.push(format!("`{staging}`.`{t}` TO `{live}`.`{t}`"));
|
||||
}
|
||||
if !renames.is_empty() { db.query(&format!("RENAME TABLE {};", renames.join(", ")))?; }
|
||||
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() })
|
||||
Ok(DbRestore { previous_schema: old, safety_backup: safety.id.clone(), tables_restored: staged.len() })
|
||||
})
|
||||
}
|
||||
|
||||
@@ -475,15 +433,33 @@ mod tests {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn corrupt_update_journal_preserves_available_backups() {
|
||||
fn backup_deletion_obeys_the_installation_lock() {
|
||||
let (_d, root, meta) = setup();
|
||||
let point = create(&root, &meta, Kind::Config, Trigger::Manual, None, &|_| {}).unwrap();
|
||||
let lock = crate::update::operation_lock(&meta).unwrap();
|
||||
assert!(delete(&meta, &point.id).is_err());
|
||||
assert!(get(&meta, &point.id).is_ok());
|
||||
drop(lock);
|
||||
delete(&meta, &point.id).unwrap();
|
||||
assert!(get(&meta, &point.id).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn damaged_configuration_is_detected_before_restore_and_copies_are_retained() {
|
||||
let (_d, root, meta) = setup();
|
||||
let point = create(&root, &meta, Kind::Config, Trigger::Automatic, None, &|_| {}).unwrap();
|
||||
let updates = meta.join("updates").join("interrupted");
|
||||
fs::create_dir_all(&updates).unwrap();
|
||||
fs::write(updates.join("txn.json"), b"{damaged").unwrap();
|
||||
let file = point_dir(&meta, &point.id).unwrap().join("files/Core/configs/worldserver.conf");
|
||||
fs::write(&file, b"corrupted").unwrap();
|
||||
assert!(!verify(&meta, &point.id).unwrap().ok);
|
||||
let original = fs::read(root.join("Core/configs/worldserver.conf")).unwrap();
|
||||
assert!(restore_configs(&root, &meta, &point.id).is_err());
|
||||
assert_eq!(fs::read(root.join("Core/configs/worldserver.conf")).unwrap(), original);
|
||||
assert_eq!(list(&meta).len(), 1);
|
||||
fs::create_dir_all(meta.join("updates/broken")).unwrap();
|
||||
fs::write(meta.join("updates/broken/txn.json"), b"{damaged").unwrap();
|
||||
assert!(delete(&meta, &point.id).is_err());
|
||||
prune_automatic(&meta, 0);
|
||||
assert!(get(&meta, &point.id).is_ok());
|
||||
assert!(file.exists());
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -89,9 +89,6 @@ 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()))?;
|
||||
@@ -268,7 +265,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()?; w.get_ref().sync_all() });
|
||||
let finish = enc.finish().and_then(|mut w| w.flush());
|
||||
let status = child.wait()?;
|
||||
let stderr_bytes = err_thread.join().unwrap_or_default();
|
||||
if !status.success() {
|
||||
@@ -283,8 +280,6 @@ 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()));
|
||||
|
||||
@@ -249,14 +249,6 @@ 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)
|
||||
}
|
||||
|
||||
@@ -31,8 +31,9 @@ impl Verb {
|
||||
}
|
||||
}
|
||||
|
||||
fn timeout(self) -> Duration {
|
||||
fn timeout(self, root: &Path) -> Duration {
|
||||
match self {
|
||||
Verb::StartAll | Verb::StartWorld if squid_enabled(root) => Duration::from_secs(2700),
|
||||
Verb::StartAll | Verb::StartWorld => Duration::from_secs(420),
|
||||
Verb::StartMysql => Duration::from_secs(120),
|
||||
Verb::StopAll => Duration::from_secs(240),
|
||||
@@ -40,6 +41,14 @@ impl Verb {
|
||||
}
|
||||
}
|
||||
|
||||
fn squid_enabled(root: &Path) -> bool {
|
||||
let active = root.join("Core/configs/modules/playerbots.conf");
|
||||
let path = if active.exists() { active } else { root.join("Core/configs/modules/playerbots.conf.dist") };
|
||||
std::fs::read(path).ok().and_then(|bytes| crate::config::parser::ConfFile::parse_bytes(&bytes).ok())
|
||||
.is_some_and(|config| config.get("AiPlayerbot.Enabled").is_none_or(|value|
|
||||
!matches!(value.trim().trim_matches('"').to_ascii_lowercase().as_str(), "0" | "false" | "no" | "off")))
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize)]
|
||||
pub struct DriverOutcome {
|
||||
pub ok: bool,
|
||||
@@ -81,41 +90,20 @@ 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, false)
|
||||
run_inner(root, verb, false)
|
||||
}
|
||||
|
||||
pub(crate) fn validate_update(root: &Path) -> Result<DriverOutcome> {
|
||||
run_inner(root, Verb::StartAll, true, true)
|
||||
run_inner(root, Verb::StartAll, true)
|
||||
}
|
||||
|
||||
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> {
|
||||
fn run_inner(root: &Path, verb: Verb, validating_update: 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::recover_before_start(&root, &crate::registry::metadata_dir_for(&root)?)?;
|
||||
crate::update::ensure_recovered(&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) {
|
||||
@@ -136,8 +124,7 @@ fn run_inner(root: &Path, verb: Verb, validating_update: bool, offline: bool) ->
|
||||
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 imported = patch_launcher_imports(&original)?;
|
||||
let patched = if offline { offline_launcher(&imported)? } else { imported };
|
||||
let patched = patch_launcher_imports(&original)?;
|
||||
if original != patched {
|
||||
fsx::atomic_write(&script, patched.as_bytes())?;
|
||||
if let Ok(dir) = crate::registry::metadata_dir_for(&root) {
|
||||
@@ -150,10 +137,8 @@ fn run_inner(root: &Path, verb: Verb, validating_update: bool, offline: bool) ->
|
||||
}
|
||||
}
|
||||
let mut cmd = Command::new(&python);
|
||||
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())
|
||||
cmd.arg("-B").arg("-c").arg(LAUNCH_SCRIPT).arg(&script).arg(verb.arg())
|
||||
.current_dir(&root).stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::piped());
|
||||
if offline { cmd.env("COA_UPDATE_VALIDATION", "1"); }
|
||||
#[cfg(windows)]
|
||||
{
|
||||
use std::os::windows::process::CommandExt;
|
||||
@@ -173,7 +158,7 @@ fn run_inner(root: &Path, verb: Verb, validating_update: bool, offline: bool) ->
|
||||
let _ = stderr.read_to_string(&mut s);
|
||||
s
|
||||
});
|
||||
let deadline = Instant::now() + verb.timeout();
|
||||
let deadline = Instant::now() + verb.timeout(&root);
|
||||
let status = loop {
|
||||
if let Some(st) = child.try_wait()? {
|
||||
break Some(st);
|
||||
@@ -203,10 +188,7 @@ fn run_inner(root: &Path, verb: Verb, validating_update: bool, offline: bool) ->
|
||||
}
|
||||
};
|
||||
tracing::info!(?verb, ok, ?code, "driver: launcher verb finished");
|
||||
if ok && verb == Verb::StartAll {
|
||||
if offline { crate::multiworld::start_validation(&root)?; }
|
||||
else { crate::multiworld::start(&root)?; }
|
||||
}
|
||||
if ok && verb == Verb::StartAll { crate::multiworld::start(&root)?; }
|
||||
Ok(DriverOutcome { ok, exit_code, code, human: code.map(ErrorCode::human), output })
|
||||
}
|
||||
|
||||
@@ -225,11 +207,24 @@ 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));
|
||||
@@ -244,6 +239,18 @@ 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);
|
||||
|
||||
@@ -148,6 +148,10 @@ 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> {
|
||||
@@ -155,14 +159,10 @@ 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 {
|
||||
let listener = std::net::TcpListener::bind("127.0.0.1:0")?;
|
||||
scratch[k] = listener.local_addr()?.port().into();
|
||||
listeners.push(listener);
|
||||
scratch[k] = free_port()?.into();
|
||||
}
|
||||
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);
|
||||
|
||||
@@ -25,7 +25,6 @@ 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;
|
||||
@@ -40,8 +39,6 @@ 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;
|
||||
|
||||
@@ -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,14 +49,17 @@ 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;"
|
||||
))?;
|
||||
let out = self.query(&format!("SELECT `db`,`id`,`sha256`,`status`,`baseline`,COALESCE(HEX(`error`),'') FROM `{LEDGER_SCHEMA}`.`{LEDGER_TABLE}` ORDER BY `db`,`id`;"))?;
|
||||
self.load_readonly()
|
||||
}
|
||||
|
||||
fn load_readonly(&self) -> Result<Vec<LedgerRow>> {
|
||||
let out = if self.tables(LEDGER_SCHEMA)?.iter().any(|name| name == LEDGER_TABLE) {
|
||||
self.query(&format!("SELECT `db`,`id`,`sha256`,`status`,`baseline`,COALESCE(HEX(`error`),'') FROM `{LEDGER_SCHEMA}`.`{LEDGER_TABLE}` ORDER BY `db`,`id`;"))?
|
||||
} else { String::new() };
|
||||
let mut rows = Vec::new();
|
||||
// Files the core's own updater (or whoever prepared this database) already recorded count as applied.
|
||||
for (kind, schema) in db::SCHEMAS {
|
||||
@@ -152,7 +155,51 @@ 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(|h| h.eq_ignore_ascii_case(&row.sha256))
|
||||
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(())
|
||||
}
|
||||
|
||||
/// Record migrations as already present without running them (adopting an existing server whose database
|
||||
@@ -182,14 +229,7 @@ pub struct ApplyReport {
|
||||
pub fn apply_pending(store: &dyn Store, list: &[Migration], dir: &Path, snapshot: &dyn Fn() -> Result<String>) -> Result<ApplyReport> {
|
||||
let rows = store.load()?;
|
||||
// The list order is the release's order of application (released updates, then pending, then modules).
|
||||
for m in list {
|
||||
if recorded(&rows, m).is_some_and(|r| matches!(r.status, Status::Running | Status::Failed)) {
|
||||
return Err(Error::Invalid(format!("Database update {} ({}) failed or was interrupted and may be partially applied. Restore its recovery point before retrying.", m.id, m.db)));
|
||||
}
|
||||
if recorded(&rows, m).is_some_and(|r| hash_changed(r, m)) {
|
||||
return Err(Error::Invalid(format!("Applied database update {} ({}) has a different checksum. A new migration is required; it was not replayed.", m.id, m.db)));
|
||||
}
|
||||
}
|
||||
check_history(&rows, list)?;
|
||||
let todo: Vec<&Migration> = list.iter().filter(|m| recorded(&rows, m).is_none_or(|r| r.status != Status::Applied)).collect();
|
||||
tracing::info!(total = list.len(), pending = todo.len(), skipped = list.len() - todo.len(), "database migration plan");
|
||||
|
||||
@@ -197,17 +237,8 @@ pub fn apply_pending(store: &dyn Store, list: &[Migration], dir: &Path, snapshot
|
||||
let mut files = Vec::new();
|
||||
let mut any_destructive = false;
|
||||
for m in &todo {
|
||||
if !ident_ok(&m.id) {
|
||||
return Err(Error::InvalidManifest(format!("migration id {:?} is not allowed", m.id)));
|
||||
}
|
||||
let schema = db::schema_of(&m.db)?;
|
||||
let path = fsx::safe_join(dir, &format!("{}/{}.sql", m.db, m.id))?;
|
||||
let bytes = std::fs::read(&path).map_err(|_| Error::Invalid(format!("migration file {} is missing", m.id)))?;
|
||||
let actual = fsx::sha256_bytes(&bytes);
|
||||
if !actual.eq_ignore_ascii_case(&m.sha256) {
|
||||
return Err(Error::HashMismatch { path: path.display().to_string(), expected: m.sha256.clone(), actual });
|
||||
}
|
||||
any_destructive |= m.destructive || looks_destructive(&String::from_utf8_lossy(&bytes));
|
||||
let (schema, path, destructive) = verified_file(m, dir)?;
|
||||
any_destructive |= destructive;
|
||||
files.push((*m, schema, path));
|
||||
}
|
||||
|
||||
@@ -221,13 +252,10 @@ 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) => {
|
||||
@@ -312,16 +340,57 @@ mod tests {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn only_explicit_published_compatibility_skips_changed_hash_without_rewriting_history() {
|
||||
fn staged_files_reject_missing_corrupt_duplicate_and_invalid_migrations() {
|
||||
let (dir, list) = setup(&[("characters", "repair", "SELECT 1;\n")]);
|
||||
verify_files(&list, dir.path()).unwrap();
|
||||
let mut bad = list.clone();
|
||||
bad[0].id = "../outside".into();
|
||||
assert!(verify_files(&bad, dir.path()).is_err());
|
||||
bad = list.clone();
|
||||
bad.push(list[0].clone());
|
||||
assert!(verify_files(&bad, dir.path()).is_err());
|
||||
std::fs::write(dir.path().join("characters/repair.sql"), b"SELECT 2;\n").unwrap();
|
||||
assert!(verify_files(&list, dir.path()).is_err());
|
||||
std::fs::remove_file(dir.path().join("characters/repair.sql")).unwrap();
|
||||
assert!(verify_files(&list, dir.path()).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn preflight_uses_readonly_history_and_rejects_conflicts_without_writes() {
|
||||
struct ReadOnly<'a>(&'a Mem);
|
||||
impl Store for ReadOnly<'_> {
|
||||
fn load(&self) -> Result<Vec<LedgerRow>> { panic!("preflight must use readonly access") }
|
||||
fn load_readonly(&self) -> Result<Vec<LedgerRow>> { self.0.load() }
|
||||
fn put(&self, _: &LedgerRow) -> Result<()> { panic!("preflight must not rewrite history") }
|
||||
fn run_file(&self, _: &str, _: &Path) -> Result<()> { panic!("preflight must not run SQL") }
|
||||
}
|
||||
let (_d, list) = setup(&[("characters", "repair", "SELECT 1;\n")]);
|
||||
for state in [Status::Applied, Status::Running, Status::Failed] {
|
||||
let store = Mem::default();
|
||||
store.rows.borrow_mut().push(LedgerRow { db: "characters".into(), id: "repair".into(), sha256: "a".repeat(64), status: state, error: None, baseline: false });
|
||||
assert!(preflight(&ReadOnly(&store), &list).is_err());
|
||||
assert_eq!(store.rows.borrow()[0].sha256, "a".repeat(64));
|
||||
assert_eq!(store.rows.borrow()[0].status, state);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn published_compatibility_preserves_history_and_never_replays_sql() {
|
||||
let (d, mut list) = setup(&[("characters", "repair", "SELECT 1;\n")]);
|
||||
let store = Mem::default();
|
||||
let 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 });
|
||||
let old = fsx::sha256_bytes(b"SELECT 1;\r\n");
|
||||
store.rows.borrow_mut().push(LedgerRow { db: "characters".into(), id: "repair".into(), sha256: old.clone(), status: Status::Applied, error: None, baseline: false });
|
||||
assert!(apply_pending(&store, &list, d.path(), &no_snapshot).is_err());
|
||||
list[0].compatible_sha256.push(previous.clone());
|
||||
list[0].compatible_sha256.push(old.clone());
|
||||
assert_eq!(status(&store, &list).unwrap()[0].status, Status::Applied);
|
||||
assert!(apply_pending(&store, &list, d.path(), &no_snapshot).unwrap().applied.is_empty());
|
||||
assert!(store.ran.borrow().is_empty());
|
||||
assert_eq!(store.rows.borrow()[0].sha256, previous);
|
||||
assert_eq!(store.rows.borrow()[0].sha256, old);
|
||||
store.rows.borrow_mut()[0].status = Status::Running;
|
||||
assert!(apply_pending(&store, &list, d.path(), &no_snapshot).is_err());
|
||||
store.rows.borrow_mut()[0].status = Status::Failed;
|
||||
assert!(apply_pending(&store, &list, d.path(), &no_snapshot).is_err());
|
||||
assert!(store.ran.borrow().is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -125,14 +125,6 @@ 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);
|
||||
@@ -140,7 +132,7 @@ fn start_inner(main: &Path, offline: bool) -> Result<()> {
|
||||
return Err(Error::Invalid("The second realm is still starting or stopping.".into()));
|
||||
}
|
||||
let second = prepare(main)?;
|
||||
let out = if offline { driver::validate_secondary(&second)? } else { driver::run(&second, Verb::StartWorld)? };
|
||||
let out = driver::run(&second, Verb::StartWorld)?;
|
||||
if !out.ok { return Err(Error::Invalid(format!("The second realm did not start: {}", out.output))); }
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -4,8 +4,6 @@
|
||||
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};
|
||||
@@ -22,77 +20,6 @@ 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 {
|
||||
@@ -117,8 +44,11 @@ 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 pinned = fetch_package(source, trusted_key)?;
|
||||
Ok((pinned.manifest, pinned.bytes))
|
||||
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))
|
||||
}
|
||||
|
||||
/// Make every archive part available in a verified folder: a local source is used in place, a remote one is
|
||||
|
||||
@@ -287,25 +287,35 @@ pub fn prepare_launcher(root: &Path) -> Result<()> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
const LAUNCHER_REALM_REPLACEMENTS: &[(&str, &str)] = &[
|
||||
("(\"WorldDatabaseInfo\", \"acore_world\")", "(\"WorldDatabaseInfo\", \"acore_world_wildcard\" if coa_realm() == 'wildcard' else \"acore_world\")"),
|
||||
("(\"CharacterDatabaseInfo\", \"acore_characters\")", "(\"CharacterDatabaseInfo\", \"acore_characters_wildcard\" if coa_realm() == 'wildcard' else \"acore_characters\")"),
|
||||
("SET name='AzerothCore',address=", "SET name='{coa_realm_name()}',address="),
|
||||
("WHERE id=1;", "WHERE id={coa_realm_id()};"),
|
||||
("mysql(\"UPDATE acore_auth.realmlist SET flag=0", "mysql(f\"UPDATE acore_auth.realmlist SET flag=0"),
|
||||
];
|
||||
|
||||
const LAUNCHER_REALM_INSERT: &str = "# coa-manager-realm-profiles-v1\ndef coa_realm():\n path = ROOT / 'Settings/realm-profile.json'\n return json.loads(path.read_text(encoding='utf-8')).get('active', 'coa') if path.exists() else 'coa'\n\ndef coa_realm_id():\n return 2 if coa_realm() == 'wildcard' else 1\n\ndef coa_realm_name():\n return 'Wildcard' if coa_realm() == 'wildcard' else 'Conquest of Azeroth'\n\n";
|
||||
|
||||
pub(crate) fn patch_launcher(source: &str) -> Result<String> {
|
||||
if source.contains("# coa-manager-realm-profiles-v1") { return Ok(source.into()); }
|
||||
let replacements = [
|
||||
("(\"WorldDatabaseInfo\", \"acore_world\")", "(\"WorldDatabaseInfo\", \"acore_world_wildcard\" if coa_realm() == 'wildcard' else \"acore_world\")"),
|
||||
("(\"CharacterDatabaseInfo\", \"acore_characters\")", "(\"CharacterDatabaseInfo\", \"acore_characters_wildcard\" if coa_realm() == 'wildcard' else \"acore_characters\")"),
|
||||
("SET name='AzerothCore',address=", "SET name='{coa_realm_name()}',address="),
|
||||
("WHERE id=1;", "WHERE id={coa_realm_id()};"),
|
||||
("mysql(\"UPDATE acore_auth.realmlist SET flag=0", "mysql(f\"UPDATE acore_auth.realmlist SET flag=0"),
|
||||
];
|
||||
let mut out = source.to_string();
|
||||
for (from, to) in replacements {
|
||||
for &(from, to) in LAUNCHER_REALM_REPLACEMENTS {
|
||||
if !out.contains(from) { return Err(Error::Invalid("This launcher does not support realm profiles. Update the server package first.".into())); }
|
||||
out = out.replace(from, to);
|
||||
}
|
||||
let insert = "# coa-manager-realm-profiles-v1\ndef coa_realm():\n path = ROOT / 'Settings/realm-profile.json'\n return json.loads(path.read_text(encoding='utf-8')).get('active', 'coa') if path.exists() else 'coa'\n\ndef coa_realm_id():\n return 2 if coa_realm() == 'wildcard' else 1\n\ndef coa_realm_name():\n return 'Wildcard' if coa_realm() == 'wildcard' else 'Conquest of Azeroth'\n\n";
|
||||
// Insert before the entry point so ROOT, json and functions are all defined when called.
|
||||
let marker = "if __name__ == \"__main__\":";
|
||||
if !out.contains(marker) { return Err(Error::Invalid("Unrecognised server launcher entry point.".into())); }
|
||||
Ok(out.replace(marker, &format!("{insert}{marker}")))
|
||||
Ok(out.replace(marker, &format!("{LAUNCHER_REALM_INSERT}{marker}")))
|
||||
}
|
||||
|
||||
/// Reverse only our exact realm transformation; callers must verify the recovered original hash.
|
||||
pub(crate) fn unpatch_launcher(source: &str) -> Option<String> {
|
||||
if !source.contains(LAUNCHER_REALM_INSERT) { return None; }
|
||||
let mut original = source.replacen(LAUNCHER_REALM_INSERT, "", 1);
|
||||
for &(from, to) in LAUNCHER_REALM_REPLACEMENTS { original = original.replace(to, from); }
|
||||
patch_launcher(&original).ok().filter(|patched| patched == source).map(|_| original)
|
||||
}
|
||||
|
||||
pub fn before_start(root: &Path) -> Result<()> {
|
||||
|
||||
@@ -13,7 +13,6 @@ 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).
|
||||
@@ -50,7 +49,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 { compatible_sha256: vec![], db: db.into(), id, origin, abs, sha256 });
|
||||
out.push(SqlFile { 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"])] {
|
||||
@@ -93,13 +92,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 { 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 });
|
||||
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 });
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
fn to_migrations(files: &[SqlFile]) -> Vec<Migration> {
|
||||
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()
|
||||
files.iter().map(|f| Migration { compatible_sha256: vec![], id: f.id.clone(), db: f.db.clone(), sha256: f.sha256.clone(), destructive: false }).collect()
|
||||
}
|
||||
|
||||
pub struct UpdateParams<'a> {
|
||||
@@ -227,7 +226,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 { 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 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 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"));
|
||||
|
||||
@@ -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 { compatible_sha256: vec![], db: kind.into(), id: format!("manager_repair__{stem}"), origin: format!("{kind}/{stem}.sql"), sha256: fsx::sha256_file(&path)?, abs: path });
|
||||
files.push(SqlFile { 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: f.compatible_sha256.clone(), db: f.db.clone(), id: f.id.clone(), sha256: f.sha256.clone(), destructive: false }).collect();
|
||||
let migrations: Vec<_> = sql.iter().map(|f| Migration { compatible_sha256: vec![], db: f.db.clone(), id: f.id.clone(), sha256: f.sha256.clone(), destructive: false }).collect();
|
||||
for file in sql {
|
||||
let path = fsx::safe_join(staging.path(), &format!("{}/{}.sql", file.db, file.id))?;
|
||||
fsx::atomic_write(&path, &std::fs::read(&file.abs)?)?;
|
||||
|
||||
+409
-771
File diff suppressed because it is too large.
Load diff
@@ -7,7 +7,4 @@ 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"] }
|
||||
@@ -46,65 +46,6 @@ 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")?),
|
||||
@@ -118,8 +59,7 @@ 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 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)?; }
|
||||
let sql = coa_core::release_schema::collect(&PathBuf::from(core), bots.as_deref(), repairs.as_deref()).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)?;
|
||||
@@ -137,8 +77,7 @@ 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 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 sql = coa_core::release_schema::collect(&PathBuf::from(need(&a, "core")?), bots.as_deref(), repairs.as_deref()).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 },
|
||||
|
||||
@@ -1,94 +0,0 @@
|
||||
# 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.
|
||||
@@ -1,61 +0,0 @@
|
||||
# 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.
|
||||
@@ -1,3 +0,0 @@
|
||||
[toolchain]
|
||||
channel = "1.98.1"
|
||||
profile = "minimal"
|
||||
+11
-27
@@ -697,28 +697,7 @@ 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)?;
|
||||
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)?)?)
|
||||
Ok(update::pending_checked(&meta_dir(&root)?)?)
|
||||
}
|
||||
|
||||
#[tauri::command]
|
||||
@@ -728,14 +707,22 @@ async fn apply_update(
|
||||
id: String,
|
||||
source: Option<String>,
|
||||
resolutions: BTreeMap<String, Resolution>,
|
||||
) -> std::result::Result<update::ExecutionResult, UiError> {
|
||||
) -> std::result::Result<update::Outcome, 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::execute(
|
||||
update::apply(
|
||||
&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 }));
|
||||
@@ -1582,9 +1569,6 @@ pub fn run() {
|
||||
create_account,
|
||||
check_update,
|
||||
pending_update,
|
||||
recover_update,
|
||||
last_update,
|
||||
last_update_result,
|
||||
apply_update,
|
||||
rollback_update,
|
||||
retry_update_validation,
|
||||
|
||||
+2
-3
@@ -46,9 +46,8 @@ 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,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==="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==="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."}]};
|
||||
|
||||
@@ -371,7 +371,6 @@ 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",
|
||||
|
||||
@@ -404,7 +404,6 @@ 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",
|
||||
|
||||
@@ -371,7 +371,6 @@ 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",
|
||||
|
||||
@@ -371,7 +371,6 @@ 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",
|
||||
|
||||
@@ -402,7 +402,6 @@ const ru: Partial<Record<keyof typeof en, string>> = {
|
||||
"upd.backNote": "Возврат восстанавливает файлы и настройки. Если обновление баз уже началось, все базы также восстанавливаются из копии перед обновлением. Более поздний прогресс будет потерян.",
|
||||
"upd.goBackTo": "Вернуться к версии {v}",
|
||||
"upd.goBackBefore": "Вернуться к версии до обновления",
|
||||
"upd.autoRestored": "Обновление не прошло проверку. Прежний сервер автоматически восстановлен.",
|
||||
"upd.title": "Обновления сервера",
|
||||
"upd.text": "Подлинность обновлений проверяется, перед ними делается резервная копия, и их можно отменить.",
|
||||
"upd.check": "Проверить обновления",
|
||||
|
||||
@@ -383,7 +383,6 @@ const zh = {
|
||||
"upd.backNote": "回滚将恢复文件和设置。如果数据库更新已开始,所有数据库也将从更新前的备份恢复。之后的进度将丢失。",
|
||||
"upd.goBackTo": "回滚至版本 {v}",
|
||||
"upd.goBackBefore": "回滚至更新前的版本",
|
||||
"upd.autoRestored": "更新验证失败。之前的服务器已自动恢复。",
|
||||
"upd.title": "服务器更新",
|
||||
"upd.text": "更新均经过真实性签名校验,并在执行前自动备份,随时可安全撤销。",
|
||||
"upd.check": "检查更新",
|
||||
|
||||
+3
-17
@@ -95,12 +95,6 @@ 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;
|
||||
@@ -276,23 +270,18 @@ export interface UpdatePreview {
|
||||
items: UpdatePlanItem[];
|
||||
conflicts: string[];
|
||||
migrations: number;
|
||||
pending_migrations?: number;
|
||||
download_bytes: number;
|
||||
}
|
||||
|
||||
export interface UpdateTxn {
|
||||
id: string;
|
||||
state: "prepared" | "stopping" | "snapshotting" | "trialing" | "applying" | "applied" | "migrating" | "validating" | "committing" | "restoring" | "needs-decision" | "committed" | "rolled-back" | "failed";
|
||||
failure_stage?: UpdateTxn["state"];
|
||||
state: "prepared" | "applying" | "applied" | "needs-decision" | "committed" | "rolled-back" | "failed";
|
||||
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 {
|
||||
@@ -441,11 +430,8 @@ 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<UpdateExecutionResult>("apply_update", { id, source: source ?? null, resolutions }),
|
||||
lastUpdateResult: (id: string) => invoke<UpdateExecutionResult | null>("last_update_result", { id }),
|
||||
invoke<{ txn: UpdateTxn }>("apply_update", { id, source: source ?? null, resolutions }),
|
||||
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 }),
|
||||
|
||||
+30
-29
@@ -1,6 +1,7 @@
|
||||
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,
|
||||
@@ -16,11 +17,13 @@ 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 } | { recovered: UpdateTxn } | null;
|
||||
result: { committed: string } | { pending: UpdateTxn } | null;
|
||||
}
|
||||
|
||||
const EMPTY: ServerUpdateState = { preview: null, available: false, checking: false, applying: false, step: null, percent: 0, error: null, uiError: null, result: 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 states = new Map<string, ServerUpdateState>();
|
||||
const listeners = new Set<() => void>();
|
||||
export const CHECK_EVERY_MS = 5 * 60 * 1000;
|
||||
@@ -37,10 +40,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: p.to_version !== (p.from_version ?? ""), error: null });
|
||||
set(id, { preview: p, available: !isUpdateCurrent(p), error: null });
|
||||
} catch (e) {
|
||||
// offline or no package published: keep what we knew and stay quiet
|
||||
set(id, { error: asUiError(e).human.code });
|
||||
// A cached offer is no longer safe after an update or failed recheck.
|
||||
set(id, { preview: null, available: false, error: asUiError(e).human.code });
|
||||
} finally {
|
||||
set(id, { checking: false });
|
||||
}
|
||||
@@ -48,21 +51,7 @@ 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 (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);
|
||||
})();
|
||||
void checkServerUpdate(id);
|
||||
const t = setInterval(() => void checkServerUpdate(id), CHECK_EVERY_MS);
|
||||
return () => clearInterval(t);
|
||||
}
|
||||
@@ -71,6 +60,20 @@ 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
|
||||
@@ -79,7 +82,8 @@ export function clearServerUpdateResult(id: string) {
|
||||
*/
|
||||
export async function applyServerUpdate(id: string, opts?: { choices: Record<string, "keep" | "replace">; source?: string }): Promise<boolean> {
|
||||
const p = get(id).preview;
|
||||
if (get(id).applying) return false;
|
||||
const current = get(id);
|
||||
if (current.applying || current.stateError || (current.result && "pending" in current.result)) 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;
|
||||
@@ -90,20 +94,17 @@ export async function applyServerUpdate(id: string, opts?: { choices: Record<str
|
||||
}
|
||||
try {
|
||||
const out = await api.applyUpdate(id, opts?.choices ?? {}, opts?.source);
|
||||
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;
|
||||
set(id, { result: out.txn.state === "committed" ? { committed: out.txn.to_version ?? "" } : { pending: out.txn } });
|
||||
return true;
|
||||
} 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);
|
||||
}
|
||||
|
||||
@@ -0,0 +1,7 @@
|
||||
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;
|
||||
}
|
||||
@@ -1,7 +1,8 @@
|
||||
import { useEffect, useState } from "react";
|
||||
import { open } from "@tauri-apps/plugin-dialog";
|
||||
import { ChevronDown, ChevronRight, Loader2 } from "lucide-react";
|
||||
import { applyServerUpdate, clearServerUpdateResult, useServerUpdate } from "@/lib/serverUpdate";
|
||||
import { applyServerUpdate, clearServerUpdateResult, refreshServerUpdateState, useServerUpdate } from "@/lib/serverUpdate";
|
||||
import { isUpdateCurrent } from "@/lib/serverUpdateStatus";
|
||||
import { api, asUiError, type UiError, type UpdatePreview, type UpdateTxn } from "@/lib/api";
|
||||
import { Button } from "@/components/ui/button";
|
||||
import { Card } from "@/components/ui/card";
|
||||
@@ -23,12 +24,14 @@ 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 = localError ?? upd.uiError;
|
||||
const error = pendingStateError ?? 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">>({});
|
||||
@@ -36,27 +39,36 @@ export function SettingsHome({ serverId }: { serverId: string }) {
|
||||
const [source, setSource] = useState("");
|
||||
|
||||
useEffect(() => {
|
||||
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)));
|
||||
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; };
|
||||
}, [serverId]);
|
||||
|
||||
// the update finished (possibly while another tab was open): drop the stale preview, show what is left to decide
|
||||
// Every finished attempt refreshes the disk state, including failures in the background.
|
||||
useEffect(() => {
|
||||
if (!upd.result) return;
|
||||
if (!upd.stateRevision) return;
|
||||
setPreview(null);
|
||||
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]);
|
||||
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; }
|
||||
}
|
||||
|
||||
async function check() {
|
||||
setBusy("check");
|
||||
@@ -65,6 +77,8 @@ 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])));
|
||||
@@ -76,12 +90,10 @@ 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) {
|
||||
@@ -95,6 +107,7 @@ export function SettingsHome({ serverId }: { serverId: string }) {
|
||||
} catch (e) {
|
||||
setError(asUiError(e));
|
||||
} finally {
|
||||
try { await refreshPending(); } catch { /* Keep the disk-state error visible. */ }
|
||||
setBusy(null);
|
||||
}
|
||||
}
|
||||
@@ -111,7 +124,10 @@ export function SettingsHome({ serverId }: { serverId: string }) {
|
||||
clearServerUpdateResult(serverId);
|
||||
} else setPending(result);
|
||||
} catch (e) { setError(asUiError(e)); }
|
||||
finally { setBusy(null); }
|
||||
finally {
|
||||
try { await refreshPending(); } catch { /* Keep the disk-state error visible. */ }
|
||||
setBusy(null);
|
||||
}
|
||||
}
|
||||
|
||||
async function browse() {
|
||||
@@ -179,28 +195,27 @@ export function SettingsHome({ serverId }: { serverId: string }) {
|
||||
</div>
|
||||
)}
|
||||
|
||||
{done && <p className="mt-4 text-sm text-ok" role="status">{done}</p>}
|
||||
{done && pendingChecked && !pendingStateError && <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 && 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.
|
||||
{preview && isUpdateCurrent(preview) && (
|
||||
<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 && !(preview.from_version === preview.to_version && preview.items.every((i) => i.action === "skip")) && (
|
||||
{preview && !isUpdateCurrent(preview) && (
|
||||
<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.migrations > 0
|
||||
? t("upd.summaryDb", { size: mb(preview.download_bytes), files: preview.items.filter((i) => i.action !== "skip").length, db: preview.migrations })
|
||||
{(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 })
|
||||
: 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">
|
||||
@@ -225,7 +240,7 @@ export function SettingsHome({ serverId }: { serverId: string }) {
|
||||
</li>
|
||||
))}
|
||||
</ul>
|
||||
<Button className="mt-4" variant="primary" disabled={!!busy} onClick={() => void update()}>
|
||||
<Button className="mt-4" variant="primary" disabled={!!busy || !pendingChecked || !!pendingStateError || !!pending} onClick={() => void update()}>
|
||||
{busy === "update" && <Loader2 className="h-4 w-4 animate-spin" aria-hidden />}
|
||||
{t("upd.now")}
|
||||
</Button>
|
||||
|
||||
@@ -0,0 +1,62 @@
|
||||
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; }
|
||||
});
|
||||
@@ -0,0 +1,18 @@
|
||||
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);
|
||||
});
|
||||
@@ -1,133 +0,0 @@
|
||||
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
|
||||
@@ -1,81 +0,0 @@
|
||||
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"
|
||||
Reference in new issue
Block a user