mirror of
https://github.com/Corfirean/coa-server-manager.git
synced 2026-11-19 11:25:56 +00:00
Compare commits
1
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
ab4bc9fd96 |
No files matched your search
@@ -12,16 +12,32 @@ permissions:
|
||||
|
||||
jobs:
|
||||
installer:
|
||||
runs-on: windows-latest
|
||||
timeout-minutes: 60
|
||||
runs-on: [self-hosted, Windows, X64, coa-update-acceptance]
|
||||
timeout-minutes: 1440
|
||||
steps:
|
||||
- uses: actions/checkout@v7
|
||||
- uses: actions/setup-node@v4
|
||||
with:
|
||||
node-version: 22
|
||||
node-version: 26.10.0
|
||||
- run: npm ci
|
||||
- name: Tests
|
||||
run: cargo test --workspace -- --test-threads=1
|
||||
run: cargo test --workspace --locked -- --test-threads=1
|
||||
- name: Windows server upgrade and recovery gate
|
||||
shell: pwsh
|
||||
env:
|
||||
GH_TOKEN: ${{ github.token }}
|
||||
run: |
|
||||
cargo build -p coa-release --locked
|
||||
if ($LASTEXITCODE) { throw 'Verification tools failed to build.' }
|
||||
gh release download base --repo Corfirean/coa-server-build --dir _acceptance-base
|
||||
if ($LASTEXITCODE) { throw 'Signed base download failed.' }
|
||||
& target/debug/coa-release.exe resolve --source https://github.com/Corfirean/coa-server-build/releases/download/edge --out _candidate-manifest.json
|
||||
if ($LASTEXITCODE) { throw 'Cannot pin the candidate server release.' }
|
||||
$version = (Get-Content _candidate-manifest.json -Raw | ConvertFrom-Json).version
|
||||
gh release download "server-$version" --repo Corfirean/coa-server-build --dir _acceptance-candidate
|
||||
if ($LASTEXITCODE) { throw 'Candidate download failed.' }
|
||||
& tools/update-chaos-matrix.ps1 -BasePackage _acceptance-base -CandidatePackage _acceptance-candidate
|
||||
if ($LASTEXITCODE) { throw 'Update/recovery acceptance failed; manager will not be published.' }
|
||||
- name: Build, sign and publish
|
||||
uses: tauri-apps/tauri-action@v0
|
||||
env:
|
||||
@@ -32,7 +48,29 @@ jobs:
|
||||
tagName: ${{ github.ref_name }}
|
||||
releaseName: CoA Server Manager ${{ github.ref_name }}
|
||||
releaseBody: See the assets to download the installer. Existing installations update themselves.
|
||||
releaseDraft: false
|
||||
releaseDraft: true
|
||||
prerelease: false
|
||||
args: --bundles nsis
|
||||
includeUpdaterJson: true
|
||||
- name: Verify the exact packaged installer
|
||||
shell: pwsh
|
||||
run: |
|
||||
$installer = Get-ChildItem target/release/bundle/nsis/*-setup.exe | Select-Object -First 1
|
||||
if (-not $installer) { throw 'Built installer is missing.' }
|
||||
$destination = Join-Path $env:RUNNER_TEMP ('coa-manager-installer-' + [guid]::NewGuid().ToString('N'))
|
||||
$process = Start-Process -FilePath $installer.FullName -ArgumentList @('/S', "/D=$destination") -WindowStyle Hidden -Wait -PassThru
|
||||
if ($process.ExitCode) { throw 'Silent installer failed.' }
|
||||
$installed = Join-Path $destination 'coa-server-manager.exe'
|
||||
if (-not (Test-Path $installed)) { throw 'Installed manager binary is missing.' }
|
||||
if ((Get-FileHash $installed).Hash -ne (Get-FileHash target/release/coa-server-manager.exe).Hash) { throw 'Installer contains a different manager binary.' }
|
||||
$report = @{ installerSha256 = (Get-FileHash $installer.FullName).Hash.ToLower(); managerSha256 = (Get-FileHash $installed).Hash.ToLower(); source = '${{ github.sha }}'; serverManifestSha256 = (Get-FileHash _acceptance-candidate/manifest.json).Hash.ToLower(); result = 'passed' }
|
||||
$report | ConvertTo-Json | Set-Content installer-acceptance.json -Encoding utf8NoBOM
|
||||
- name: Publish validated draft
|
||||
shell: pwsh
|
||||
env:
|
||||
GH_TOKEN: ${{ github.token }}
|
||||
run: |
|
||||
gh release upload '${{ github.ref_name }}' installer-acceptance.json --clobber
|
||||
if ($LASTEXITCODE) { throw 'Acceptance report upload failed.' }
|
||||
gh release edit '${{ github.ref_name }}' --draft=false
|
||||
if ($LASTEXITCODE) { throw 'Validated draft publication failed.' }
|
||||
Generated
+6
-3
@@ -491,7 +491,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "coa-core"
|
||||
version = "0.6.4"
|
||||
version = "0.6.5"
|
||||
dependencies = [
|
||||
"base64 0.22.1",
|
||||
"chrono",
|
||||
@@ -519,16 +519,19 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "coa-release"
|
||||
version = "0.6.4"
|
||||
version = "0.6.5"
|
||||
dependencies = [
|
||||
"base64 0.22.1",
|
||||
"chrono",
|
||||
"coa-core",
|
||||
"ed25519-dalek",
|
||||
"serde_json",
|
||||
"tempfile",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "coa-server-manager"
|
||||
version = "0.6.4"
|
||||
version = "0.6.5"
|
||||
dependencies = [
|
||||
"coa-core",
|
||||
"serde",
|
||||
|
||||
+1
-1
@@ -3,7 +3,7 @@ resolver = "2"
|
||||
members = ["crates/coa-core", "crates/coa-release", "src-tauri"]
|
||||
|
||||
[workspace.package]
|
||||
version = "0.6.4"
|
||||
version = "0.6.5"
|
||||
edition = "2021"
|
||||
license = "AGPL-3.0-only"
|
||||
|
||||
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: changed
|
||||
audience: admins
|
||||
title: Server updates are tested on a private copy and automatically restored after failure
|
||||
---
|
||||
Updates keep a fixed verified package, preserve migration history, and recover interrupted changes before starting the server. Recovery problems show a specific reason and keep the available backups.
|
||||
@@ -31,7 +31,7 @@ rand_core = { version = "0.6", features = ["getrandom"] }
|
||||
ed25519-dalek = { version = "2", features = ["rand_core"] }
|
||||
|
||||
[target.'cfg(windows)'.dependencies]
|
||||
windows-sys = { version = "0.60", features = ["Win32_Foundation", "Win32_System_Threading", "Win32_System_SystemInformation", "Win32_System_Diagnostics_ToolHelp", "Win32_NetworkManagement_IpHelper", "Win32_Networking_WinSock"] }
|
||||
windows-sys = { version = "0.60", features = ["Win32_Foundation", "Win32_Storage_FileSystem", "Win32_System_Threading", "Win32_System_SystemInformation", "Win32_System_Diagnostics_ToolHelp", "Win32_NetworkManagement_IpHelper", "Win32_Networking_WinSock"] }
|
||||
|
||||
[features]
|
||||
testkit = []
|
||||
@@ -29,7 +29,7 @@ fn main() {
|
||||
let dst = staging.join(db).join(format!("{id}.sql"));
|
||||
std::fs::create_dir_all(dst.parent().unwrap()).unwrap();
|
||||
std::fs::write(&dst, &bytes).unwrap();
|
||||
list.push(Migration { id, db: db.into(), sha256: fsx::sha256_bytes(&bytes), destructive: false });
|
||||
list.push(Migration { compatible_sha256: vec![], id, db: db.into(), sha256: fsx::sha256_bytes(&bytes), destructive: false });
|
||||
};
|
||||
for (kind, dirs) in [("auth", ["db_auth", "pending_db_auth"]), ("characters", ["db_characters", "pending_db_characters"]), ("world", ["db_world", "pending_db_world"])] {
|
||||
for d in dirs {
|
||||
|
||||
@@ -58,7 +58,7 @@ fn main() -> Result<()> {
|
||||
let path = staged.join(format!("{kind}/manager_realm_fixture.sql"));
|
||||
std::fs::create_dir_all(path.parent().unwrap())?;
|
||||
std::fs::write(&path, sql)?;
|
||||
manifest.migrations.push(Migration { id: "manager_realm_fixture".into(), db: kind.into(), sha256: coa_core::fsx::sha256_file(&path)?, destructive: false });
|
||||
manifest.migrations.push(Migration { compatible_sha256: vec![], id: "manager_realm_fixture".into(), db: kind.into(), sha256: coa_core::fsx::sha256_file(&path)?, destructive: false });
|
||||
}
|
||||
let result = env.migrate(&manifest, &staged)?;
|
||||
assert!(result.failed.is_none());
|
||||
|
||||
@@ -20,7 +20,7 @@ fn main() -> Result<()> {
|
||||
fsx::atomic_write(&update_tree.join(format!("_migrations/world/{id}.sql")), sql.as_bytes())?;
|
||||
let options = |kind, version: &str, migrations| BuildOptions { kind, version: version.into(), core_commit: None, built_at: "fixture".into(), part_size: 1 << 20, bots_commit: None, migrations };
|
||||
let base = package::build(&base_tree, &base_pkg, &options(Kind::Base, "1.0.0", vec![]), &|_| {})?;
|
||||
let update = package::build(&update_tree, &update_pkg, &options(Kind::Update, "1.0.1", vec![Migration { id: id.into(), db: "world".into(), sha256: fsx::sha256_bytes(sql.as_bytes()), destructive: false }]), &|_| {})?;
|
||||
let update = package::build(&update_tree, &update_pkg, &options(Kind::Update, "1.0.1", vec![Migration { compatible_sha256: vec![], id: id.into(), db: "world".into(), sha256: fsx::sha256_bytes(sql.as_bytes()), destructive: false }]), &|_| {})?;
|
||||
// A test-only trust key, unrelated to production signing material.
|
||||
let key = SigningKey::from_bytes(&[23; 32]);
|
||||
let public = STANDARD.encode(key.verifying_key().as_bytes());
|
||||
|
||||
@@ -33,7 +33,7 @@ fn main() {
|
||||
let sql = "CREATE TABLE IF NOT EXISTS coa_manager_update_test (id INT PRIMARY KEY); INSERT IGNORE INTO coa_manager_update_test VALUES (1);";
|
||||
put(&src, "_migrations/world/2026_09_30_00_update_e2e.sql", sql);
|
||||
let mut m = build(&src, &pkg, &BuildOptions { kind: Kind::Update, version: "0.2.0".into(), core_commit: None, built_at: chrono::Utc::now().to_rfc3339(), part_size: 1 << 20, bots_commit: None, migrations: vec![] }, &|_| {}).unwrap();
|
||||
m.migrations.push(Migration { id: "2026_09_30_00_update_e2e".into(), db: "world".into(), sha256: fsx::sha256_bytes(sql.as_bytes()), destructive: false });
|
||||
m.migrations.push(Migration { compatible_sha256: vec![], id: "2026_09_30_00_update_e2e".into(), db: "world".into(), sha256: fsx::sha256_bytes(sql.as_bytes()), destructive: false });
|
||||
std::fs::write(pkg.join("manifest.json"), serde_json::to_vec_pretty(&m).unwrap()).unwrap();
|
||||
let key = format!("{}/.coa-manager/signing/manifest-signing.key", std::env::var("USERPROFILE").unwrap());
|
||||
let seed: [u8; 32] = STANDARD.decode(std::fs::read_to_string(key).unwrap().trim()).unwrap().try_into().unwrap();
|
||||
|
||||
@@ -37,7 +37,7 @@ fn exercise(root: &Path) -> Result<()> {
|
||||
("world", "probe_world", "DROP TABLE manager_recovery_probe; THIS IS INTENTIONALLY INVALID SQL;"),
|
||||
] {
|
||||
fsx::atomic_write(&source.join(format!("_migrations/{db}/{id}.sql")), sql.as_bytes())?;
|
||||
migrations.push(Migration { db: db.into(), id: id.into(), sha256: fsx::sha256_bytes(sql.as_bytes()), destructive: false });
|
||||
migrations.push(Migration { compatible_sha256: vec![], db: db.into(), id: id.into(), sha256: fsx::sha256_bytes(sql.as_bytes()), destructive: false });
|
||||
}
|
||||
let pkg = root.join("fixture-package");
|
||||
let manifest = package::build(&source, &pkg, &BuildOptions {
|
||||
|
||||
@@ -22,7 +22,7 @@ fn main() -> Result<()> {
|
||||
let path = old_sql.join(format!("{name}.sql"));
|
||||
let hash = fsx::sha256_file(&path)?;
|
||||
db.put(&LedgerRow { db: "characters".into(), id: name.into(), sha256: hash.clone(), status: Status::Applied, error: None, baseline: false })?;
|
||||
migrations.push(Migration { db: "characters".into(), id: name.into(), sha256: hash, destructive: false });
|
||||
migrations.push(Migration { compatible_sha256: vec![], db: "characters".into(), id: name.into(), sha256: hash, destructive: false });
|
||||
}
|
||||
for (_, tables) in schema_check::WILDCARD_TABLES.iter().filter(|(kind,_)| *kind == "characters") {
|
||||
for table in *tables { db.query(&format!("DROP TABLE IF EXISTS acore_characters.`{table}`;"))?; }
|
||||
@@ -33,7 +33,7 @@ fn main() -> Result<()> {
|
||||
let files = release_schema::collect(empty_core.path(), None, Some(&repairs))?;
|
||||
assert_eq!(files.len(), 1);
|
||||
let repair = &files[0];
|
||||
migrations.push(Migration { db: repair.db.clone(), id: repair.id.clone(), sha256: repair.sha256.clone(), destructive: false });
|
||||
migrations.push(Migration { compatible_sha256: vec![], db: repair.db.clone(), id: repair.id.clone(), sha256: repair.sha256.clone(), destructive: false });
|
||||
let staged = tree.path().join("sql/characters");
|
||||
fsx::atomic_write(&staged.join(format!("{}.sql", repair.id)), &std::fs::read(&repair.abs)?)?;
|
||||
let report = migrations::apply_pending(&db, &migrations, &tree.path().join("sql"), &|| Ok("disposable fixture".into()))?;
|
||||
|
||||
@@ -51,6 +51,8 @@ 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")]
|
||||
pub file_sha256: std::collections::BTreeMap<String, String>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
@@ -91,7 +93,10 @@ pub fn list(meta: &Path) -> Vec<RecoveryPoint> {
|
||||
}
|
||||
|
||||
pub fn get(meta: &Path, id: &str) -> Result<RecoveryPoint> {
|
||||
fsx::read_json(&point_dir(meta, id)?.join("backup.json")).map_err(|_| Error::Invalid(format!("backup {id} was not found")))
|
||||
let path = fsx::ensure_within(meta, &point_dir(meta, id)?.join("backup.json"))?;
|
||||
let point: RecoveryPoint = fsx::read_json(&path).map_err(|_| Error::Invalid(format!("backup {id} was not found or its metadata is damaged")))?;
|
||||
if point.id != id || point.schema != 1 { return Err(Error::Invalid(format!("Backup {id} has inconsistent identity or an unsupported schema."))); }
|
||||
Ok(point)
|
||||
}
|
||||
|
||||
/// Files that make up "configuration": everything a user or the Manager may have changed, minus secrets.
|
||||
@@ -132,6 +137,7 @@ pub fn config_files(root: &Path) -> Vec<String> {
|
||||
walk(root, &root.join("Settings/realm-profiles"), &mut out);
|
||||
if root.join("Settings/realm-profile.json").is_file() { out.push("Settings/realm-profile.json".into()); }
|
||||
out.sort();
|
||||
out.dedup();
|
||||
out
|
||||
}
|
||||
|
||||
@@ -139,13 +145,17 @@ fn copy_configs(root: &Path, dir: &Path) -> Result<Component> {
|
||||
let files = config_files(root);
|
||||
let target = dir.join("files");
|
||||
let mut bytes = 0;
|
||||
let mut file_sha256 = std::collections::BTreeMap::new();
|
||||
for rel in &files {
|
||||
let src = fsx::safe_join(root, rel)?;
|
||||
let dst = fsx::safe_join(&target, rel)?;
|
||||
fs::create_dir_all(dst.parent().unwrap())?;
|
||||
bytes += fs::copy(&src, &dst)?;
|
||||
let contents = fs::read(&src)?;
|
||||
fsx::atomic_write(&dst, &contents)?;
|
||||
bytes += contents.len() as u64;
|
||||
file_sha256.insert(rel.clone(), fsx::sha256_bytes(&contents));
|
||||
}
|
||||
Ok(Component { name: "configs".into(), path: "files".into(), bytes, sha256: None, tables: None, files: Some(files) })
|
||||
Ok(Component { name: "configs".into(), path: "files".into(), bytes, sha256: None, tables: None, files: Some(files), file_sha256 })
|
||||
}
|
||||
|
||||
/// Make sure the database is up for `f`. If we had to start it (and nothing else is running), stop it again.
|
||||
@@ -215,7 +225,7 @@ pub fn create(root: &Path, meta: &Path, kind: Kind, trigger: Trigger, label: Opt
|
||||
let tables = db.tables(schema)?.len();
|
||||
let file = format!("{name}.sql.zst");
|
||||
let (bytes, sha) = db.dump_to(schema, &partial.join(&file))?;
|
||||
Ok(Component { name, path: file, bytes, sha256: Some(sha), tables: Some(tables), files: None })
|
||||
Ok(Component { name, path: file, bytes, sha256: Some(sha), tables: Some(tables), files: None, file_sha256: Default::default() })
|
||||
})?;
|
||||
components.push(component);
|
||||
}
|
||||
@@ -245,7 +255,7 @@ pub fn create(root: &Path, meta: &Path, kind: Kind, trigger: Trigger, label: Opt
|
||||
components,
|
||||
};
|
||||
fsx::atomic_write_json(&partial.join("backup.json"), &point)?;
|
||||
fs::rename(&partial, &final_dir)?;
|
||||
fsx::durable_replace(&partial, &final_dir)?;
|
||||
tracing::info!(%id, ?kind, ?trigger, "recovery point created");
|
||||
if trigger == Trigger::Automatic {
|
||||
prune_automatic(meta, 10);
|
||||
@@ -255,6 +265,7 @@ pub fn create(root: &Path, meta: &Path, kind: Kind, trigger: Trigger, label: Opt
|
||||
|
||||
/// Keep the newest `keep` automatic recovery points; manual and safety ones are never pruned.
|
||||
pub fn prune_automatic(meta: &Path, keep: usize) {
|
||||
if crate::update::ensure_recovered(meta).is_err() { return; }
|
||||
let autos: Vec<_> = list(meta).into_iter().filter(|p| p.trigger == Trigger::Automatic).collect();
|
||||
for p in autos.into_iter().skip(keep) {
|
||||
if let Ok(dir) = point_dir(meta, &p.id) {
|
||||
@@ -274,7 +285,7 @@ pub fn verify(meta: &Path, id: &str) -> Result<VerifyReport> {
|
||||
let dir = point_dir(meta, id)?;
|
||||
let mut problems = Vec::new();
|
||||
for c in &point.components {
|
||||
let path = dir.join(&c.path);
|
||||
let path = fsx::ensure_within(&dir, &fsx::safe_join(&dir, &c.path)?)?;
|
||||
match (&c.sha256, &c.files) {
|
||||
(Some(sha), _) => match fsx::sha256_file(&path) {
|
||||
Ok(actual) if actual.eq_ignore_ascii_case(sha) => {}
|
||||
@@ -285,6 +296,8 @@ pub fn verify(meta: &Path, id: &str) -> Result<VerifyReport> {
|
||||
for f in files {
|
||||
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")); }
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -296,6 +309,9 @@ 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.
|
||||
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()));
|
||||
}
|
||||
@@ -324,6 +340,20 @@ pub fn restore_configs(root: &Path, meta: &Path, id: &str) -> Result<RecoveryPoi
|
||||
Ok(safety)
|
||||
}
|
||||
|
||||
/// Transaction recovery has already protected the original state. Do not require a second backup.
|
||||
pub(crate) fn restore_update_configs(root: &Path, meta: &Path, id: &str) -> Result<()> {
|
||||
let point = get(meta, id)?;
|
||||
if !verify(meta, id)?.ok { return Err(Error::Invalid("The update recovery point is damaged.".into())); }
|
||||
let comp = point.components.iter().find(|c| c.name == "configs").ok_or_else(|| Error::Invalid("The update recovery point has no configuration.".into()))?;
|
||||
if comp.files.as_deref().unwrap_or_default().iter().any(|file| !comp.file_sha256.contains_key(file)) {
|
||||
return Err(Error::Invalid("This legacy recovery point has no configuration checksums. Automatic recovery cannot verify the original settings; copies were preserved for inspection.".into()));
|
||||
}
|
||||
for rel in comp.files.as_deref().unwrap_or_default() {
|
||||
fsx::atomic_write(&fsx::ensure_within(root, &fsx::safe_join(root, rel)?)?, &fs::read(fsx::safe_join(&point_dir(meta, id)?.join(&comp.path), rel)?)?)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize)]
|
||||
pub struct DbRestore {
|
||||
/// The database the restore replaced, kept intact under this name.
|
||||
@@ -335,6 +365,14 @@ pub struct DbRestore {
|
||||
/// Restore one database from a recovery point without dropping anything:
|
||||
/// import into a staging schema, sanity-check it, then swap tables atomically and keep the old schema.
|
||||
pub fn restore_database(root: &Path, meta: &Path, id: &str, name: &str) -> Result<DbRestore> {
|
||||
restore_database_inner(root, meta, id, name, true)
|
||||
}
|
||||
|
||||
pub(crate) fn restore_update_database(root: &Path, meta: &Path, id: &str, name: &str) -> Result<DbRestore> {
|
||||
restore_database_inner(root, meta, id, name, false)
|
||||
}
|
||||
|
||||
fn restore_database_inner(root: &Path, meta: &Path, id: &str, name: &str, safety_copy: bool) -> Result<DbRestore> {
|
||||
let point = get(meta, id)?;
|
||||
if point.realm != crate::realms::state(root)?.active {
|
||||
return Err(Error::Invalid("Select the realm this backup belongs to before restoring it.".into()));
|
||||
@@ -350,21 +388,48 @@ pub fn restore_database(root: &Path, meta: &Path, id: &str, name: &str) -> Resul
|
||||
let live = if name.contains('-') || name == "playerbots" { db::schema_of(name)? } else { point.realm.schema(name)? };
|
||||
let expected_tables = comp.tables.unwrap_or(0);
|
||||
let dump = point_dir(meta, id)?.join(&comp.path);
|
||||
let stamp = uuid::Uuid::new_v4().simple().to_string()[..16].to_string();
|
||||
let reconstructed_hash = point_dir(meta, id)?.join(format!("restore-{name}.sha256"));
|
||||
let stamp = if safety_copy { uuid::Uuid::new_v4().simple().to_string()[..16].to_string() }
|
||||
else { fsx::sha256_bytes(format!("update-recovery:{id}:{name}").as_bytes())[..16].to_string() };
|
||||
|
||||
// 1. Safety copy of the current state, so even a wrong restore is reversible.
|
||||
let safety = create(root, meta, Kind::Database, Trigger::BeforeRestore, Some(format!("before restoring {name} from {id}")), &|_| {})?;
|
||||
let safety = if safety_copy { Some(create(root, meta, Kind::Database, Trigger::BeforeRestore, Some(format!("before restoring {name} from {id}")), &|_| {})?.id) } else { None };
|
||||
|
||||
with_database(root, |db| {
|
||||
let db = db.clone().for_realm(crate::realms::Mode::Coa);
|
||||
let staging = format!("{live}_restore_{stamp}");
|
||||
let old = format!("{live}_before_restore_{stamp}");
|
||||
if db.schema_exists(&staging)? || db.schema_exists(&old)? {
|
||||
if safety_copy && (db.schema_exists(&staging)? || db.schema_exists(&old)?) {
|
||||
return Err(Error::Invalid("A previous restore left its work schemas behind; try again in a moment.".into()));
|
||||
}
|
||||
if !safety_copy {
|
||||
if db.schema_exists(&old)? {
|
||||
// RENAME TABLE is atomic. An empty staging schema proves that the old tables
|
||||
// were moved out and the complete restored set was moved into live together.
|
||||
if reconstructed_hash.is_file() && db.schema_exists(&staging)? && db.tables(&staging)?.is_empty() && db.tables(live)?.len() == expected_tables {
|
||||
db.query(&format!("DROP DATABASE `{old}`; DROP DATABASE `{staging}`;"))?;
|
||||
return Ok(DbRestore { previous_schema: old, safety_backup: String::new(), tables_restored: expected_tables });
|
||||
}
|
||||
// A server crash can interrupt a rename involving MyISAM tables.
|
||||
// The original dump was verified above and is authoritative: discard only
|
||||
// this recovery's deterministic work schemas and import a complete set again.
|
||||
db.query(&format!("DROP DATABASE `{old}`;"))?;
|
||||
}
|
||||
if db.schema_exists(&staging)? { db.query(&format!("DROP DATABASE `{staging}`;"))?; }
|
||||
}
|
||||
// 2. Import into staging.
|
||||
db.query(&format!("CREATE DATABASE `{staging}` CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;"))?;
|
||||
db.import_from(&staging, &dump)?;
|
||||
if !safety_copy {
|
||||
// SHOW CREATE TABLE can make implicit character sets explicit on import.
|
||||
// Compare live against the independently reconstructed snapshot, keeping all
|
||||
// schema and row bytes rather than accepting a table-count approximation.
|
||||
let check = point_dir(meta, id)?.join(format!("restore-{name}.sql.zst"));
|
||||
let (_, hash) = db.dump_to(&staging, &check)?;
|
||||
fsx::atomic_write(&reconstructed_hash, hash.as_bytes())?;
|
||||
fs::remove_file(check)?;
|
||||
}
|
||||
crate::update_fault::checkpoint(root, &format!("restore-database:{name}:imported"));
|
||||
// 3. Sanity checks.
|
||||
let staged = db.tables(&staging)?;
|
||||
if comp.tables.is_some_and(|expected| staged.len() != expected) || (comp.tables.is_none() && staged.is_empty()) {
|
||||
@@ -384,7 +449,11 @@ pub fn restore_database(root: &Path, meta: &Path, id: &str, name: &str) -> Resul
|
||||
renames.push(format!("`{staging}`.`{t}` TO `{live}`.`{t}`"));
|
||||
}
|
||||
if !renames.is_empty() { db.query(&format!("RENAME TABLE {};", renames.join(", ")))?; }
|
||||
Ok(DbRestore { previous_schema: old, safety_backup: safety.id.clone(), tables_restored: staged.len() })
|
||||
crate::update_fault::checkpoint(root, &format!("restore-database:{name}:swapped"));
|
||||
// For emergency recovery, completed temporary schemas are disposable. A crash before
|
||||
// cleanup leaves the original dump intact, and another recovery can repeat the swap.
|
||||
if !safety_copy { db.query(&format!("DROP DATABASE `{old}`; DROP DATABASE `{staging}`;"))?; }
|
||||
Ok(DbRestore { previous_schema: old, safety_backup: safety.clone().unwrap_or_default(), tables_restored: staged.len() })
|
||||
})
|
||||
}
|
||||
|
||||
@@ -405,6 +474,18 @@ mod tests {
|
||||
(dir, root, meta)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn corrupt_update_journal_preserves_available_backups() {
|
||||
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();
|
||||
assert!(delete(&meta, &point.id).is_err());
|
||||
prune_automatic(&meta, 0);
|
||||
assert!(get(&meta, &point.id).is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn config_backup_excludes_secrets_and_clutter_and_restores_byte_exact() {
|
||||
let (_d, root, meta) = setup();
|
||||
|
||||
@@ -181,7 +181,7 @@ pub fn build(p: &Params, say: &dyn Fn(&str)) -> Result<()> {
|
||||
if let Some(b) = p.bots {
|
||||
sql.extend(collect_bots_sql(b)?);
|
||||
}
|
||||
let migrations: Vec<_> = sql.iter().map(|f| crate::manifest::Migration { id: f.id.clone(), db: f.db.clone(), sha256: f.sha256.clone(), destructive: false }).collect();
|
||||
let migrations: Vec<_> = sql.iter().map(|f| crate::manifest::Migration { compatible_sha256: vec![], id: f.id.clone(), db: f.db.clone(), sha256: f.sha256.clone(), destructive: false }).collect();
|
||||
let staging = std::env::temp_dir().join("coa-cleanbase-sql");
|
||||
let _ = fs::remove_dir_all(&staging);
|
||||
for f in &sql {
|
||||
|
||||
@@ -89,6 +89,9 @@ pub(crate) fn credentials(root: &Path) -> Result<(String, String)> {
|
||||
}
|
||||
|
||||
impl Db {
|
||||
pub(crate) fn native_root(&self) -> Option<PathBuf> {
|
||||
if self.container.is_some() { None } else { self.bin.parent().and_then(|p| p.parent()).map(Path::to_path_buf) }
|
||||
}
|
||||
pub fn from_repack(root: &Path, account: Account) -> Result<Db> {
|
||||
let creds: Credentials = fsx::read_json(&root.join("Settings/database.json"))
|
||||
.map_err(|_| Error::Invalid("The database settings of this server could not be read.".into()))?;
|
||||
@@ -265,7 +268,7 @@ impl Db {
|
||||
let file = File::create(out)?;
|
||||
let mut enc = zstd::Encoder::new(BufWriter::new(file), 3)?;
|
||||
let copy = std::io::copy(&mut stdout, &mut enc);
|
||||
let finish = enc.finish().and_then(|mut w| w.flush());
|
||||
let finish = enc.finish().and_then(|mut w| { w.flush()?; w.get_ref().sync_all() });
|
||||
let status = child.wait()?;
|
||||
let stderr_bytes = err_thread.join().unwrap_or_default();
|
||||
if !status.success() {
|
||||
@@ -280,6 +283,8 @@ impl Db {
|
||||
|
||||
/// Run a plain SQL file against `schema`; the first error aborts and is returned.
|
||||
pub fn run_sql_file(&self, schema: &str, file: &Path) -> Result<()> {
|
||||
let injected = if let Some(root) = self.native_root() { crate::update_fault::failing_sql(&root, file)? } else { None };
|
||||
let file = injected.as_ref().map(|f| f.path()).unwrap_or(file);
|
||||
let schema = self.realm_schema(schema);
|
||||
if !ident_ok(schema) {
|
||||
return Err(Error::Invalid("bad schema name".into()));
|
||||
|
||||
@@ -249,6 +249,14 @@ pub fn export_package(root: &Path, meta_dir: &Path, manager_log: &Path, meta: &I
|
||||
if let Ok(b) = fs::read(meta_dir.join("logs/database-checks.json")) {
|
||||
add("database-checks.json", redact(&String::from_utf8_lossy(&b)).as_bytes())?;
|
||||
}
|
||||
if let Ok(b) = fs::read(meta_dir.join("logs/update-result.json")) {
|
||||
add("update-result.json", redact(&String::from_utf8_lossy(&b)).as_bytes())?;
|
||||
}
|
||||
if let Ok(Some(txn)) = crate::update::latest(meta_dir) {
|
||||
if let Ok(b) = fs::read(meta_dir.join("updates").join(&txn.id).join("diagnostic.json")) {
|
||||
add("update-diagnostic.json", redact(&String::from_utf8_lossy(&b)).as_bytes())?;
|
||||
}
|
||||
}
|
||||
zip.finish().map_err(|e| Error::Invalid(e.to_string()))?;
|
||||
Ok(n)
|
||||
}
|
||||
|
||||
@@ -81,20 +81,41 @@ fn launcher(root: &Path) -> Result<(PathBuf, PathBuf)> {
|
||||
|
||||
/// Run a launcher verb to completion (blocking; call from a worker thread).
|
||||
pub fn run(root: &Path, verb: Verb) -> Result<DriverOutcome> {
|
||||
run_inner(root, verb, false)
|
||||
run_inner(root, verb, false, false)
|
||||
}
|
||||
|
||||
pub(crate) fn validate_update(root: &Path) -> Result<DriverOutcome> {
|
||||
run_inner(root, Verb::StartAll, true)
|
||||
run_inner(root, Verb::StartAll, true, true)
|
||||
}
|
||||
|
||||
fn run_inner(root: &Path, verb: Verb, validating_update: bool) -> Result<DriverOutcome> {
|
||||
pub(crate) fn start_after_update(root: &Path) -> Result<DriverOutcome> {
|
||||
run_inner(root, Verb::StartAll, true, false)
|
||||
}
|
||||
|
||||
pub(crate) fn validate_secondary(root: &Path) -> Result<DriverOutcome> {
|
||||
run_inner(root, Verb::StartWorld, true, true)
|
||||
}
|
||||
|
||||
/// Validate without accepting game connections or submitting reports. Child supervisors inherit the flag.
|
||||
pub(crate) fn offline_launcher(text: &str) -> Result<String> {
|
||||
let normalized = text.replace("\r\n", "\n");
|
||||
let text = normalized.as_str();
|
||||
if text.contains("# coa-offline-validation") { return Ok(text.into()); }
|
||||
if !text.contains("def spawn(name, command, cwd, log):") || !text.contains("def relay_worker():") {
|
||||
return Err(Error::Invalid("This launcher cannot isolate an update validation. Update was not applied.".into()));
|
||||
}
|
||||
let spawn = "def spawn(name, command, cwd, log):\n # coa-offline-validation\n if os.environ.get('COA_UPDATE_VALIDATION') == '1':\n for filename in ('worldserver.conf', 'authserver.conf'):\n path = ROOT / 'Core/configs' / filename\n if path.exists():\n text = path.read_text(encoding='utf-8-sig')\n for key, value in (('BindIP', '\"127.0.0.1\"'), ('Ra.IP', '\"127.0.0.1\"'), ('SOAP.Enabled', '0')):\n text = re.sub(r'(?m)^\\s*' + re.escape(key) + r'\\s*=.*$', '', text)\n text += '\\n' + key + ' = ' + value + '\\n'\n path.write_text(text, encoding='utf-8')\n";
|
||||
let relay = "def relay_worker():\n if os.environ.get('COA_UPDATE_VALIDATION') == '1':\n save_process('relay-ready', os.getpid())\n while not (STATE / 'stop-relay').exists():\n time.sleep(0.5)\n return\n";
|
||||
Ok(text.replacen("def spawn(name, command, cwd, log):\n", spawn, 1).replacen("def relay_worker():\n", relay, 1))
|
||||
}
|
||||
|
||||
fn run_inner(root: &Path, verb: Verb, validating_update: bool, offline: bool) -> Result<DriverOutcome> {
|
||||
let root = fsx::canonicalize_lenient(root)?;
|
||||
let _update_lock = if !validating_update && matches!(verb, Verb::StartAll | Verb::StartWorld) {
|
||||
Some(crate::update::operation_lock(&crate::registry::metadata_dir_for(&root)?)?)
|
||||
} else { None };
|
||||
if !validating_update && matches!(verb, Verb::StartAll | Verb::StartWorld) {
|
||||
crate::update::ensure_recovered(&crate::registry::metadata_dir_for(&root)?)?;
|
||||
crate::update::recover_before_start(&root, &crate::registry::metadata_dir_for(&root)?)?;
|
||||
}
|
||||
if matches!(verb, Verb::StartAll | Verb::StartWorld) { crate::modules::ensure_bot_exclusivity(&root)?; }
|
||||
if crate::docker::is_docker(&root) {
|
||||
@@ -115,7 +136,8 @@ fn run_inner(root: &Path, verb: Verb, validating_update: bool) -> Result<DriverO
|
||||
if matches!(verb, Verb::StartAll | Verb::StartWorld) { crate::modules::ensure_bot_exclusivity(&root)?; }
|
||||
let (python, script) = launcher(&root)?;
|
||||
let original = std::fs::read_to_string(&script)?;
|
||||
let patched = patch_launcher_imports(&original)?;
|
||||
let imported = patch_launcher_imports(&original)?;
|
||||
let patched = if offline { offline_launcher(&imported)? } else { imported };
|
||||
if original != patched {
|
||||
fsx::atomic_write(&script, patched.as_bytes())?;
|
||||
if let Ok(dir) = crate::registry::metadata_dir_for(&root) {
|
||||
@@ -128,8 +150,10 @@ fn run_inner(root: &Path, verb: Verb, validating_update: bool) -> Result<DriverO
|
||||
}
|
||||
}
|
||||
let mut cmd = Command::new(&python);
|
||||
cmd.arg("-B").arg("-c").arg(LAUNCH_SCRIPT).arg(&script).arg(verb.arg())
|
||||
let launch = if offline && crate::update_fault::python_failure(&root) { "raise RuntimeError('Injected disposable-fixture Python failure')" } else { LAUNCH_SCRIPT };
|
||||
cmd.arg("-B").arg("-c").arg(launch).arg(&script).arg(verb.arg())
|
||||
.current_dir(&root).stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::piped());
|
||||
if offline { cmd.env("COA_UPDATE_VALIDATION", "1"); }
|
||||
#[cfg(windows)]
|
||||
{
|
||||
use std::os::windows::process::CommandExt;
|
||||
@@ -179,7 +203,10 @@ fn run_inner(root: &Path, verb: Verb, validating_update: bool) -> Result<DriverO
|
||||
}
|
||||
};
|
||||
tracing::info!(?verb, ok, ?code, "driver: launcher verb finished");
|
||||
if ok && verb == Verb::StartAll { crate::multiworld::start(&root)?; }
|
||||
if ok && verb == Verb::StartAll {
|
||||
if offline { crate::multiworld::start_validation(&root)?; }
|
||||
else { crate::multiworld::start(&root)?; }
|
||||
}
|
||||
Ok(DriverOutcome { ok, exit_code, code, human: code.map(ErrorCode::human), output })
|
||||
}
|
||||
|
||||
@@ -198,6 +225,7 @@ 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))
|
||||
}
|
||||
|
||||
@@ -123,7 +123,7 @@ pub fn atomic_write(path: &Path, bytes: &[u8]) -> Result<()> {
|
||||
let tmp = parent.join(format!(
|
||||
".{}.{}.tmp",
|
||||
path.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default(),
|
||||
std::process::id()
|
||||
uuid::Uuid::new_v4().simple()
|
||||
));
|
||||
let write = || -> std::io::Result<()> {
|
||||
let mut f = OpenOptions::new().write(true).create_new(true).open(&tmp)?;
|
||||
@@ -135,13 +135,41 @@ pub fn atomic_write(path: &Path, bytes: &[u8]) -> Result<()> {
|
||||
let _ = fs::remove_file(&tmp);
|
||||
return Err(e.into());
|
||||
}
|
||||
if let Err(e) = fs::rename(&tmp, path) {
|
||||
if let Err(e) = durable_replace(&tmp, path) {
|
||||
let _ = fs::remove_file(&tmp);
|
||||
return Err(e.into());
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// The temporary file must already be flushed, on the same volume as the destination.
|
||||
pub(crate) fn durable_replace(from: &Path, to: &Path) -> std::io::Result<()> {
|
||||
#[cfg(windows)]
|
||||
{
|
||||
use std::os::windows::ffi::OsStrExt;
|
||||
use windows_sys::Win32::Storage::FileSystem::{MoveFileExW, MOVEFILE_REPLACE_EXISTING, MOVEFILE_WRITE_THROUGH};
|
||||
fn wide(path: &Path) -> std::io::Result<Vec<u16>> {
|
||||
let absolute = std::path::absolute(path)?;
|
||||
let text = absolute.as_os_str().to_string_lossy().replace('/', "\\");
|
||||
let extended = if text.starts_with("\\\\?\\") { text }
|
||||
else if let Some(unc) = text.strip_prefix("\\\\") { format!("\\\\?\\UNC\\{unc}") }
|
||||
else { format!("\\\\?\\{text}") };
|
||||
Ok(std::ffi::OsStr::new(&extended).encode_wide().chain(Some(0)).collect())
|
||||
}
|
||||
let src = wide(from)?;
|
||||
let dst = wide(to)?;
|
||||
if unsafe { MoveFileExW(src.as_ptr(), dst.as_ptr(), MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH) } == 0 {
|
||||
return Err(std::io::Error::last_os_error());
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
#[cfg(not(windows))]
|
||||
{
|
||||
fs::rename(from, to)?;
|
||||
File::open(to.parent().unwrap())?.sync_all()
|
||||
}
|
||||
}
|
||||
|
||||
pub fn atomic_write_json<T: serde::Serialize>(path: &Path, value: &T) -> Result<()> {
|
||||
let mut bytes = serde_json::to_vec_pretty(value)?;
|
||||
bytes.push(b'\n');
|
||||
@@ -199,6 +227,16 @@ pub fn require_space(path: &Path, needed: u64) -> Result<()> {
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn durable_replacement_handles_long_transaction_backup_paths() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let parent = dir.path().join("a".repeat(90)).join("b".repeat(90));
|
||||
let path = parent.join("configuration-with-a-long-name.template");
|
||||
atomic_write(&path, b"old").unwrap();
|
||||
atomic_write(&path, b"new").unwrap();
|
||||
assert_eq!(fs::read(&path).unwrap(), b"new");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn safe_join_accepts_normal_and_rejects_traversal() {
|
||||
let root = Path::new("C:/srv");
|
||||
|
||||
@@ -148,10 +148,6 @@ pub(crate) fn bootstrap_database(root: &Path) -> Result<()> {
|
||||
with_scratch_ports(root, || bootstrap_database_inner(root))
|
||||
}
|
||||
|
||||
fn free_port() -> Result<u16> {
|
||||
Ok(std::net::TcpListener::bind("127.0.0.1:0")?.local_addr()?.port())
|
||||
}
|
||||
|
||||
/// Run `f` with the staging copy listening on unused ports, so an installation never collides with a server (or any
|
||||
/// other program) already using the shipped ports. The shipped ports are put back afterwards.
|
||||
pub(crate) fn with_scratch_ports<T>(root: &Path, f: impl FnOnce() -> Result<T>) -> Result<T> {
|
||||
@@ -159,10 +155,14 @@ pub(crate) fn with_scratch_ports<T>(root: &Path, f: impl FnOnce() -> Result<T>)
|
||||
let path = root.join("Settings/repack.json");
|
||||
let original: serde_json::Value = fsx::read_json(&path)?;
|
||||
let mut scratch = original.clone();
|
||||
let mut listeners = Vec::new();
|
||||
for k in KEYS {
|
||||
scratch[k] = free_port()?.into();
|
||||
let listener = std::net::TcpListener::bind("127.0.0.1:0")?;
|
||||
scratch[k] = listener.local_addr()?.port().into();
|
||||
listeners.push(listener);
|
||||
}
|
||||
fsx::atomic_write_json(&path, &scratch)?;
|
||||
drop(listeners);
|
||||
let result = f();
|
||||
// keep whatever else changed meanwhile (console credentials), restore only the ports
|
||||
let mut now: serde_json::Value = fsx::read_json(&path).unwrap_or(scratch);
|
||||
|
||||
@@ -25,6 +25,7 @@ pub mod population;
|
||||
pub mod process;
|
||||
pub mod manifest;
|
||||
pub mod migrations;
|
||||
pub mod migration_registry;
|
||||
pub mod multiworld;
|
||||
pub mod repair;
|
||||
pub mod schema_check;
|
||||
@@ -39,6 +40,8 @@ pub mod registry;
|
||||
pub mod release;
|
||||
pub mod release_schema;
|
||||
pub mod update;
|
||||
mod update_trial;
|
||||
mod update_fault;
|
||||
pub mod upnp;
|
||||
pub mod signing;
|
||||
pub mod srp6;
|
||||
|
||||
@@ -48,6 +48,8 @@ pub struct FileEntry {
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
pub struct Migration {
|
||||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||
pub compatible_sha256: Vec<String>,
|
||||
pub id: String,
|
||||
pub db: String,
|
||||
pub sha256: String,
|
||||
@@ -134,6 +136,11 @@ impl Manifest {
|
||||
if parse_version(&self.min_manager_version).is_none() {
|
||||
return bad(format!("bad minManagerVersion {:?}", self.min_manager_version));
|
||||
}
|
||||
for migration in &self.migrations {
|
||||
if !is_sha256(&migration.sha256) || migration.compatible_sha256.iter().any(|h| !is_sha256(h) || h == &"0".repeat(64)) {
|
||||
return bad(format!("{}: invalid migration checksum compatibility", migration.id));
|
||||
}
|
||||
}
|
||||
for (label, rev) in [("core", Some(&self.core)), ("bots", self.bots.as_ref())] {
|
||||
if let Some(Revision { commit: Some(c) }) = rev {
|
||||
if !is_commit(c) {
|
||||
|
||||
@@ -37,6 +37,7 @@ pub trait Store {
|
||||
fn load(&self) -> Result<Vec<LedgerRow>>;
|
||||
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 {
|
||||
@@ -48,6 +49,9 @@ 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;"
|
||||
@@ -148,7 +152,7 @@ fn recorded<'a>(rows: &'a [LedgerRow], m: &Migration) -> Option<&'a LedgerRow> {
|
||||
}
|
||||
|
||||
fn hash_changed(row: &LedgerRow, m: &Migration) -> bool {
|
||||
row.status == Status::Applied && row.sha256 != "0".repeat(64) && !row.sha256.eq_ignore_ascii_case(&m.sha256)
|
||||
row.status == Status::Applied && row.sha256 != "0".repeat(64) && !row.sha256.eq_ignore_ascii_case(&m.sha256) && !m.compatible_sha256.iter().any(|h| h.eq_ignore_ascii_case(&row.sha256))
|
||||
}
|
||||
|
||||
/// Record migrations as already present without running them (adopting an existing server whose database
|
||||
@@ -217,10 +221,13 @@ pub fn apply_pending(store: &dyn Store, list: &[Migration], dir: &Path, snapshot
|
||||
for (m, schema, path) in files {
|
||||
tracing::info!(migration = %m.id, database = %m.db, "database migration starting");
|
||||
store.put(&LedgerRow { db: m.db.clone(), id: m.id.clone(), sha256: m.sha256.clone(), status: Status::Running, error: Some("Interrupted SQL must be recovered before replay.".into()), baseline: false })?;
|
||||
store.checkpoint(&format!("before-sql:{}", m.id));
|
||||
match store.run_file(schema, &path) {
|
||||
Ok(()) => {
|
||||
store.checkpoint(&format!("after-sql:{}", m.id));
|
||||
store.put(&LedgerRow { db: m.db.clone(), id: m.id.clone(), sha256: m.sha256.clone(), status: Status::Applied, error: None, baseline: false })?;
|
||||
report.applied.push(m.id.clone());
|
||||
store.checkpoint(&format!("recorded-sql:{}", m.id));
|
||||
tracing::info!(migration = %m.id, database = %m.db, "database migration applied");
|
||||
}
|
||||
Err(e) => {
|
||||
@@ -273,7 +280,7 @@ mod tests {
|
||||
for (db, id, sql) in files {
|
||||
std::fs::create_dir_all(d.path().join(db)).unwrap();
|
||||
std::fs::write(d.path().join(db).join(format!("{id}.sql")), sql).unwrap();
|
||||
list.push(Migration { id: id.to_string(), db: db.to_string(), sha256: fsx::sha256_bytes(sql.as_bytes()), destructive: false });
|
||||
list.push(Migration { compatible_sha256: vec![], id: id.to_string(), db: db.to_string(), sha256: fsx::sha256_bytes(sql.as_bytes()), destructive: false });
|
||||
}
|
||||
(d, list)
|
||||
}
|
||||
@@ -304,6 +311,19 @@ mod tests {
|
||||
assert!(store.ran.borrow().is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn only_explicit_published_compatibility_skips_changed_hash_without_rewriting_history() {
|
||||
let (d, mut list) = setup(&[("characters", "repair", "SELECT 1;\n")]);
|
||||
let store = Mem::default();
|
||||
let previous = fsx::sha256_bytes(b"SELECT 1;\r\n");
|
||||
store.rows.borrow_mut().push(LedgerRow { db: "characters".into(), id: "repair".into(), sha256: previous.clone(), status: Status::Applied, error: None, baseline: false });
|
||||
assert!(apply_pending(&store, &list, d.path(), &no_snapshot).is_err());
|
||||
list[0].compatible_sha256.push(previous.clone());
|
||||
assert!(apply_pending(&store, &list, d.path(), &no_snapshot).unwrap().applied.is_empty());
|
||||
assert!(store.ran.borrow().is_empty());
|
||||
assert_eq!(store.rows.borrow()[0].sha256, previous);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn applies_in_order_once_and_records_the_ledger() {
|
||||
let (d, list) = setup(&[("world", "2026_09_01_00_a", "CREATE TABLE t (id INT);"), ("world", "2026_09_02_00_b", "ALTER TABLE t ADD c INT;")]);
|
||||
|
||||
@@ -125,6 +125,14 @@ fn secondary_launcher(source: &str) -> Result<String> {
|
||||
}
|
||||
|
||||
pub fn start(main: &Path) -> Result<()> {
|
||||
start_inner(main, false)
|
||||
}
|
||||
|
||||
pub(crate) fn start_validation(main: &Path) -> Result<()> {
|
||||
start_inner(main, true)
|
||||
}
|
||||
|
||||
fn start_inner(main: &Path, offline: bool) -> Result<()> {
|
||||
if !realms::state(main)?.simultaneous { return Ok(()); }
|
||||
if is_running(main) {
|
||||
let second = root(main);
|
||||
@@ -132,7 +140,7 @@ pub fn start(main: &Path) -> Result<()> {
|
||||
return Err(Error::Invalid("The second realm is still starting or stopping.".into()));
|
||||
}
|
||||
let second = prepare(main)?;
|
||||
let out = driver::run(&second, Verb::StartWorld)?;
|
||||
let out = if offline { driver::validate_secondary(&second)? } else { driver::run(&second, Verb::StartWorld)? };
|
||||
if !out.ok { return Err(Error::Invalid(format!("The second realm did not start: {}", out.output))); }
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -4,6 +4,8 @@
|
||||
use std::fs;
|
||||
use std::io::Read;
|
||||
use std::path::{Path, PathBuf};
|
||||
use base64::{engine::general_purpose::STANDARD, Engine};
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::download::{self, Cancel, Job, Progress};
|
||||
use crate::error::{Error, Result};
|
||||
@@ -20,6 +22,77 @@ pub enum Source {
|
||||
Dir(PathBuf),
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, Deserialize)]
|
||||
pub struct Channel {
|
||||
pub schema: u32,
|
||||
pub version: String,
|
||||
pub release: String,
|
||||
pub manifest_sha256: String,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub acceptance_sha256: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Serialize, Deserialize)]
|
||||
pub struct SignedChannel {
|
||||
pub payload: String,
|
||||
pub signature: String,
|
||||
}
|
||||
|
||||
pub fn verify_channel(bytes: &[u8], trusted_key: &str) -> Result<Channel> {
|
||||
let signed: SignedChannel = serde_json::from_slice(bytes).map_err(|e| Error::InvalidManifest(e.to_string()))?;
|
||||
let payload = STANDARD.decode(&signed.payload).map_err(|e| Error::InvalidManifest(e.to_string()))?;
|
||||
signing::verify(&payload, &signed.signature, trusted_key)?;
|
||||
let pointer: Channel = serde_json::from_slice(&payload).map_err(|e| Error::InvalidManifest(e.to_string()))?;
|
||||
let required = format!("https://github.com/Corfirean/coa-server-build/releases/download/server-{}/", pointer.version);
|
||||
if pointer.schema != 1 || crate::manifest::parse_version(&pointer.version).is_none() || pointer.release != required {
|
||||
return Err(Error::InvalidManifest("Channel does not point to an immutable server release.".into()));
|
||||
}
|
||||
Ok(pointer)
|
||||
}
|
||||
|
||||
/// A channel is one atomically replaced signed envelope. Its target is immutable.
|
||||
pub struct PinnedPackage {
|
||||
pub source: Source,
|
||||
pub manifest: Manifest,
|
||||
pub bytes: Vec<u8>,
|
||||
pub signature: Vec<u8>,
|
||||
}
|
||||
|
||||
pub fn fetch_package(source: &Source, trusted_key: &str) -> Result<PinnedPackage> {
|
||||
let channel = match source {
|
||||
Source::Dir(d) if !d.join("channel.json").exists() => None,
|
||||
_ => match fetch_small(source, "channel.json") {
|
||||
Ok(bytes) => Some(bytes),
|
||||
Err(Error::PackageNotPublished(_)) => None,
|
||||
Err(e) => return Err(e),
|
||||
},
|
||||
};
|
||||
let (mut resolved, expected) = if let Some(bytes) = channel {
|
||||
let pointer = verify_channel(&bytes, trusted_key)?;
|
||||
(Source::Url(pointer.release.clone()), Some(pointer))
|
||||
} else { (source.clone(), None) };
|
||||
let mut bytes = fetch_small(&resolved, "manifest.json")?;
|
||||
let mut signature = fetch_small(&resolved, "manifest.json.sig")?;
|
||||
signing::verify(&bytes, &String::from_utf8_lossy(&signature), trusted_key)?;
|
||||
let manifest = Manifest::parse(&bytes)?;
|
||||
// Legacy moving channels are pinned by matching their signed manifest to the immutable tag.
|
||||
if matches!(&resolved, Source::Url(url) if matches!(url.trim_end_matches('/'), "https://github.com/Corfirean/coa-server-build/releases/download/stable" | "https://github.com/Corfirean/coa-server-build/releases/download/edge")) {
|
||||
resolved = Source::Url(format!("https://github.com/Corfirean/coa-server-build/releases/download/server-{}/", manifest.version));
|
||||
let immutable = fetch_small(&resolved, "manifest.json")?;
|
||||
let sig = fetch_small(&resolved, "manifest.json.sig")?;
|
||||
signing::verify(&immutable, &String::from_utf8_lossy(&sig), trusted_key)?;
|
||||
if immutable != bytes { return Err(Error::InvalidManifest("Moving channel differs from its immutable release.".into())); }
|
||||
bytes = immutable;
|
||||
signature = sig;
|
||||
}
|
||||
if let Some(pointer) = expected {
|
||||
if pointer.version != manifest.version || pointer.manifest_sha256 != fsx::sha256_bytes(&bytes) {
|
||||
return Err(Error::InvalidManifest("Immutable release does not match the signed channel.".into()));
|
||||
}
|
||||
}
|
||||
Ok(PinnedPackage { source: resolved, manifest, bytes, signature })
|
||||
}
|
||||
|
||||
/// Read a small file (manifest, signature) from the source.
|
||||
pub fn fetch_small(source: &Source, name: &str) -> Result<Vec<u8>> {
|
||||
match source {
|
||||
@@ -44,11 +117,8 @@ pub fn fetch_small(source: &Source, name: &str) -> Result<Vec<u8>> {
|
||||
|
||||
/// Download and verify the manifest. Returns the parsed manifest and its exact bytes.
|
||||
pub fn fetch_manifest(source: &Source, trusted_key: &str) -> Result<(Manifest, Vec<u8>)> {
|
||||
let bytes = fetch_small(source, "manifest.json")?;
|
||||
let sig = String::from_utf8_lossy(&fetch_small(source, "manifest.json.sig")?).into_owned();
|
||||
signing::verify(&bytes, &sig, trusted_key)?;
|
||||
let manifest = Manifest::parse(&bytes)?;
|
||||
Ok((manifest, bytes))
|
||||
let pinned = fetch_package(source, trusted_key)?;
|
||||
Ok((pinned.manifest, pinned.bytes))
|
||||
}
|
||||
|
||||
/// Make every archive part available in a verified folder: a local source is used in place, a remote one is
|
||||
|
||||
@@ -13,6 +13,7 @@ use crate::package::{self, BuildOptions};
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct SqlFile {
|
||||
pub compatible_sha256: Vec<String>,
|
||||
pub db: String,
|
||||
pub id: String,
|
||||
/// Path relative to the checkout it came from (used only for ordering and display).
|
||||
@@ -49,7 +50,7 @@ pub fn collect_core_sql(core: &Path) -> Result<Vec<SqlFile>> {
|
||||
let mut out = Vec::new();
|
||||
let mut push = |db: &str, id: String, abs: PathBuf, origin: String| -> Result<()> {
|
||||
let sha256 = fsx::sha256_file(&abs)?;
|
||||
out.push(SqlFile { db: db.into(), id, origin, abs, sha256 });
|
||||
out.push(SqlFile { compatible_sha256: vec![], db: db.into(), id, origin, abs, sha256 });
|
||||
Ok(())
|
||||
};
|
||||
for (kind, dirs) in [("auth", ["db_auth", "pending_db_auth"]), ("characters", ["db_characters", "pending_db_characters"]), ("world", ["db_world", "pending_db_world"])] {
|
||||
@@ -92,13 +93,13 @@ pub fn collect_bots_sql(bots: &Path) -> Result<Vec<SqlFile>> {
|
||||
let mut out = Vec::new();
|
||||
for f in sql_in(&bots.join("dist/sql")) {
|
||||
let stem = f.file_stem().unwrap().to_string_lossy().into_owned();
|
||||
out.push(SqlFile { db: "characters".into(), id: format!("mod_coa_playerbots__{stem}"), origin: format!("dist/sql/{stem}.sql"), sha256: fsx::sha256_file(&f)?, abs: f });
|
||||
out.push(SqlFile { compatible_sha256: vec![], db: "characters".into(), id: format!("mod_coa_playerbots__{stem}"), origin: format!("dist/sql/{stem}.sql"), sha256: fsx::sha256_file(&f)?, abs: f });
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
fn to_migrations(files: &[SqlFile]) -> Vec<Migration> {
|
||||
files.iter().map(|f| Migration { id: f.id.clone(), db: f.db.clone(), sha256: f.sha256.clone(), destructive: false }).collect()
|
||||
files.iter().map(|f| Migration { compatible_sha256: f.compatible_sha256.clone(), id: f.id.clone(), db: f.db.clone(), sha256: f.sha256.clone(), destructive: false }).collect()
|
||||
}
|
||||
|
||||
pub struct UpdateParams<'a> {
|
||||
@@ -226,7 +227,7 @@ mod tests {
|
||||
write(&tree, "Core/newlib.dll", "n");
|
||||
write(&tree, crate::schema_check::CONTRACT, "same contract");
|
||||
write(&sqldir, "world.sql", "SELECT 1;");
|
||||
let sql = vec![SqlFile { db: "world".into(), id: "m1".into(), origin: "x".into(), abs: sqldir.join("world.sql"), sha256: fsx::sha256_file(&sqldir.join("world.sql")).unwrap() }];
|
||||
let sql = vec![SqlFile { compatible_sha256: vec![], db: "world".into(), id: "m1".into(), origin: "x".into(), abs: sqldir.join("world.sql"), sha256: fsx::sha256_file(&sqldir.join("world.sql")).unwrap() }];
|
||||
let m = pack_update(&UpdateParams { tree: &tree, base_manifest: &base, sql: &sql, out: &upd_out, version: "1.1.0".into(), core_commit: Some("a".repeat(40)), bots_commit: Some("b".repeat(40)), part_size: 1 << 20 }, &|_| {}).unwrap();
|
||||
let paths: Vec<&str> = m.files.iter().map(|f| f.path.as_str()).collect();
|
||||
assert!(paths.contains(&"Core/worldserver.exe") && paths.contains(&"Core/newlib.dll"));
|
||||
|
||||
@@ -16,7 +16,7 @@ pub fn collect(core: &Path, bots: Option<&Path>, repairs: Option<&Path>) -> Resu
|
||||
paths.sort();
|
||||
for path in paths.into_iter().filter(|p| p.extension().is_some_and(|e| e == "sql")) {
|
||||
let stem = path.file_stem().unwrap().to_string_lossy();
|
||||
files.push(SqlFile { db: kind.into(), id: format!("manager_repair__{stem}"), origin: format!("{kind}/{stem}.sql"), sha256: fsx::sha256_file(&path)?, abs: path });
|
||||
files.push(SqlFile { compatible_sha256: vec![], db: kind.into(), id: format!("manager_repair__{stem}"), origin: format!("{kind}/{stem}.sql"), sha256: fsx::sha256_file(&path)?, abs: path });
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -47,7 +47,7 @@ pub fn capture_release(fixture: &Path, tree: &Path, sql: &[SqlFile]) -> Result<(
|
||||
return Err(Error::Invalid("Refusing to apply release SQL to a non-fixture server.".into()));
|
||||
}
|
||||
let staging = tempfile::tempdir()?;
|
||||
let migrations: Vec<_> = sql.iter().map(|f| Migration { db: f.db.clone(), id: f.id.clone(), sha256: f.sha256.clone(), destructive: false }).collect();
|
||||
let migrations: Vec<_> = sql.iter().map(|f| Migration { compatible_sha256: f.compatible_sha256.clone(), db: f.db.clone(), id: f.id.clone(), sha256: f.sha256.clone(), destructive: false }).collect();
|
||||
for file in sql {
|
||||
let path = fsx::safe_join(staging.path(), &format!("{}/{}.sql", file.db, file.id))?;
|
||||
fsx::atomic_write(&path, &std::fs::read(&file.abs)?)?;
|
||||
|
||||
+803
-121
File diff suppressed because it is too large.
Load diff
@@ -7,4 +7,7 @@ license.workspace = true
|
||||
[dependencies]
|
||||
coa-core = { path = "../coa-core" }
|
||||
serde_json = "1"
|
||||
base64 = "0.22"
|
||||
ed25519-dalek = "2"
|
||||
tempfile = "3"
|
||||
chrono = { version = "0.4", default-features = false, features = ["clock", "std"] }
|
||||
@@ -46,6 +46,65 @@ fn run() -> Result<(), String> {
|
||||
let e = |x: coa_core::Error| x.to_string();
|
||||
let part = a.get("part-size").and_then(|v| v.parse().ok()).unwrap_or(DEFAULT_PART_SIZE);
|
||||
match cmd.as_str() {
|
||||
"verify-registry" => {
|
||||
let sql = coa_core::migration_registry::reconcile(&PathBuf::from(need(&a, "registry")?), Vec::new()).map_err(e)?;
|
||||
println!("Verified {} historical migrations, order and signed byte variants", sql.len());
|
||||
}
|
||||
"resolve" => {
|
||||
let package = coa_core::pkgsource::fetch_package(&coa_core::pkgsource::Source::Url(need(&a, "source")?.clone()), coa_core::signing::EMBEDDED_PUBLIC_KEY).map_err(e)?;
|
||||
coa_core::fsx::atomic_write(&PathBuf::from(need(&a, "out")?), &package.bytes).map_err(e)?;
|
||||
}
|
||||
"extract-game-data" => {
|
||||
let source = PathBuf::from(need(&a, "package")?);
|
||||
let package = coa_core::pkgsource::fetch_package(&coa_core::pkgsource::Source::Dir(source.clone()), coa_core::signing::EMBEDDED_PUBLIC_KEY).map_err(e)?;
|
||||
if !package.manifest.files.iter().any(|f| f.path.starts_with("Data/")) { return Err("Signed base has no game data.".into()); }
|
||||
coa_core::package::extract_selected(&source, &package.manifest, &PathBuf::from(need(&a, "fixture")?), &|p| p.starts_with("Data/"), &|_, _| {}).map_err(e)?;
|
||||
}
|
||||
"repackage" => {
|
||||
let source = PathBuf::from(need(&a, "package")?);
|
||||
let pinned = coa_core::pkgsource::fetch_package(&coa_core::pkgsource::Source::Dir(source.clone()), coa_core::signing::EMBEDDED_PUBLIC_KEY).map_err(e)?;
|
||||
let work = tempfile::tempdir().map_err(|e| e.to_string())?;
|
||||
coa_core::package::extract(&source, &pinned.manifest, work.path(), &|_, _| {}).map_err(e)?;
|
||||
let mut sql: Vec<_> = pinned.manifest.migrations.iter().map(|m| coa_core::release::SqlFile {
|
||||
compatible_sha256: m.compatible_sha256.clone(), db: m.db.clone(), id: m.id.clone(), sha256: m.sha256.clone(), origin: "signed package".into(), abs: work.path().join("_migrations").join(&m.db).join(format!("{}.sql", m.id)),
|
||||
}).collect();
|
||||
let repairs = PathBuf::from(need(&a, "repairs")?);
|
||||
for repair in coa_core::release_schema::collect(&work.path().join("no-core"), None, Some(&repairs)).map_err(e)? {
|
||||
if !sql.iter().any(|m| m.db == repair.db && m.id == repair.id) { sql.push(repair); }
|
||||
}
|
||||
let sql = coa_core::migration_registry::reconcile(&PathBuf::from(need(&a, "registry")?), sql).map_err(e)?;
|
||||
let migrations = sql.iter().map(|m| coa_core::manifest::Migration { compatible_sha256: m.compatible_sha256.clone(), db: m.db.clone(), id: m.id.clone(), sha256: m.sha256.clone(), destructive: false }).collect();
|
||||
for file in &sql { coa_core::fsx::atomic_write(&work.path().join("_migrations").join(&file.db).join(format!("{}.sql", file.id)), &std::fs::read(&file.abs).map_err(|e| e.to_string())?).map_err(e)?; }
|
||||
let out = PathBuf::from(need(&a, "out")?);
|
||||
let opts = BuildOptions { kind: Kind::Update, version: need(&a, "version")?.clone(), core_commit: pinned.manifest.core.commit, bots_commit: pinned.manifest.bots.and_then(|b| b.commit), built_at: chrono_now(), part_size: part, migrations };
|
||||
let mut manifest = build(work.path(), &out, &opts, &|s| eprintln!("{s}")).map_err(e)?;
|
||||
manifest.min_manager_version = coa_core::MANAGER_VERSION.into();
|
||||
coa_core::fsx::atomic_write_json(&out.join("manifest.json"), &manifest).map_err(e)?;
|
||||
}
|
||||
"archive-migrations" => {
|
||||
coa_core::migration_registry::import(&PathBuf::from(need(&a, "package")?), &PathBuf::from(need(&a, "registry")?), coa_core::signing::EMBEDDED_PUBLIC_KEY).map_err(e)?;
|
||||
println!("Published migration bytes and compatibility archived");
|
||||
}
|
||||
"verify-channel" => {
|
||||
let pointer = coa_core::pkgsource::verify_channel(&std::fs::read(need(&a, "file")?).map_err(|e| e.to_string())?, coa_core::signing::EMBEDDED_PUBLIC_KEY).map_err(e)?;
|
||||
let dir = PathBuf::from(need(&a, "dir")?);
|
||||
let manifest: Manifest = coa_core::fsx::read_json(&dir.join("manifest.json")).map_err(e)?;
|
||||
if manifest.version != pointer.version || coa_core::fsx::sha256_file(&dir.join("manifest.json")).map_err(e)? != pointer.manifest_sha256 || pointer.acceptance_sha256.as_deref() != Some(&coa_core::fsx::sha256_file(&dir.join("acceptance.json")).map_err(e)?) {
|
||||
return Err("Signed channel differs from the tested package/report".into());
|
||||
}
|
||||
}
|
||||
"channel" => {
|
||||
use base64::{engine::general_purpose::STANDARD, Engine};
|
||||
use ed25519_dalek::{Signer, SigningKey};
|
||||
let dir = PathBuf::from(need(&a, "dir")?);
|
||||
let pinned = coa_core::pkgsource::fetch_package(&coa_core::pkgsource::Source::Dir(dir.clone()), coa_core::signing::EMBEDDED_PUBLIC_KEY).map_err(e)?;
|
||||
let pointer = coa_core::pkgsource::Channel { schema: 1, version: pinned.manifest.version.clone(), release: format!("https://github.com/Corfirean/coa-server-build/releases/download/server-{}/", pinned.manifest.version), manifest_sha256: coa_core::fsx::sha256_bytes(&pinned.bytes), acceptance_sha256: Some(coa_core::fsx::sha256_file(&dir.join("acceptance.json")).map_err(e)?) };
|
||||
let payload = serde_json::to_vec(&pointer).map_err(|e| e.to_string())?;
|
||||
let seed: [u8; 32] = STANDARD.decode(signing_key()?.trim()).map_err(|e| e.to_string())?.try_into().map_err(|_| "Wrong signing key length")?;
|
||||
let signed = coa_core::pkgsource::SignedChannel { payload: STANDARD.encode(&payload), signature: STANDARD.encode(SigningKey::from_bytes(&seed).sign(&payload).to_bytes()) };
|
||||
coa_core::signing::verify_embedded(&payload, &signed.signature).map_err(e)?;
|
||||
coa_core::fsx::atomic_write_json(&PathBuf::from(need(&a, "out")?), &signed).map_err(e)?;
|
||||
}
|
||||
"extract-schema-base" => {
|
||||
coa_core::release_schema::extract_base(
|
||||
&PathBuf::from(need(&a, "package")?), &PathBuf::from(need(&a, "fixture")?),
|
||||
@@ -59,7 +118,8 @@ fn run() -> Result<(), String> {
|
||||
if let Some(core) = a.get("core") {
|
||||
let bots = a.get("bots").map(PathBuf::from);
|
||||
let repairs = a.get("repairs").map(PathBuf::from);
|
||||
let sql = coa_core::release_schema::collect(&PathBuf::from(core), bots.as_deref(), repairs.as_deref()).map_err(e)?;
|
||||
let mut sql = coa_core::release_schema::collect(&PathBuf::from(core), bots.as_deref(), repairs.as_deref()).map_err(e)?;
|
||||
if let Some(registry) = a.get("registry") { sql = coa_core::migration_registry::reconcile(&PathBuf::from(registry), sql).map_err(e)?; }
|
||||
coa_core::release_schema::capture_release(&repack, &tree, &sql).map_err(e)?;
|
||||
} else {
|
||||
coa_core::backup::with_database(&repack, |db| coa_core::schema_check::capture(db, &tree)).map_err(e)?;
|
||||
@@ -77,7 +137,8 @@ fn run() -> Result<(), String> {
|
||||
coa_core::schema_check::require_release_contract(&PathBuf::from(need(&a, "tree")?)).map_err(e)?;
|
||||
let bots = a.get("bots").map(PathBuf::from);
|
||||
let repairs = a.get("repairs").map(PathBuf::from);
|
||||
let sql = coa_core::release_schema::collect(&PathBuf::from(need(&a, "core")?), bots.as_deref(), repairs.as_deref()).map_err(e)?;
|
||||
let mut sql = coa_core::release_schema::collect(&PathBuf::from(need(&a, "core")?), bots.as_deref(), repairs.as_deref()).map_err(e)?;
|
||||
if let Some(registry) = a.get("registry") { sql = coa_core::migration_registry::reconcile(&PathBuf::from(registry), sql).map_err(e)?; }
|
||||
let out = PathBuf::from(need(&a, "out")?);
|
||||
let m = pack_update(
|
||||
&UpdateParams { tree: &PathBuf::from(need(&a, "tree")?), base_manifest: &base, sql: &sql, out: &out, version: need(&a, "version")?.clone(), core_commit: a.get("core-commit").cloned(), bots_commit: a.get("bots-commit").cloned(), part_size: part },
|
||||
|
||||
@@ -0,0 +1,94 @@
|
||||
# Reliable updates and Windows acceptance
|
||||
|
||||
An operation resolves one signed manifest and immutable release before downloading its
|
||||
archive. The same verified bytes are used for the private trial and the real application.
|
||||
The installation lock covers stop, snapshot, trial, application, validation and recovery.
|
||||
Native Windows installations with the bundled Python and MySQL runtime are supported;
|
||||
Docker and unrecognised launchers are rejected before applying files.
|
||||
|
||||
The manager measures the installation and database directories, checks free space and
|
||||
allocates recovery reserves. The private copy contains independent runtime, configuration,
|
||||
game-data and database files. It imports the verified original recovery point, runs the
|
||||
candidate SQL and uses loopback ports for startup. The known launcher reporting relay is
|
||||
disabled during validation. No junctions or hardlinks are created.
|
||||
|
||||
Transactions keep the exact manifest hash, original running state, protected generated
|
||||
files, database recovery point and individual file operations. SQL has its own migration
|
||||
ledger. Stop, snapshot and trial have separate durable states. The original failure stage
|
||||
is retained when the current state changes to recovery or recovered.
|
||||
Interrupted SQL is restored, never automatically repeated. Windows file replacement
|
||||
uses a synced temporary file and MoveFileExW with WRITE_THROUGH, including long paths.
|
||||
Recovery is repeatable and does not require backing up the damaged state. Corrupt journals
|
||||
or snapshots block startup and preserve available copies.
|
||||
|
||||
Recovery verifies the original dump before importing it into a private recovery schema,
|
||||
then compares the live database with a deterministic dump of that schema. This accounts
|
||||
for MySQL's normalisation of character-set declarations while checking schema and rows.
|
||||
Configuration backups carry individual content hashes. Legacy update snapshots without
|
||||
those hashes require manual inspection rather than an unverified automatic restore.
|
||||
Database dumps and configuration copies are flushed to disk before the snapshot is usable.
|
||||
A committed operation interrupted before admission
|
||||
resumes startup without undoing the committed database. Diagnostic JSON is saved locally;
|
||||
database passwords are removed and reports leave the machine only through explicit export.
|
||||
|
||||
## Migration publication
|
||||
|
||||
`coa-release archive-migrations --package DIR --registry DIR` verifies the released
|
||||
signature and preserves original SQL bytes, fixed order, hashes and signed provenance.
|
||||
Only byte variants differing in UTF-8 BOM or line endings can share an ID. Other changes
|
||||
fail the build and need a new migration ID. Compatibility hashes are included in the signed
|
||||
manifest, leaving existing ledger checksums unchanged.
|
||||
|
||||
Published packages use `server-VERSION` releases. Channels contain one signed envelope;
|
||||
it binds the immutable manifest and acceptance report hashes. Stable is switched only
|
||||
after package verification and acceptance. Never replace assets of an existing immutable
|
||||
release or rewrite historical registry SQL.
|
||||
|
||||
## Disposable acceptance fixture
|
||||
|
||||
Run `tools/update-chaos-gate.ps1 -BasePackage DIR -CandidatePackage DIR -Target NEW_PATH`
|
||||
on Windows. NEW_PATH must start with `coa-schema-fixture-chaos-`; the harness creates
|
||||
both disposable markers itself. Base and candidate signatures are required. The harness
|
||||
extracts game data independently and seeds an account, character and inventory item.
|
||||
Optional `-DataSource DIR` reads an existing game-data folder without modifying it.
|
||||
|
||||
Crash injection is compiled only with `coa-core/testkit` and additionally requires the
|
||||
disposable marker. `COA_UPDATE_CRASH_AT` terminates the test process with exit 91 at a
|
||||
named checkpoint. Production builds do not enable this mechanism. The harness exercises
|
||||
file journaling, SQL phases, commit and repeated recovery interruption. Backups and failed
|
||||
trial copies remain available for diagnosis.
|
||||
|
||||
The release jobs must run on a Windows worker with enough free space for the actual
|
||||
signed base, private copy, full snapshots and recovery reserves. Insufficient space is a
|
||||
test failure, not permission to bypass acceptance.
|
||||
The workflows require a dedicated runner labelled `coa-update-acceptance` (Windows,
|
||||
X64). Provision at least 300 GB of free workspace and 16 GB of RAM for the retained
|
||||
ten-scenario matrix, plus the normal Rust/Tauri build prerequisites. The timeout is
|
||||
24 hours: full snapshot, import and recovery checks take minutes per injected fault.
|
||||
A default hosted runner's disk and four-hour budget are insufficient for this gate.
|
||||
|
||||
`tools/update-chaos-matrix.ps1` runs separate fixtures for CoA, Wildcard, both worlds,
|
||||
SQUID and imported installations. With `-PreviousPackage`, it also runs each mode from
|
||||
that signed previous release. Its acceptance report binds every scenario to the same
|
||||
candidate manifest hash and manager source commit. Publication requires all ten scenarios.
|
||||
It also requires every mandatory fault class in each scenario's coverage record. Missing
|
||||
coverage produces an `incomplete` report and fails publication. The current harness still
|
||||
lacks real disk exhaustion, denied writes, database-child and new-server crash coverage,
|
||||
OS network containment and coverage of every file-operation phase.
|
||||
The gate includes real occupied ports and locked files, a Python startup failure, and SQL
|
||||
that creates and populates a table before failing. These faults must preserve seeded
|
||||
accounts, characters and inventory in every applicable database.
|
||||
|
||||
Validation currently isolates listeners on loopback and disables the recognised reporting
|
||||
relay. It does not enforce an operating-system firewall against arbitrary outbound actions
|
||||
in custom binaries; additional network containment is required for that release criterion.
|
||||
|
||||
## Release acceptance still required
|
||||
|
||||
Unit tests and compilation do not establish the full release criterion. Record results
|
||||
for exact package and installer hashes, previous supported releases and skipped versions,
|
||||
CoA/Wildcard/both/SQUID, imported repacks and modified configurations. Exercise occupied
|
||||
ports/files, partial DDL, disk exhaustion, write errors, corrupt packages/journals/backups,
|
||||
Python failure and server crashes. Verify schema, all player data, migration history,
|
||||
metadata and startup after every injected failure. A passing subset must not be described
|
||||
as completion of this matrix or as a guarantee against all possible failures.
|
||||
@@ -0,0 +1,61 @@
|
||||
# Local update validation, 2026-10-05
|
||||
|
||||
These results are a partial validation record, not a release acceptance report.
|
||||
Tests use the independently copied, doubly marked disposable fixture
|
||||
`C:\games\coa-schema-fixture-chaos-20261005-v1`. User installations are not modified.
|
||||
|
||||
Candidate: `0.261005.24`, signed manifest SHA-256
|
||||
`1284b1273815209c9621b6d173a2211bae316f33462ccbe8b578e53b8d26fb5b`.
|
||||
Published migration provenance was verified for `0.261005.0` and `0.261005.22`.
|
||||
Their disputed repair differs only by line endings; both published hashes are retained.
|
||||
|
||||
Completed real-runtime checks:
|
||||
|
||||
- Base-to-candidate update, isolated trial, SQL, startup and commit.
|
||||
- Repeat candidate application without replaying applied migrations.
|
||||
- CoA and Wildcard together, including both world processes and player databases.
|
||||
- Hard process termination after stop and after corrective SQL.
|
||||
- Repeated recovery interruption after database restoration, followed by successful recovery.
|
||||
- Occupied world port and exclusively locked configuration-default file, rejected before stop.
|
||||
- Partial DDL and inserted data followed by invalid SQL in the live corrective migration.
|
||||
Automatic rollback completed and removed the injected table.
|
||||
- Bundled Python failure during live startup after a successful private two-world trial.
|
||||
Automatic recovery passed exact pre-operation file and installation-metadata hashes,
|
||||
restored all six databases, and preserved seeded accounts, characters and inventory.
|
||||
- Modified user template values survived recovery. The fixture changes the template,
|
||||
not the launcher-generated active file; this corrected an initial harness assertion.
|
||||
- A modified manifest with its original signature was rejected before application.
|
||||
- Hard termination immediately after recording a complete snapshot, followed by separately
|
||||
corrupted transaction JSON and compressed character database archive. Both recovery
|
||||
attempts refused without starting services or changing the world executable/installation
|
||||
metadata. After removing the injected corruption, rollback completed and preserved the
|
||||
seeded accounts, characters and inventory in both worlds.
|
||||
- A live Python failure with both worlds originally running restored their ready state,
|
||||
all six databases, player data, configuration and installation metadata. An initial
|
||||
strict comparison exposed realm-profile regeneration after restart; the final protection
|
||||
pass was corrected and the real-runtime case passed on repetition. Test processes were
|
||||
explicitly stopped after verification.
|
||||
|
||||
Checks compare restored database content and preserve a seeded account, character and
|
||||
inventory item in each applicable realm. Recovery also checks original file hashes and
|
||||
installation metadata. The core unit suite passed 260 tests; frontend build and translation
|
||||
validation passed. Changes after these runs require the relevant checks again.
|
||||
The full 260-test run used `--test-threads=1`. A parallel run during native database
|
||||
recovery encountered connection resets in two existing RA socket tests; those failures
|
||||
are recorded rather than treated as update failures or hidden by the passing rerun.
|
||||
|
||||
Not yet established: the complete five-mode, base/previous-release Windows matrix;
|
||||
published installer execution against fixtures; actual disk exhaustion and denied writes;
|
||||
database-child termination during table swaps; every individual file mutation checkpoint;
|
||||
operating-system containment of arbitrary external actions. Publication must stay blocked
|
||||
until the required matrix and remaining release invariants have been demonstrated.
|
||||
|
||||
The matrix report now explicitly records fault coverage. Missing mandatory fault classes
|
||||
produce an `incomplete` report and fail the gate, even when every scenario that was executed
|
||||
passed. Disk exhaustion, denied writes, database-child and new-server crashes,
|
||||
network containment and all file-operation phases still require actual evidence. Snapshot
|
||||
corruption guards now have real-runtime coverage. The later backup-metadata hash and
|
||||
backup-retention guards require their own runtime injection checks before release.
|
||||
|
||||
Infrastructure inspection found zero registered repository runners for both projects.
|
||||
The dedicated Windows acceptance runner must be provisioned before these workflows can run.
|
||||
Generated
+2
-2
@@ -1,12 +1,12 @@
|
||||
{
|
||||
"name": "coa-server-manager",
|
||||
"version": "0.6.4",
|
||||
"version": "0.6.5",
|
||||
"lockfileVersion": 3,
|
||||
"requires": true,
|
||||
"packages": {
|
||||
"": {
|
||||
"name": "coa-server-manager",
|
||||
"version": "0.6.4",
|
||||
"version": "0.6.5",
|
||||
"dependencies": {
|
||||
"@tauri-apps/api": "^2.12.0",
|
||||
"@tauri-apps/plugin-dialog": "^2.8.0",
|
||||
|
||||
+1
-1
@@ -1,7 +1,7 @@
|
||||
{
|
||||
"name": "coa-server-manager",
|
||||
"private": true,
|
||||
"version": "0.6.4",
|
||||
"version": "0.6.5",
|
||||
"license": "AGPL-3.0-only",
|
||||
"type": "module",
|
||||
"scripts": {
|
||||
|
||||
@@ -0,0 +1,3 @@
|
||||
[toolchain]
|
||||
channel = "1.98.1"
|
||||
profile = "minimal"
|
||||
+27
-11
@@ -697,7 +697,28 @@ async fn check_update(state: State<'_, AppState>, id: String, source: Option<Str
|
||||
#[tauri::command]
|
||||
fn pending_update(state: State<'_, AppState>, id: String) -> std::result::Result<Option<update::Txn>, UiError> {
|
||||
let root = path_of(&state, &id)?;
|
||||
Ok(update::unfinished(&meta_dir(&root)?))
|
||||
let dir = meta_dir(&root)?;
|
||||
let latest = update::latest(&dir)?;
|
||||
Ok(update::unfinished(&dir).or_else(|| latest.filter(|t| t.state == update::State::Committed && t.server_stopped)))
|
||||
}
|
||||
|
||||
#[tauri::command]
|
||||
async fn recover_update(state: State<'_, AppState>, id: String) -> std::result::Result<Option<update::Txn>, UiError> {
|
||||
let root = path_of(&state, &id)?;
|
||||
let _guard = BusyGuard::acquire(&state, &id)?;
|
||||
blocking(move || update::recover(&root, &meta_dir(&root)?)).await.map_err(UiError::from)
|
||||
}
|
||||
|
||||
#[tauri::command]
|
||||
fn last_update(state: State<'_, AppState>, id: String) -> std::result::Result<Option<update::Txn>, UiError> {
|
||||
let root = path_of(&state, &id)?;
|
||||
Ok(update::latest(&meta_dir(&root)?)?)
|
||||
}
|
||||
|
||||
#[tauri::command]
|
||||
fn last_update_result(state: State<'_, AppState>, id: String) -> std::result::Result<Option<update::ExecutionResult>, UiError> {
|
||||
let root = path_of(&state, &id)?;
|
||||
Ok(update::last_execution_result(&meta_dir(&root)?)?)
|
||||
}
|
||||
|
||||
#[tauri::command]
|
||||
@@ -707,22 +728,14 @@ async fn apply_update(
|
||||
id: String,
|
||||
source: Option<String>,
|
||||
resolutions: BTreeMap<String, Resolution>,
|
||||
) -> std::result::Result<update::Outcome, UiError> {
|
||||
) -> std::result::Result<update::ExecutionResult, UiError> {
|
||||
let root = path_of(&state, &id)?;
|
||||
let src = update_source(source);
|
||||
let _guard = BusyGuard::acquire(&state, &id)?;
|
||||
blocking(move || {
|
||||
let (dir, _) = install_meta(&root)?;
|
||||
// Files cannot be replaced while the server runs: stop it first (gracefully), like the Stop button.
|
||||
let observed = coa_core::process::observe(&root, &layout::read_ports(&root));
|
||||
if observed.world.state != coa_core::process::ServiceState::Stopped || observed.auth.state != coa_core::process::ServiceState::Stopped || coa_core::multiworld::is_running(&root) {
|
||||
let out = driver::run(&root, Verb::StopAll)?;
|
||||
if !out.ok {
|
||||
return Err(Error::Invalid("The server could not be stopped, so the update was not started.".into()));
|
||||
}
|
||||
}
|
||||
let env = update::RepackEnv { root: &root, meta_dir: &dir };
|
||||
update::apply(
|
||||
update::execute(
|
||||
&update::Params { root: &root, meta_dir: &dir, source: src, trusted_key: coa_core::signing::EMBEDDED_PUBLIC_KEY, cancel: Cancel::default(), resolutions, env: &env, fail_after_ops: None },
|
||||
&|step, percent| {
|
||||
let _ = app.emit("update-progress", serde_json::json!({ "step": step, "percent": percent }));
|
||||
@@ -1569,6 +1582,9 @@ pub fn run() {
|
||||
create_account,
|
||||
check_update,
|
||||
pending_update,
|
||||
recover_update,
|
||||
last_update,
|
||||
last_update_result,
|
||||
apply_update,
|
||||
rollback_update,
|
||||
retry_update_validation,
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
{
|
||||
"$schema": "https://schema.tauri.app/config/2",
|
||||
"productName": "CoA Server Manager",
|
||||
"version": "0.6.4",
|
||||
"version": "0.6.5",
|
||||
"identifier": "com.coa.servermanager",
|
||||
"build": {
|
||||
"beforeDevCommand": "npm run dev",
|
||||
|
||||
+2
-1
@@ -47,7 +47,8 @@ export {};
|
||||
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 {txn:{state:"committed",to_version:"0.261001.8"},migrations:null};}
|
||||
if(cmd==="apply_update"){const w=window as any;for(let i=1;i<=8;i++){await new Promise((r: any)=>setTimeout(r,700));(w.__handlers?.["update-progress"]??[]).forEach((h: any)=>h({event:"update-progress",id:1,payload:{step:i<4?"Downloading the update":i<7?"Applying the update":"Finishing",percent:i*12}}));}(window as any).__updated=true;return {disposition:"updated",txn:{state:"committed",to_version:"0.261001.8"},message:null};}
|
||||
if(cmd==="pending_update" || cmd==="last_update" || cmd==="last_update_result" || cmd==="recover_update") return null;
|
||||
if(cmd==="get_population"){if(!running) return null;let b=(window as any).__bots??85;const t=(window as any).__target??0;if(t>b){b=Math.min(t,b+25);(window as any).__bots=b;}return {online_total:b,bots_online:Math.max(0,b-7),players_online:0,bots_total:b};}
|
||||
if(cmd==="get_performance") return running?{mean_ms:14,median_ms:15,p95_ms:24,p99_ms:30,max_ms:61,ticks_per_sec:71.4}:null;
|
||||
if(cmd==="run_diagnostics") return {problems:2,checks:[{id:"files",title:"Server files",level:"ok",detail:"All expected server parts were found."},{id:"world",title:"World server",level:"warn",detail:"Not running."},{id:"disk",title:"Free disk space",level:"warn",detail:"Only 3 GB free; backups and updates need room."},{id:"exposure",title:"Private services",level:"ok",detail:"Database and server console are not reachable from the network."}]};
|
||||
|
||||
@@ -371,6 +371,7 @@ const de: Partial<Record<keyof typeof en, string>> = {
|
||||
"upd.backNote": "Die Rückkehr stellt Dateien und Einstellungen wieder her. Wurden Datenbankupdates begonnen, werden auch alle Datenbanken aus der Sicherung vor dem Update wiederhergestellt. Späterer Fortschritt geht verloren.",
|
||||
"upd.goBackTo": "Zu Version {v} zurückkehren",
|
||||
"upd.goBackBefore": "Zur Version vor dem Update zurückkehren",
|
||||
"upd.autoRestored": "Die Aktualisierung ist fehlgeschlagen. Der vorherige Server wurde automatisch wiederhergestellt.",
|
||||
"upd.title": "Server-Updates",
|
||||
"upd.text": "Updates werden auf Echtheit geprüft, vorher gesichert und können rückgängig gemacht werden.",
|
||||
"upd.check": "Nach Updates suchen",
|
||||
|
||||
@@ -404,6 +404,7 @@ const en = {
|
||||
"upd.backNote": "Going back restores files and settings. If database updates started, it also restores all databases to the backup taken before the update. Later progress will be lost.",
|
||||
"upd.goBackTo": "Go back to version {v}",
|
||||
"upd.goBackBefore": "Go back to the version before the update",
|
||||
"upd.autoRestored": "The update failed validation. Your previous server was restored automatically.",
|
||||
"upd.title": "Server updates",
|
||||
"upd.text": "Updates are checked for authenticity, backed up first, and can be undone.",
|
||||
"upd.check": "Check for updates",
|
||||
|
||||
@@ -371,6 +371,7 @@ const es: Partial<Record<keyof typeof en, string>> = {
|
||||
"upd.backNote": "Volver restaura los archivos y los ajustes. Si comenzaron las actualizaciones de las bases de datos, también se restauran todas las bases desde la copia anterior a la actualización. Se perderá el progreso posterior.",
|
||||
"upd.goBackTo": "Volver a la versión {v}",
|
||||
"upd.goBackBefore": "Volver a la versión anterior a la actualización",
|
||||
"upd.autoRestored": "La actualización falló. El servidor anterior se restauró automáticamente.",
|
||||
"upd.title": "Actualizaciones del servidor",
|
||||
"upd.text": "Las actualizaciones se comprueban, se respaldan antes y se pueden deshacer.",
|
||||
"upd.check": "Buscar actualizaciones",
|
||||
|
||||
@@ -371,6 +371,7 @@ const fr: Partial<Record<keyof typeof en, string>> = {
|
||||
"upd.backNote": "Le retour restaure les fichiers et les paramètres. Si la mise à jour des bases a commencé, toutes les bases sont aussi restaurées depuis la sauvegarde précédant la mise à jour. La progression ultérieure sera perdue.",
|
||||
"upd.goBackTo": "Revenir à la version {v}",
|
||||
"upd.goBackBefore": "Revenir à la version d’avant la mise à jour",
|
||||
"upd.autoRestored": "La mise à jour a échoué. Le serveur précédent a été restauré automatiquement.",
|
||||
"upd.title": "Mises à jour du serveur",
|
||||
"upd.text": "Les mises à jour sont vérifiées, sauvegardées au préalable et peuvent être annulées.",
|
||||
"upd.check": "Rechercher des mises à jour",
|
||||
|
||||
@@ -402,6 +402,7 @@ const ru: Partial<Record<keyof typeof en, string>> = {
|
||||
"upd.backNote": "Возврат восстанавливает файлы и настройки. Если обновление баз уже началось, все базы также восстанавливаются из копии перед обновлением. Более поздний прогресс будет потерян.",
|
||||
"upd.goBackTo": "Вернуться к версии {v}",
|
||||
"upd.goBackBefore": "Вернуться к версии до обновления",
|
||||
"upd.autoRestored": "Обновление не прошло проверку. Прежний сервер автоматически восстановлен.",
|
||||
"upd.title": "Обновления сервера",
|
||||
"upd.text": "Подлинность обновлений проверяется, перед ними делается резервная копия, и их можно отменить.",
|
||||
"upd.check": "Проверить обновления",
|
||||
|
||||
@@ -383,6 +383,7 @@ const zh = {
|
||||
"upd.backNote": "回滚将恢复文件和设置。如果数据库更新已开始,所有数据库也将从更新前的备份恢复。之后的进度将丢失。",
|
||||
"upd.goBackTo": "回滚至版本 {v}",
|
||||
"upd.goBackBefore": "回滚至更新前的版本",
|
||||
"upd.autoRestored": "更新验证失败。之前的服务器已自动恢复。",
|
||||
"upd.title": "服务器更新",
|
||||
"upd.text": "更新均经过真实性签名校验,并在执行前自动备份,随时可安全撤销。",
|
||||
"upd.check": "检查更新",
|
||||
|
||||
+17
-2
@@ -95,6 +95,12 @@ export interface UiError {
|
||||
fields?: FieldError[];
|
||||
}
|
||||
|
||||
export interface UpdateExecutionResult {
|
||||
disposition: "updated" | "rejected" | "restored" | "recovery-required";
|
||||
txn: UpdateTxn | null;
|
||||
message: string | null;
|
||||
}
|
||||
|
||||
export type Scope = "bots" | "server";
|
||||
export type Restart = "runtime" | "world" | "full";
|
||||
export type JsonValue = string | number | boolean;
|
||||
@@ -275,12 +281,18 @@ export interface UpdatePreview {
|
||||
|
||||
export interface UpdateTxn {
|
||||
id: string;
|
||||
state: "prepared" | "applying" | "applied" | "needs-decision" | "committed" | "rolled-back" | "failed";
|
||||
state: "prepared" | "stopping" | "snapshotting" | "trialing" | "applying" | "applied" | "migrating" | "validating" | "committing" | "restoring" | "needs-decision" | "committed" | "rolled-back" | "failed";
|
||||
failure_stage?: UpdateTxn["state"];
|
||||
from_version: string | null;
|
||||
to_version: string;
|
||||
recovery_point: string | null;
|
||||
databases_started: boolean;
|
||||
message: string | null;
|
||||
outcome?: "updated" | "rejected" | "restored" | "recovery-required" | null;
|
||||
manifest_sha256?: string | null;
|
||||
was_running?: boolean;
|
||||
recovery_verified?: boolean;
|
||||
trial_completed?: boolean;
|
||||
}
|
||||
|
||||
export interface Population {
|
||||
@@ -429,8 +441,11 @@ export const api = {
|
||||
invoke<void>("create_account", { id, username, password, administrator }),
|
||||
checkUpdate: (id: string, source?: string) => invoke<UpdatePreview>("check_update", { id, source: source ?? null }),
|
||||
pendingUpdate: (id: string) => invoke<UpdateTxn | null>("pending_update", { id }),
|
||||
lastUpdate: (id: string) => invoke<UpdateTxn | null>("last_update", { id }),
|
||||
recoverUpdate: (id: string) => invoke<UpdateTxn | null>("recover_update", { id }),
|
||||
applyUpdate: (id: string, resolutions: Record<string, "keep" | "replace">, source?: string) =>
|
||||
invoke<{ txn: UpdateTxn }>("apply_update", { id, source: source ?? null, resolutions }),
|
||||
invoke<UpdateExecutionResult>("apply_update", { id, source: source ?? null, resolutions }),
|
||||
lastUpdateResult: (id: string) => invoke<UpdateExecutionResult | null>("last_update_result", { id }),
|
||||
rollbackUpdate: (id: string, txn: string) => invoke<UpdateTxn>("rollback_update", { id, txn }),
|
||||
retryUpdateValidation: (id: string, txn: string) => invoke<UpdateTxn>("retry_update_validation", { id, txn }),
|
||||
population: (id: string) => invoke<Population | null>("get_population", { id }),
|
||||
|
||||
+24
-4
@@ -17,7 +17,7 @@ export interface ServerUpdateState {
|
||||
/** The full error of the last update attempt, for the Settings card. */
|
||||
uiError: UiError | null;
|
||||
/** How the last update ended; kept here so the Settings card can show it after the user left and came back. */
|
||||
result: { committed: string } | { pending: UpdateTxn } | null;
|
||||
result: { committed: string } | { pending: UpdateTxn } | { recovered: UpdateTxn } | null;
|
||||
}
|
||||
|
||||
const EMPTY: ServerUpdateState = { preview: null, available: false, checking: false, applying: false, step: null, percent: 0, error: null, uiError: null, result: null };
|
||||
@@ -48,7 +48,21 @@ export async function checkServerUpdate(id: string): Promise<void> {
|
||||
|
||||
/** Check now and then every five minutes. Returns the function that stops it. */
|
||||
export function startServerUpdatePolling(id: string): () => void {
|
||||
void checkServerUpdate(id);
|
||||
void (async () => {
|
||||
try {
|
||||
const pending = await api.pendingUpdate(id);
|
||||
if (pending) {
|
||||
set(id, { applying: true, step: "Recovering the interrupted update", result: null });
|
||||
const recovered = await api.recoverUpdate(id);
|
||||
if (recovered) set(id, { result: recovered.state === "committed" ? { committed: recovered.to_version } : { recovered } });
|
||||
}
|
||||
} catch (e) {
|
||||
const ui = asUiError(e);
|
||||
set(id, { error: ui.human.code, uiError: ui });
|
||||
return;
|
||||
} finally { set(id, { applying: false, step: null }); }
|
||||
await checkServerUpdate(id);
|
||||
})();
|
||||
const t = setInterval(() => void checkServerUpdate(id), CHECK_EVERY_MS);
|
||||
return () => clearInterval(t);
|
||||
}
|
||||
@@ -76,8 +90,14 @@ export async function applyServerUpdate(id: string, opts?: { choices: Record<str
|
||||
}
|
||||
try {
|
||||
const out = await api.applyUpdate(id, opts?.choices ?? {}, opts?.source);
|
||||
set(id, { result: out.txn.state === "committed" ? { committed: out.txn.to_version ?? "" } : { pending: out.txn } });
|
||||
return true;
|
||||
if (out.disposition === "updated" && out.txn) {
|
||||
set(id, { result: { committed: out.txn.to_version } });
|
||||
return true;
|
||||
}
|
||||
if (out.txn) set(id, { result: out.disposition === "restored" ? { recovered: out.txn } : { pending: out.txn } });
|
||||
const ui = asUiError(out.message ?? out.disposition);
|
||||
set(id, { error: ui.human.code, uiError: ui });
|
||||
return false;
|
||||
} catch (e) {
|
||||
const ui = asUiError(e);
|
||||
set(id, { error: ui.human.code, uiError: ui });
|
||||
|
||||
@@ -36,7 +36,15 @@ export function SettingsHome({ serverId }: { serverId: string }) {
|
||||
const [source, setSource] = useState("");
|
||||
|
||||
useEffect(() => {
|
||||
void api.pendingUpdate(serverId).then(setPending).catch(() => {});
|
||||
void api.pendingUpdate(serverId).then(setPending).catch((e) => setError(asUiError(e)));
|
||||
void api.lastUpdateResult(serverId).then(async (result) => {
|
||||
const txn = result?.txn ?? await api.lastUpdate(serverId);
|
||||
if (result?.disposition === "rejected" || result?.disposition === "recovery-required") {
|
||||
setDone(null);
|
||||
if (result.message) setError(asUiError(result.message));
|
||||
} else if (txn?.outcome === "restored" && txn.recovery_verified) setDone(t("upd.autoRestored"));
|
||||
else if (result?.disposition === "updated" && txn) setDone(t("upd.updatedTo", { v: txn.to_version }));
|
||||
}).catch((e) => setError(asUiError(e)));
|
||||
}, [serverId]);
|
||||
|
||||
// the update finished (possibly while another tab was open): drop the stale preview, show what is left to decide
|
||||
@@ -44,7 +52,10 @@ export function SettingsHome({ serverId }: { serverId: string }) {
|
||||
if (!upd.result) return;
|
||||
setPreview(null);
|
||||
if ("pending" in upd.result) setPending(upd.result.pending);
|
||||
else void api.pendingUpdate(serverId).then(setPending).catch(() => {});
|
||||
else {
|
||||
if ("recovered" in upd.result && upd.result.recovered.recovery_verified) setDone(t("upd.autoRestored"));
|
||||
void api.pendingUpdate(serverId).then(setPending).catch((e) => setError(asUiError(e)));
|
||||
}
|
||||
}, [upd.result, serverId]);
|
||||
|
||||
async function check() {
|
||||
@@ -68,6 +79,9 @@ export function SettingsHome({ serverId }: { serverId: string }) {
|
||||
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) {
|
||||
|
||||
@@ -0,0 +1,133 @@
|
||||
param(
|
||||
[Parameter(Mandatory)][string]$BasePackage,
|
||||
[Parameter(Mandatory)][string]$CandidatePackage,
|
||||
[string]$DataSource = '',
|
||||
[string]$PreviousPackage = '',
|
||||
[ValidateSet('coa','wildcard','dual','squid','imported')][string]$Mode = 'coa',
|
||||
[switch]$SkipBuild,
|
||||
[string]$ReportFile = '',
|
||||
[string]$Target = (Join-Path $env:RUNNER_TEMP ('coa-schema-fixture-chaos-' + [guid]::NewGuid().ToString('N')))
|
||||
)
|
||||
$ErrorActionPreference = 'Stop'
|
||||
$project = Split-Path $PSScriptRoot -Parent
|
||||
$tool = Join-Path $project 'target/debug/coa-release.exe'
|
||||
$test = Join-Path $project 'target/debug/examples/update_acceptance_e2e.exe'
|
||||
if (Test-Path -LiteralPath $Target) { throw 'Use a new disposable fixture directory.' }
|
||||
if ((Split-Path $Target -Leaf) -notlike 'coa-schema-fixture-chaos-*') { throw 'Invalid disposable fixture name.' }
|
||||
if (-not $SkipBuild) {
|
||||
& cargo build --manifest-path "$project/Cargo.toml" -p coa-release -p coa-core --example update_acceptance_e2e --features coa-core/testkit --locked
|
||||
if ($LASTEXITCODE) { throw 'Could not build acceptance tools.' }
|
||||
& cargo build --manifest-path "$project/Cargo.toml" -p coa-release --locked
|
||||
if ($LASTEXITCODE) { throw 'Could not build release tools.' }
|
||||
}
|
||||
if (-not (Test-Path -LiteralPath $tool) -or -not (Test-Path -LiteralPath $test)) { throw 'Acceptance tools are missing.' }
|
||||
& $tool extract-schema-base --package $BasePackage --fixture $Target
|
||||
if ($LASTEXITCODE) { throw 'Could not prepare the signed base.' }
|
||||
[IO.File]::WriteAllText((Join-Path $Target '.coa-chaos-fixture'), 'disposable update chaos fixture')
|
||||
# A real independent copy: a junction would allow validation to modify source data.
|
||||
if ($DataSource) {
|
||||
& robocopy $DataSource (Join-Path $Target 'Data') /E /R:1 /W:1 /NFL /NDL /NJH /NJS /NP | Out-Null
|
||||
if ($LASTEXITCODE -ge 8) { throw 'Could not copy isolated game data.' }
|
||||
} else {
|
||||
& $tool extract-game-data --package $BasePackage --fixture $Target
|
||||
if ($LASTEXITCODE) { throw 'Could not extract signed game data.' }
|
||||
}
|
||||
& $test init $Target
|
||||
if ($LASTEXITCODE) { throw 'Could not initialize sentinels.' }
|
||||
& $test seed-players $Target
|
||||
if ($LASTEXITCODE) { throw 'Could not seed real account, character and inventory records.' }
|
||||
if ($PreviousPackage) {
|
||||
& $test baseline-release $Target $PreviousPackage
|
||||
if ($LASTEXITCODE) { throw 'Previous published release could not be established.' }
|
||||
}
|
||||
& $test apply $Target $CandidatePackage
|
||||
if ($LASTEXITCODE) { throw 'Candidate failed acceptance.' }
|
||||
& $test prepare-mode $Target $Mode
|
||||
if ($LASTEXITCODE) { throw "Could not prepare $Mode installation." }
|
||||
if ($PreviousPackage) {
|
||||
# Re-establish the old signed release after mode provisioning, so the actual
|
||||
# upgrade below runs in this mode rather than only in the initial CoA setup.
|
||||
& $test baseline-release $Target $PreviousPackage
|
||||
if ($LASTEXITCODE) { throw "Previous release could not be established in $Mode mode." }
|
||||
}
|
||||
& $test seed-config $Target
|
||||
if ($LASTEXITCODE) { throw 'Could not seed a modified user configuration.' }
|
||||
& $test break-legacy-baseline $Target
|
||||
if ($LASTEXITCODE) { throw 'Could not inject missing-table baseline.' }
|
||||
& $test apply $Target $CandidatePackage
|
||||
if ($LASTEXITCODE) { throw 'Legacy missing-table baseline was not repaired.' }
|
||||
& $test verify $Target
|
||||
if ($LASTEXITCODE) { throw 'Sentinels were lost.' }
|
||||
foreach ($rejection in @('expect-corrupt-package','expect-locked-file','expect-occupied-port')) {
|
||||
& $test $rejection $Target $CandidatePackage
|
||||
if ($LASTEXITCODE) { throw "$rejection did not reject safely." }
|
||||
}
|
||||
$oldPythonFailure = $env:COA_UPDATE_PYTHON_FAILURE
|
||||
try {
|
||||
$env:COA_UPDATE_PYTHON_FAILURE = '1'
|
||||
& $test expect-rejection $Target $CandidatePackage
|
||||
if ($LASTEXITCODE) { throw 'Python failure was not restored.' }
|
||||
} finally { $env:COA_UPDATE_PYTHON_FAILURE = $oldPythonFailure }
|
||||
$oldValidation = $env:COA_UPDATE_VALIDATION
|
||||
try {
|
||||
$env:COA_UPDATE_VALIDATION = '1'
|
||||
& $test start-fixture $Target
|
||||
if ($LASTEXITCODE) { throw 'Original offline fixture could not start.' }
|
||||
$env:COA_UPDATE_PYTHON_FAILURE = '1'
|
||||
& $test expect-rejection $Target $CandidatePackage
|
||||
if ($LASTEXITCODE) { throw 'The originally running server was not restored.' }
|
||||
} finally {
|
||||
$env:COA_UPDATE_PYTHON_FAILURE = $oldPythonFailure
|
||||
& $test stop-fixture $Target
|
||||
$stopResult = $LASTEXITCODE
|
||||
$env:COA_UPDATE_VALIDATION = $oldValidation
|
||||
if ($stopResult) { throw 'The offline running-state fixture could not be stopped.' }
|
||||
}
|
||||
$oldSqlFailure = $env:COA_UPDATE_SQL_FAILURE
|
||||
try {
|
||||
& $test break-legacy-baseline $Target
|
||||
if ($LASTEXITCODE) { throw 'Could not prepare partial-DDL failure.' }
|
||||
$env:COA_UPDATE_SQL_FAILURE = 'manager_repair__20261005_reconcile_wildcard_tables'
|
||||
& $test expect-rejection $Target $CandidatePackage
|
||||
if ($LASTEXITCODE) { throw 'Partial DDL/SQL failure was not restored.' }
|
||||
} finally { $env:COA_UPDATE_SQL_FAILURE = $oldSqlFailure }
|
||||
$oldCrash = $env:COA_UPDATE_CRASH_AT
|
||||
try {
|
||||
$env:COA_UPDATE_CRASH_AT = 'snapshot-recorded'
|
||||
& $test apply $Target $CandidatePackage
|
||||
if ($LASTEXITCODE -ne 91) { throw 'The recorded-snapshot interruption was not exercised.' }
|
||||
$env:COA_UPDATE_CRASH_AT = ''
|
||||
foreach ($corruption in @('expect-corrupt-journal','expect-corrupt-recovery-point')) {
|
||||
& $test $corruption $Target
|
||||
if ($LASTEXITCODE) { throw "Corruption guard $corruption failed." }
|
||||
}
|
||||
& $test rollback $Target
|
||||
if ($LASTEXITCODE) { throw 'Recovery after removing injected corruption failed.' }
|
||||
foreach ($point in @('stopped','snapshot','trial','before-file:0','journal-file:0','written-file:0','completed-file:0','applied','before-migrations','before-sql:manager_repair__20261005_reconcile_wildcard_tables','after-sql:manager_repair__20261005_reconcile_wildcard_tables','recorded-sql:manager_repair__20261005_reconcile_wildcard_tables','migrated','validated','before-commit','commit-metadata')) {
|
||||
$env:COA_UPDATE_CRASH_AT = ''
|
||||
& $test break-legacy-baseline $Target
|
||||
if ($LASTEXITCODE) { throw 'Could not reset isolated baseline.' }
|
||||
& $test dirty-fixture $Target $CandidatePackage
|
||||
if ($LASTEXITCODE) { throw 'Could not arrange a real file replacement.' }
|
||||
$env:COA_UPDATE_CRASH_AT = $point
|
||||
& $test apply $Target $CandidatePackage
|
||||
if ($LASTEXITCODE -ne 91) { throw "Fault point $point was not exercised (exit $LASTEXITCODE)." }
|
||||
foreach ($recoveryPoint in @('restore-stopped','restore-databases','restore-files')) {
|
||||
$env:COA_UPDATE_CRASH_AT = $recoveryPoint
|
||||
& $test rollback $Target
|
||||
# restore-databases may not be reached before any live database changes.
|
||||
if ($LASTEXITCODE -notin @(0,91)) { throw "Recovery fault $recoveryPoint failed." }
|
||||
if ($LASTEXITCODE -eq 0) { break }
|
||||
}
|
||||
$env:COA_UPDATE_CRASH_AT = ''
|
||||
& $test rollback $Target
|
||||
if ($LASTEXITCODE) { throw "Recovery from $point failed." }
|
||||
}
|
||||
} finally { $env:COA_UPDATE_CRASH_AT = $oldCrash }
|
||||
$manifest = Get-Content (Join-Path $CandidatePackage 'manifest.json') -Raw | ConvertFrom-Json
|
||||
$managerSource = (& git -C $project rev-parse HEAD).Trim()
|
||||
if ($LASTEXITCODE -or $managerSource -notmatch '^[0-9a-f]{40}$') { throw 'Cannot identify the tested manager source.' }
|
||||
$report = @{ schema = 1; version = $manifest.version; manifestSha256 = (Get-FileHash (Join-Path $CandidatePackage 'manifest.json') -Algorithm SHA256).Hash.ToLower(); manager = (Get-FileHash $test -Algorithm SHA256).Hash.ToLower(); managerSource = $managerSource; mode = $Mode; baseline = $(if ($PreviousPackage) { (Get-Content (Join-Path $PreviousPackage 'manifest.json') -Raw | ConvertFrom-Json).version } else { 'base' }); result = 'passed' }
|
||||
$report.coverage = @('signed-package-corruption','locked-file','occupied-port','python-startup-failure','partial-ddl-invalid-sql','update-process-crash','recovery-process-crash','modified-config-preservation','running-state-recovery','player-data-preservation','corrupt-journal','corrupt-recovery-point')
|
||||
if (-not $ReportFile) { $ReportFile = Join-Path $CandidatePackage 'acceptance.json' }
|
||||
$report | ConvertTo-Json | Set-Content $ReportFile -Encoding utf8NoBOM
|
||||
@@ -0,0 +1,81 @@
|
||||
param(
|
||||
[Parameter(Mandatory)][string]$BasePackage,
|
||||
[Parameter(Mandatory)][string]$CandidatePackage,
|
||||
[string]$PreviousPackage = '',
|
||||
[string]$DataSource = '',
|
||||
[ValidateRange(1,5)][int]$MaxParallel = 2,
|
||||
[string]$WorkDirectory = (Join-Path $env:RUNNER_TEMP ('coa-acceptance-' + [guid]::NewGuid().ToString('N')))
|
||||
)
|
||||
$ErrorActionPreference = 'Stop'
|
||||
$project = Split-Path $PSScriptRoot -Parent
|
||||
& git -C $project diff --quiet HEAD --
|
||||
if ($LASTEXITCODE) { throw 'Release acceptance requires committed manager source; tracked changes are present.' }
|
||||
$untrackedSource = & git -C $project ls-files --others --exclude-standard -- crates src src-tauri tools .github
|
||||
if ($LASTEXITCODE -or $untrackedSource) { throw 'Release acceptance requires committed manager source; untracked source files are present.' }
|
||||
$base = (Resolve-Path -LiteralPath $BasePackage).Path
|
||||
$candidate = (Resolve-Path -LiteralPath $CandidatePackage).Path
|
||||
$previous = if ($PreviousPackage) { (Resolve-Path -LiteralPath $PreviousPackage).Path } else { '' }
|
||||
$data = if ($DataSource) { (Resolve-Path -LiteralPath $DataSource).Path } else { '' }
|
||||
if (Test-Path -LiteralPath $WorkDirectory) { throw 'Use a fresh acceptance work directory.' }
|
||||
New-Item -ItemType Directory -Path $WorkDirectory | Out-Null
|
||||
$work = (Resolve-Path -LiteralPath $WorkDirectory).Path
|
||||
& cargo build --manifest-path "$project/Cargo.toml" -p coa-core --example update_acceptance_e2e --features testkit --locked
|
||||
if ($LASTEXITCODE) { throw 'Could not build the marked-fixture acceptance tool.' }
|
||||
& cargo build --manifest-path "$project/Cargo.toml" -p coa-release --locked
|
||||
if ($LASTEXITCODE) { throw 'Could not build signature verification tools.' }
|
||||
|
||||
$queue = [Collections.Generic.Queue[object]]::new()
|
||||
foreach ($mode in @('coa','wildcard','dual','squid','imported')) {
|
||||
$queue.Enqueue(@{ mode=$mode; baseline='base'; previous='' })
|
||||
if ($previous) { $queue.Enqueue(@{ mode=$mode; baseline='previous'; previous=$previous }) }
|
||||
}
|
||||
$active = [Collections.Generic.List[object]]::new()
|
||||
$completed = [Collections.Generic.List[object]]::new()
|
||||
try {
|
||||
while ($queue.Count -or $active.Count) {
|
||||
while ($queue.Count -and $active.Count -lt $MaxParallel) {
|
||||
$job = $queue.Dequeue()
|
||||
$name = "$($job.mode)-$($job.baseline)"
|
||||
$report = Join-Path $work "$name.json"
|
||||
$target = Join-Path $work "coa-schema-fixture-chaos-$name"
|
||||
$arguments = @('-NoProfile','-File', ('"' + (Join-Path $PSScriptRoot 'update-chaos-gate.ps1') + '"'), '-SkipBuild', '-BasePackage', ('"' + $base + '"'), '-CandidatePackage', ('"' + $candidate + '"'), '-Target', ('"' + $target + '"'), '-Mode', $job.mode, '-ReportFile', ('"' + $report + '"'))
|
||||
if ($job.previous) { $arguments += @('-PreviousPackage', ('"' + $job.previous + '"')) }
|
||||
if ($data) { $arguments += @('-DataSource', ('"' + $data + '"')) }
|
||||
$process = Start-Process -FilePath (Get-Process -Id $PID).Path -ArgumentList $arguments -WindowStyle Hidden -PassThru -RedirectStandardOutput (Join-Path $work "$name.log") -RedirectStandardError (Join-Path $work "$name.errors.log")
|
||||
$active.Add(@{ process=$process; name=$name; report=$report })
|
||||
Write-Output "Started isolated $name acceptance"
|
||||
}
|
||||
foreach ($job in @($active.ToArray())) {
|
||||
$job.process.Refresh()
|
||||
if (-not $job.process.HasExited) { continue }
|
||||
$job.process.WaitForExit()
|
||||
if ($job.process.ExitCode -ne 0 -or -not (Test-Path -LiteralPath $job.report)) {
|
||||
throw "Acceptance $($job.name) failed. Logs and marked copies are preserved at $work."
|
||||
}
|
||||
$completed.Add((Get-Content -LiteralPath $job.report -Raw | ConvertFrom-Json))
|
||||
$active.Remove($job) | Out-Null
|
||||
Write-Output "Passed isolated $($job.name) acceptance"
|
||||
}
|
||||
if ($active.Count) { Start-Sleep -Seconds 1 }
|
||||
}
|
||||
} catch {
|
||||
# Do not kill recovery processes or remove their copies. Each active fixture completes
|
||||
# independently; the parent fails publication immediately.
|
||||
throw
|
||||
}
|
||||
$manifestHash = (Get-FileHash (Join-Path $candidate 'manifest.json')).Hash.ToLower()
|
||||
$manifest = Get-Content (Join-Path $candidate 'manifest.json') -Raw | ConvertFrom-Json
|
||||
foreach ($result in $completed) {
|
||||
if ($result.result -ne 'passed' -or $result.manifestSha256 -ne $manifestHash -or $result.version -ne $manifest.version -or $result.managerSource -ne $completed[0].managerSource) { throw 'Acceptance results refer to different source or package bytes.' }
|
||||
}
|
||||
$expected = if ($previous) { 10 } else { 5 }
|
||||
if ($completed.Count -ne $expected) { throw 'Incomplete update acceptance matrix.' }
|
||||
$requiredCoverage = @('signed-package-corruption','locked-file','occupied-port','python-startup-failure','partial-ddl-invalid-sql','update-process-crash','recovery-process-crash','modified-config-preservation','running-state-recovery','player-data-preservation','disk-exhaustion','write-denial','corrupt-journal','corrupt-recovery-point','database-process-crash','new-server-crash','network-action-containment','all-file-operation-phases')
|
||||
$missingCoverage = @($requiredCoverage | Where-Object {
|
||||
$required = $_
|
||||
@($completed | Where-Object { $required -notin $_.coverage }).Count -gt 0
|
||||
})
|
||||
$combined = @{ schema=1; result=$(if ($missingCoverage.Count) { 'incomplete' } else { 'passed' }); version=$manifest.version; manifestSha256=$manifestHash; manager=$completed[0].manager; managerSource=$completed[0].managerSource; scenarios=$completed.ToArray(); missingCoverage=$missingCoverage }
|
||||
$combined | ConvertTo-Json -Depth 10 | Set-Content (Join-Path $candidate 'acceptance.json') -Encoding utf8NoBOM
|
||||
if ($missingCoverage.Count) { throw "Publication is blocked: release fault coverage is incomplete ($($missingCoverage -join ', ')). Scenario results were preserved." }
|
||||
Write-Output "Passed all $expected update acceptance scenarios"
|
||||
Reference in new issue
Block a user