mirror of
https://github.com/Corfirean/coa-server-manager.git
synced 2026-11-19 03:25:56 +00:00
Compare commits
4
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
ab4bc9fd96 | ||
|
|
654b7cddd3 | ||
|
|
f8301d7394 | ||
|
|
cd3a963f70 |
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: added
|
||||
audience: admins
|
||||
title: Imported SquidBots servers warn before replacing their original binary
|
||||
---
|
||||
Imports explain that the original launcher and updater check the server binary hash. Updating that binary requires an explicit choice to keep or replace it.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: changed
|
||||
audience: admins
|
||||
title: Server updates are tested on a private copy and automatically restored after failure
|
||||
---
|
||||
Updates keep a fixed verified package, preserve migration history, and recover interrupted changes before starting the server. Recovery problems show a specific reason and keep the available backups.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: added
|
||||
audience: admins
|
||||
title: SquidBots settings follow the options shipped by the module
|
||||
---
|
||||
New settings use the module's descriptions, groups, defaults and value limits while retaining existing translations. Unknown formats or invalid fields use built-in controls so the settings page remains available.
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
area: manager
|
||||
type: added
|
||||
audience: admins
|
||||
title: SquidBots shows its bundled release and includes it in problem reports
|
||||
---
|
||||
The Bots and Modules pages and problem reports include the release identifiers. Imported repacks use their recorded bot revision; empty tags are hidden. The settings file's source commit is not presented as the build revision.
|
||||
@@ -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()));
|
||||
|
||||
@@ -199,6 +199,7 @@ pub fn export_package(root: &Path, meta_dir: &Path, manager_log: &Path, meta: &I
|
||||
"manager": crate::MANAGER_VERSION,
|
||||
"core": meta.core,
|
||||
"bots": meta.bots,
|
||||
"squid_bots": crate::squid::release(root),
|
||||
"kind": meta.kind,
|
||||
"layout": meta.layout,
|
||||
"checks": report.checks,
|
||||
@@ -248,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)
|
||||
}
|
||||
@@ -323,6 +332,8 @@ real error
|
||||
let d = tempfile::tempdir().unwrap();
|
||||
let root = d.path().join("srv");
|
||||
layout::testkit::fake_repack(&root);
|
||||
fs::create_dir_all(root.join("Extras/SquidPlayerbots")).unwrap();
|
||||
fs::write(root.join("Extras/SquidPlayerbots/release.json"), r#"{"tag":"v1.8","commit":"48c4786a","password":"upstream-secret"}"#).unwrap();
|
||||
fs::write(root.join("Core/Logs/Errors.log"), "boom\nDatabase password=hunter2 rejected\n").unwrap();
|
||||
fs::write(root.join("Core/configs/worldserver.conf"), "LoginDatabaseInfo = \"127.0.0.1;3307;acore;SECRETPW;auth\"\nRate.XP.Kill = 1\n").unwrap();
|
||||
let meta_dir = d.path().join("srv.manager");
|
||||
@@ -340,6 +351,7 @@ real error
|
||||
all.push_str(&s);
|
||||
}
|
||||
assert!(all.contains("boom") && all.contains("Rate.XP.Kill"), "keys and ordinary log lines are included");
|
||||
assert!(!all.contains("hunter2") && !all.contains("SECRETPW"));
|
||||
assert!(all.contains("v1.8") && all.contains("48c4786a"));
|
||||
assert!(!all.contains("hunter2") && !all.contains("SECRETPW") && !all.contains("upstream-secret"));
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
|
||||
@@ -315,6 +315,7 @@ pub fn scan(root: &Path) -> Result<ScanReport> {
|
||||
(None, None)
|
||||
};
|
||||
|
||||
if crate::squid::imported_repack(&root) { notes.push("import.squidRepackWarning".into()); }
|
||||
Ok(ScanReport {
|
||||
path: root.to_string_lossy().into_owned(),
|
||||
classification,
|
||||
|
||||
@@ -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;
|
||||
@@ -46,3 +49,5 @@ pub mod srp6;
|
||||
pub use error::{Error, ErrorCode, Result};
|
||||
|
||||
pub const MANAGER_VERSION: &str = env!("CARGO_PKG_VERSION");
|
||||
|
||||
pub mod squid;
|
||||
@@ -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;")]);
|
||||
|
||||
@@ -87,6 +87,7 @@ fn truthy(v: &str) -> bool {
|
||||
pub struct ModuleView {
|
||||
pub id: String,
|
||||
pub name: String,
|
||||
pub version: Option<String>,
|
||||
pub description: BTreeMap<String, String>,
|
||||
pub repo: String,
|
||||
/// The module's configuration is present on this server (otherwise it is not part of this server build).
|
||||
@@ -137,7 +138,11 @@ fn list_in(cat: &[Entry], root: &Path) -> Vec<ModuleView> {
|
||||
!e.switchable || read(&conf).or_else(|| read(&dist)).and_then(|c| c.get(&e.enable_key).map(truthy)).unwrap_or(e.default_on)
|
||||
};
|
||||
let blocked = wildcard && matches!(e.id.as_str(), "companions" | "playerbots");
|
||||
let version = if e.id == "playerbots" { crate::squid::release(root).map(|release| {
|
||||
[release.tag, release.commit.map(|commit| commit.chars().take(8).collect())].into_iter().flatten().collect::<Vec<_>>().join(" · ")
|
||||
}) } else { None };
|
||||
ModuleView {
|
||||
version,
|
||||
compatibility: if blocked { "unsupported" } else if wildcard && e.id != "client-compat" { "experimental" } else { "compatible" }.into(),
|
||||
id: e.id,
|
||||
name: e.name,
|
||||
@@ -243,13 +248,14 @@ fn set_enabled_in(cat: &[Entry], root: &Path, meta: &Path, id: &str, on: bool) -
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, PartialEq, Eq)]
|
||||
#[derive(Debug, Serialize, PartialEq)]
|
||||
pub struct Setting {
|
||||
pub key: String,
|
||||
pub value: String,
|
||||
pub default: Option<String>,
|
||||
/// The documentation the module ships above the setting.
|
||||
pub doc: String,
|
||||
pub field: Option<crate::squid::Field>,
|
||||
}
|
||||
|
||||
/// Every active setting of the module with its current value, its documented default and its description.
|
||||
@@ -263,6 +269,7 @@ fn settings_in(cat: &[Entry], root: &Path, id: &str) -> Result<Vec<Setting>> {
|
||||
let conf = dir(root).join(&name);
|
||||
let dist = read(&dir(root).join(format!("{name}.dist")));
|
||||
let active = read(&conf).or_else(|| dist.clone()).ok_or_else(|| Error::Invalid("This module is not part of this server.".into()))?;
|
||||
let fields = if id == "playerbots" { crate::squid::fields(root)? } else { Default::default() };
|
||||
let mut effective = active.clone();
|
||||
if let Some(defaults) = &dist {
|
||||
for (key, value) in defaults.entries() {
|
||||
@@ -275,8 +282,9 @@ fn settings_in(cat: &[Entry], root: &Path, id: &str) -> Result<Vec<Setting>> {
|
||||
.entries()
|
||||
.map(|(k, v)| Setting {
|
||||
key: k.to_string(),
|
||||
value: v.to_string(),
|
||||
default: dist.as_ref().and_then(|d| d.get(k)).map(str::to_string),
|
||||
value: fields.get(k).and_then(|field| field.default_if_missing.as_ref()).filter(|_| active.get(k).is_none()).and_then(crate::squid::scalar).unwrap_or_else(|| v.to_string()),
|
||||
default: fields.get(k).and_then(|field| crate::squid::scalar(&field.default)).or_else(|| dist.as_ref().and_then(|d| d.get(k)).map(str::to_string)),
|
||||
field: fields.get(k).cloned(),
|
||||
doc: dist.as_ref().map(|d| d.doc_for(k)).filter(|d| !d.is_empty()).unwrap_or_else(|| active.doc_for(k)).join(" "),
|
||||
})
|
||||
.collect())
|
||||
@@ -293,9 +301,11 @@ fn save_settings_in(cat: &[Entry], root: &Path, meta: &Path, id: &str, changes:
|
||||
let conf = active_file(root, &e)?;
|
||||
let mut file = ConfFile::parse_bytes(&fs::read(&conf)?)?;
|
||||
let dist = read(&dir(root).join(format!("{}.dist", conf_name(root, &e))));
|
||||
let fields = if id == "playerbots" { crate::squid::fields(root)? } else { Default::default() };
|
||||
let mut changed = Vec::new();
|
||||
for (key, value) in changes {
|
||||
let value = value.trim();
|
||||
if let Some(field) = fields.get(key) { crate::squid::validate(field, value)?; }
|
||||
if e.switchable && key == &e.enable_key {
|
||||
return Err(Error::Invalid("Use the module switch to turn this module on or off.".into()));
|
||||
}
|
||||
@@ -374,6 +384,27 @@ mod tests {
|
||||
(root, meta)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn squid_missing_keys_use_code_defaults_and_saves_enforce_json_ranges() {
|
||||
let d = tempfile::tempdir().unwrap();
|
||||
let root = d.path();
|
||||
fs::create_dir_all(dir(root)).unwrap();
|
||||
fs::write(dir(root).join("playerbots.conf"), "AiPlayerbot.Enabled = 0\n").unwrap();
|
||||
fs::write(dir(root).join("playerbots.conf.dist"), "AiPlayerbot.Enabled = 0\nAiPlayerbot.MinRandomBots = 500\n").unwrap();
|
||||
fs::write(dir(root).join("playerbots.conf.settings.json"), r#"{"format":1,"groups":{"population":"Population"},"settings":[{"key":"AiPlayerbot.MinRandomBots","type":"int","group":"population","title":"Minimum bots","description":"Lower bound","default":500,"default_if_missing":50,"min":0,"max":5000}]}"#).unwrap();
|
||||
let cat = catalog();
|
||||
let options = settings_in(&cat, root, "playerbots").unwrap();
|
||||
let option = options.iter().find(|setting| setting.key == "AiPlayerbot.MinRandomBots").unwrap();
|
||||
assert_eq!(option.value, "50");
|
||||
assert_eq!(option.default.as_deref(), Some("500"));
|
||||
assert_eq!(option.field.as_ref().unwrap().group_title.as_deref(), Some("Population"));
|
||||
let before = fs::read(dir(root).join("playerbots.conf")).unwrap();
|
||||
assert!(save_settings_in(&cat, root, root, "playerbots", &BTreeMap::from([("AiPlayerbot.MinRandomBots".into(), "5001".into())])).is_err());
|
||||
assert_eq!(fs::read(dir(root).join("playerbots.conf")).unwrap(), before);
|
||||
save_settings_in(&cat, root, root, "playerbots", &BTreeMap::from([("AiPlayerbot.MinRandomBots".into(), "42".into())])).unwrap();
|
||||
assert_eq!(settings_in(&cat, root, "playerbots").unwrap().iter().find(|setting| setting.key == "AiPlayerbot.MinRandomBots").unwrap().value, "42");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bot_systems_are_mutually_exclusive_in_both_directions_and_manual_configs() {
|
||||
let d = tempfile::tempdir().unwrap();
|
||||
@@ -456,7 +487,7 @@ mod tests {
|
||||
let (root, meta) = server(d.path());
|
||||
let s = settings_in(&test_catalog(), &root, "war-games").unwrap();
|
||||
assert_eq!(s.len(), 2);
|
||||
assert_eq!(s[1], Setting { key: "WarGames.ChallengeSeconds".into(), value: "60".into(), default: Some("60".into()), doc: "How long a challenge stays open.".into() });
|
||||
assert_eq!(s[1], Setting { key: "WarGames.ChallengeSeconds".into(), value: "60".into(), default: Some("60".into()), doc: "How long a challenge stays open.".into(), field: None });
|
||||
assert_eq!(s[0].doc, "Turns War Games on. Second line.");
|
||||
|
||||
let ok = BTreeMap::from([("WarGames.ChallengeSeconds".to_string(), "90".to_string())]);
|
||||
|
||||
@@ -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(())
|
||||
}
|
||||
|
||||
@@ -41,7 +41,7 @@ pub fn excluded(rel: &str) -> bool {
|
||||
|| l == "mysql/my.ini"
|
||||
|| l == "mysql/mysql.pid"
|
||||
|| l == "mysql/data.7z"
|
||||
|| l.starts_with("core/configs/") && !l.ends_with(".dist") // generated at first start from Settings templates
|
||||
|| l.starts_with("core/configs/") && !l.ends_with(".dist") && l != "core/configs/modules/playerbots.conf.settings.json" // generated at first start from Settings templates
|
||||
|| name.ends_with(".pdb")
|
||||
|| name.ends_with(".bak")
|
||||
|| name.ends_with(".log")
|
||||
@@ -56,7 +56,7 @@ fn policy_for(rel: &str) -> (Owner, ReplacePolicy) {
|
||||
let l = rel.to_lowercase();
|
||||
if l.starts_with("_migrations/") {
|
||||
(Owner::Core, ReplacePolicy::NeverTouch) // staged for the migration runner, never copied into the server
|
||||
} else if l.ends_with(".dist") {
|
||||
} else if l.ends_with(".dist") || l == "core/configs/modules/playerbots.conf.settings.json" {
|
||||
(Owner::Core, ReplacePolicy::Replace)
|
||||
} else if l.starts_with("mysql/data/") {
|
||||
(Owner::User, ReplacePolicy::NeverTouch)
|
||||
@@ -370,6 +370,20 @@ mod tests {
|
||||
v
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn upstream_settings_metadata_ships_and_updates_but_active_configs_stay_private() {
|
||||
let d = tempfile::tempdir().unwrap();
|
||||
let src = d.path().join("src");
|
||||
fs::create_dir_all(src.join("Core/configs/modules")).unwrap();
|
||||
fs::write(src.join("Core/configs/modules/playerbots.conf.settings.json"), "{}\n").unwrap();
|
||||
fs::write(src.join("Core/configs/modules/playerbots.conf"), "PlayerbotsDatabaseInfo = private\n").unwrap();
|
||||
let out = d.path().join("package");
|
||||
let manifest = build(&src, &out, &BuildOptions { kind: Kind::Update, version: "1.0.0".into(), core_commit: None, built_at: "test".into(), part_size: 1 << 20, bots_commit: None, migrations: vec![] }, &|_| {}).unwrap();
|
||||
assert_eq!(manifest.files.len(), 1);
|
||||
assert_eq!(manifest.files[0].path, "Core/configs/modules/playerbots.conf.settings.json");
|
||||
assert_eq!(manifest.files[0].policy, ReplacePolicy::Replace);
|
||||
}
|
||||
|
||||
fn source() -> (tempfile::TempDir, PathBuf) {
|
||||
let d = tempfile::tempdir().unwrap();
|
||||
let src = d.path().join("src");
|
||||
|
||||
@@ -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)?)?;
|
||||
|
||||
@@ -0,0 +1,155 @@
|
||||
use std::path::Path;
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
#[derive(Debug, Serialize, PartialEq, Eq)]
|
||||
pub struct Release {
|
||||
pub tag: Option<String>,
|
||||
pub commit: Option<String>,
|
||||
}
|
||||
|
||||
pub fn imported_repack(root: &Path) -> bool {
|
||||
root.join("CoA-Bots/release.json").is_file()
|
||||
}
|
||||
|
||||
pub fn release(root: &Path) -> Option<Release> {
|
||||
for name in ["Extras/SquidPlayerbots/release.json", "Core/configs/modules/playerbots.conf.settings.json", "CoA-Bots/release.json"] {
|
||||
let Ok(bytes) = std::fs::read(root.join(name)) else { continue; };
|
||||
if bytes.len() > 1024 * 1024 { continue; }
|
||||
let Ok(json) = serde_json::from_slice::<serde_json::Value>(&bytes) else { continue; };
|
||||
let safe = |key: &str| json.get(key).and_then(|value| value.as_str())
|
||||
.filter(|value| !value.is_empty() && value.len() <= 80 && value.chars().all(|c| c.is_ascii_alphanumeric() || "._-".contains(c))).map(str::to_owned);
|
||||
let tag = safe("tag").or_else(|| safe("version"));
|
||||
let revision = if name == "CoA-Bots/release.json" {
|
||||
json.get("botsModuleRevision").and_then(|value| value.as_str()).and_then(|value| value.split_whitespace().next()).map(str::to_owned).or_else(|| safe("commit"))
|
||||
} else if name.ends_with(".settings.json") { None } else { safe("commit") };
|
||||
let commit = revision.filter(|value| value.len() >= 7 && value.len() <= 40 && value.chars().all(|c| c.is_ascii_hexdigit()));
|
||||
if tag.is_some() || commit.is_some() { return Some(Release { tag, commit }); }
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
|
||||
pub struct Field {
|
||||
pub key: String,
|
||||
#[serde(rename = "type")]
|
||||
pub kind: String,
|
||||
pub title: String,
|
||||
pub description: String,
|
||||
#[serde(default)]
|
||||
pub group: String,
|
||||
#[serde(default)]
|
||||
pub group_title: Option<String>,
|
||||
pub default: serde_json::Value,
|
||||
#[serde(default)]
|
||||
pub default_if_missing: Option<serde_json::Value>,
|
||||
pub min: Option<f64>,
|
||||
pub max: Option<f64>,
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
struct Settings {
|
||||
format: u32,
|
||||
settings: Vec<serde_json::Value>,
|
||||
#[serde(default)]
|
||||
groups: std::collections::BTreeMap<String, String>,
|
||||
}
|
||||
|
||||
pub fn fields(root: &Path) -> crate::Result<std::collections::BTreeMap<String, Field>> {
|
||||
let path = root.join("Core/configs/modules/playerbots.conf.settings.json");
|
||||
if !path.is_file() { return Ok(Default::default()); }
|
||||
let Ok(bytes) = std::fs::read(path) else { return Ok(Default::default()); };
|
||||
if bytes.len() > 1024 * 1024 { return Ok(Default::default()); }
|
||||
let Ok(settings) = serde_json::from_slice::<Settings>(&bytes) else { return Ok(Default::default()); };
|
||||
if settings.format != 1 { return Ok(Default::default()); }
|
||||
let mut fields = std::collections::BTreeMap::new();
|
||||
for value in settings.settings {
|
||||
let Ok(mut field) = serde_json::from_value::<Field>(value) else { continue; };
|
||||
field.group_title = settings.groups.get(&field.group).cloned();
|
||||
if !matches!(field.kind.as_str(), "bool" | "int" | "float" | "string")
|
||||
|| field.key.len() > 200 || field.key.is_empty()
|
||||
|| !field.key.chars().all(|c| c.is_ascii_alphanumeric() || "._".contains(c))
|
||||
|| field.min.zip(field.max).is_some_and(|(min,max)| min > max)
|
||||
|| !default_type(&field.kind, &field.default)
|
||||
|| field.default_if_missing.as_ref().is_some_and(|value| !default_type(&field.kind, value))
|
||||
|| fields.contains_key(&field.key) { continue; }
|
||||
fields.insert(field.key.clone(), field);
|
||||
}
|
||||
Ok(fields)
|
||||
}
|
||||
|
||||
fn default_type(kind: &str, value: &serde_json::Value) -> bool {
|
||||
match kind {
|
||||
"bool" => value.is_boolean(),
|
||||
"int" => value.is_i64() || value.is_u64(),
|
||||
"float" => value.is_number(),
|
||||
"string" => value.is_string(),
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn scalar(value: &serde_json::Value) -> Option<String> {
|
||||
match value {
|
||||
serde_json::Value::Bool(value) => Some(if *value { "1" } else { "0" }.into()),
|
||||
serde_json::Value::String(value) => Some(value.clone()),
|
||||
serde_json::Value::Number(value) => Some(value.to_string()),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn validate(field: &Field, value: &str) -> crate::Result<()> {
|
||||
let valid = match field.kind.as_str() {
|
||||
"bool" => matches!(value, "0" | "1"),
|
||||
"int" | "float" => value.parse::<f64>().is_ok_and(|number| number.is_finite()
|
||||
&& (field.kind != "int" || number.fract() == 0.0)
|
||||
&& field.min.is_none_or(|min| number >= min) && field.max.is_none_or(|max| number <= max)),
|
||||
"string" => true,
|
||||
_ => false,
|
||||
};
|
||||
if valid { Ok(()) } else { Err(crate::Error::Invalid(format!("{} must match its documented SquidBots type and range.", field.key))) }
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn upstream_settings_preserve_types_ranges_and_distinct_defaults() {
|
||||
let root = tempfile::tempdir().unwrap();
|
||||
crate::fsx::atomic_write(&root.path().join("Core/configs/modules/playerbots.conf.settings.json"), br#"{"format":1,"settings":[{"key":"AiPlayerbot.MinRandomBots","type":"int","group":"population","title":"Minimum bots","description":"Lower bound","default":500,"default_if_missing":50,"min":0,"max":5000}]}"#).unwrap();
|
||||
let fields = fields(root.path()).unwrap();
|
||||
let field = &fields["AiPlayerbot.MinRandomBots"];
|
||||
assert_eq!(scalar(&field.default).as_deref(), Some("500"));
|
||||
assert_eq!(scalar(field.default_if_missing.as_ref().unwrap()).as_deref(), Some("50"));
|
||||
assert!(validate(field, "5000").is_ok());
|
||||
for value in ["5001", "-1", "0.5", "NaN"] { assert!(validate(field, value).is_err()); }
|
||||
}
|
||||
#[test]
|
||||
fn unsupported_metadata_falls_back_and_bad_entries_do_not_hide_valid_fields() {
|
||||
let root = tempfile::tempdir().unwrap();
|
||||
let path = root.path().join("Core/configs/modules/playerbots.conf.settings.json");
|
||||
for data in [r#"{"format":99,"settings":[]}"#, "invalid json", r#"{"format":1,"settings":{}}"#] {
|
||||
crate::fsx::atomic_write(&path, data.as_bytes()).unwrap();
|
||||
assert!(fields(root.path()).unwrap().is_empty());
|
||||
}
|
||||
crate::fsx::atomic_write(&path, br#"{"format":1,"settings":[{"key":"Broken","type":"enum","title":"Broken","description":"Unknown type","default":1},{"key":"Malformed"},{"key":"WrongDefault","type":"int","title":"Wrong","description":"Bad default","default":"oops"},{"key":"Good","type":"bool","title":"Good","description":"Good field","default":true}]}"#).unwrap();
|
||||
let parsed = fields(root.path()).unwrap();
|
||||
assert_eq!(parsed.len(), 1);
|
||||
assert!(parsed.contains_key("Good"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn imported_revision_uses_its_first_word_and_empty_tags_are_hidden() {
|
||||
let root = tempfile::tempdir().unwrap();
|
||||
crate::fsx::atomic_write(&root.path().join("CoA-Bots/release.json"), br#"{"tag":"","botsModuleRevision":"48c4786a 2026-10-01 (coa branch)","commit":"abcdef01"}"#).unwrap();
|
||||
assert_eq!(release(root.path()).unwrap(), Release { tag: None, commit: Some("48c4786a".into()) });
|
||||
crate::fsx::atomic_write(&root.path().join("Core/configs/modules/playerbots.conf.settings.json"), br#"{"tag":"v1.8.1","commit":"11111111"}"#).unwrap();
|
||||
assert_eq!(release(root.path()).unwrap(), Release { tag: Some("v1.8.1".into()), commit: None });
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn diagnostics_only_expose_release_identifiers() {
|
||||
let root = tempfile::tempdir().unwrap();
|
||||
crate::fsx::atomic_write(&root.path().join("CoA-Bots/release.json"), br#"{"tag":"v1.8","commit":"48c4786a","password":"secret"}"#).unwrap();
|
||||
assert!(imported_repack(root.path()));
|
||||
assert_eq!(release(root.path()).unwrap(), Release { tag: Some("v1.8".into()), commit: Some("48c4786a".into()) });
|
||||
}
|
||||
}
|
||||
+826
-122
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."}]};
|
||||
|
||||
@@ -75,6 +75,7 @@ const de: Partial<Record<keyof typeof en, string>> = {
|
||||
"btn.restart": "Neustart",
|
||||
"btn.startWithoutUpdate": "Ohne Update starten",
|
||||
"btn.playWithoutUpdate": "Ohne Update spielen",
|
||||
"import.squidRepackWarning": "Dieses SquidBots-Repack prüft den Worldserver-Hash. Ein Austausch kann Start_All_Bots und coa_update deaktivieren. Updates fragen vorher nach.",
|
||||
"btn.play": "SPIELEN",
|
||||
"btn.startPlay": "STARTEN & SPIELEN",
|
||||
"btn.startingCaps": "STARTET …",
|
||||
@@ -370,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",
|
||||
|
||||
@@ -106,6 +106,7 @@ const en = {
|
||||
"btn.restart": "Restart",
|
||||
"btn.startWithoutUpdate": "Start without updating",
|
||||
"btn.playWithoutUpdate": "Play without updating",
|
||||
"import.squidRepackWarning": "This SquidBots repack checks its worldserver hash. Replacing the binary can stop Start_All_Bots and coa_update from working. Updates will ask before replacing it.",
|
||||
"btn.play": "PLAY",
|
||||
"btn.startPlay": "START & PLAY",
|
||||
"btn.startingCaps": "STARTING…",
|
||||
@@ -403,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",
|
||||
|
||||
@@ -75,6 +75,7 @@ const es: Partial<Record<keyof typeof en, string>> = {
|
||||
"btn.restart": "Reiniciar",
|
||||
"btn.startWithoutUpdate": "Iniciar sin actualizar",
|
||||
"btn.playWithoutUpdate": "Jugar sin actualizar",
|
||||
"import.squidRepackWarning": "Este repack SquidBots verifica el hash del servidor. Sustituirlo puede impedir el funcionamiento de Start_All_Bots y coa_update. Se solicitará confirmación.",
|
||||
"btn.play": "JUGAR",
|
||||
"btn.startPlay": "INICIAR Y JUGAR",
|
||||
"btn.startingCaps": "INICIANDO…",
|
||||
@@ -370,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",
|
||||
|
||||
@@ -75,6 +75,7 @@ const fr: Partial<Record<keyof typeof en, string>> = {
|
||||
"btn.restart": "Redémarrer",
|
||||
"btn.startWithoutUpdate": "Démarrer sans mise à jour",
|
||||
"btn.playWithoutUpdate": "Jouer sans mise à jour",
|
||||
"import.squidRepackWarning": "Ce repack SquidBots vérifie le hash du serveur. Le remplacer peut empêcher Start_All_Bots et coa_update de fonctionner. Une confirmation sera demandée.",
|
||||
"btn.play": "JOUER",
|
||||
"btn.startPlay": "DÉMARRER ET JOUER",
|
||||
"btn.startingCaps": "DÉMARRAGE…",
|
||||
@@ -370,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",
|
||||
|
||||
@@ -106,6 +106,7 @@ const ru: Partial<Record<keyof typeof en, string>> = {
|
||||
"btn.restart": "Перезапустить",
|
||||
"btn.startWithoutUpdate": "Запустить без обновления",
|
||||
"btn.playWithoutUpdate": "Играть без обновления",
|
||||
"import.squidRepackWarning": "Этот репак SquidBots проверяет хеш worldserver. Замена файла может нарушить работу Start_All_Bots и coa_update. Перед заменой менеджер запросит ваше решение.",
|
||||
"btn.play": "ИГРАТЬ",
|
||||
"btn.startPlay": "ЗАПУСТИТЬ И ИГРАТЬ",
|
||||
"btn.startingCaps": "ЗАПУСК…",
|
||||
@@ -401,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": "Проверить обновления",
|
||||
|
||||
@@ -87,6 +87,7 @@ const zh = {
|
||||
"btn.restart": "重启",
|
||||
"btn.startWithoutUpdate": "不更新启动服务器",
|
||||
"btn.playWithoutUpdate": "不更新开始游戏",
|
||||
"import.squidRepackWarning": "此 SquidBots 整合包会检查 worldserver 哈希。替换程序可能导致 Start_All_Bots 和 coa_update 无法运行。更新前会要求您选择。",
|
||||
"btn.play": "开始游戏",
|
||||
"btn.startPlay": "启动并开始游戏",
|
||||
"btn.startingCaps": "正在启动…",
|
||||
@@ -382,6 +383,7 @@ const zh = {
|
||||
"upd.backNote": "回滚将恢复文件和设置。如果数据库更新已开始,所有数据库也将从更新前的备份恢复。之后的进度将丢失。",
|
||||
"upd.goBackTo": "回滚至版本 {v}",
|
||||
"upd.goBackBefore": "回滚至更新前的版本",
|
||||
"upd.autoRestored": "更新验证失败。之前的服务器已自动恢复。",
|
||||
"upd.title": "服务器更新",
|
||||
"upd.text": "更新均经过真实性签名校验,并在执行前自动备份,随时可安全撤销。",
|
||||
"upd.check": "检查更新",
|
||||
|
||||
+19
-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;
|
||||
@@ -193,6 +199,7 @@ export interface RealmProfile {
|
||||
export interface ModuleView {
|
||||
id: string;
|
||||
name: string;
|
||||
version?: string | null;
|
||||
description: Record<string, string>;
|
||||
repo: string;
|
||||
/** the module is part of this server build (its configuration exists) */
|
||||
@@ -216,6 +223,7 @@ export interface ModuleSetting {
|
||||
value: string;
|
||||
default: string | null;
|
||||
doc: string;
|
||||
field?: { key: string; type: string; title: string; description: string; group: string; group_title?: string | null; min?: number | null; max?: number | null } | null;
|
||||
}
|
||||
|
||||
export interface AllSetting {
|
||||
@@ -273,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 {
|
||||
@@ -427,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 }),
|
||||
|
||||
@@ -173,7 +173,9 @@ for (const [category, categoryNames] of Object.entries(auctionCategories)) {
|
||||
{ min: 0, max: 1000, advanced: true },
|
||||
);
|
||||
}
|
||||
export function moduleField(key: string, locale: Locale): ModuleField | undefined {
|
||||
export function moduleField(key: string, locale: Locale, metadata?: ModuleSetting["field"]): ModuleField | undefined {
|
||||
const translated = locale !== "en" ? fields.find(f => f.key === key) : undefined;
|
||||
if (metadata) return { title: translated ? text(translated.title, locale) : metadata.title, description: translated ? text(translated.description, locale) : metadata.description, type: metadata.type, category: metadata.group, advanced: false, min: metadata.min ?? undefined, max: metadata.max ?? undefined };
|
||||
const field = fields.find(f => f.key === key);
|
||||
if (field) return { ...field, title: text(field.title, locale), description: text(field.description, locale), category: "general", advanced: field.advanced ?? false, step: field.type === "range" ? 0.05 : undefined, options: field.options?.map(o => ({ value: o.value, label: text(o.label, locale) })) };
|
||||
const existing = [...bots.settings, ...server.settings].find(s => s.key === key);
|
||||
|
||||
+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 });
|
||||
|
||||
@@ -24,7 +24,7 @@ function group(key: string, curated: boolean) {
|
||||
/** Use the same settings screen as Companions, backed only by shipped SQUID options. */
|
||||
export function squidSettingsView(items: ModuleSetting[], locale: Locale): SettingsView {
|
||||
const settings: SettingView[] = items.filter(s => s.key !== "AiPlayerbot.Enabled" && !s.key.startsWith("PlayerbotsDatabase") && !s.key.startsWith("Playerbots.Updates.")).map(s => {
|
||||
const field = moduleField(s.key, locale);
|
||||
const field = moduleField(s.key, locale, s.field);
|
||||
const type = field?.type === "bool" || field?.type === "int" || field?.type === "float" || field?.type === "enum" ? field.type : "string";
|
||||
const decode = (raw: string): JsonValue => {
|
||||
const value = raw.trim().replace(/^"|"$/g, "");
|
||||
@@ -35,11 +35,13 @@ export function squidSettingsView(items: ModuleSetting[], locale: Locale): Setti
|
||||
const value = decode(s.value), defaultValue = decode(s.default ?? s.value);
|
||||
return {
|
||||
key: s.key, type, title: field?.title ?? s.key, description: field?.description ?? s.doc,
|
||||
category: group(s.key, !!field), advanced: !field || !!field.advanced,
|
||||
category: s.field?.group ? "squid." + s.field.group : group(s.key, !!field), advanced: !field || !!field.advanced,
|
||||
min: field?.min, max: field?.max, options: field?.options ?? [],
|
||||
value, default: defaultValue, is_default: value === defaultValue, present: true, problem: null,
|
||||
drift: false, restartRequired: "world", dangerous: false,
|
||||
};
|
||||
});
|
||||
return { scope: "bots", categories: groups.map(g => ({ id: g.id, title: g.titles[languages.indexOf(locale)] })), settings, unknown_keys: 0, drift_keys: [], files: ["Core/configs/modules/playerbots.conf"] };
|
||||
const categories = new Map(groups.map(g => [g.id, g.titles[languages.indexOf(locale)]]));
|
||||
for (const item of items) if (item.field?.group) categories.set("squid." + item.field.group, categories.get("squid." + item.field.group) ?? item.field.group_title ?? item.field.group);
|
||||
return { scope: "bots", categories: [...categories].map(([id, title]) => ({ id, title })), settings, unknown_keys: 0, drift_keys: [], files: ["Core/configs/modules/playerbots.conf"] };
|
||||
}
|
||||
@@ -145,7 +145,7 @@ export function ImportServer(props: {
|
||||
|
||||
{report.notes.map((n) => (
|
||||
<p key={n} className="mt-3 text-sm text-warn">
|
||||
{n}
|
||||
{hasKey(n) ? t(n as Key) : n}
|
||||
</p>
|
||||
))}
|
||||
|
||||
|
||||
@@ -133,6 +133,7 @@ export function ModulesPage({ serverId, onChanged }: { serverId: string; onChang
|
||||
<div className="min-w-0 flex-1">
|
||||
<div className="flex flex-wrap items-center gap-x-2 gap-y-1">
|
||||
<h2 className="font-semibold leading-tight">{m.name}</h2>
|
||||
{m.version && <span className="ml-2 text-xs font-normal text-muted">{m.version}</span>}
|
||||
<StatusBadge status={m.status} />
|
||||
</div>
|
||||
<p className="mt-1.5 line-clamp-2 text-sm text-muted">{m.description[locale] ?? m.description.en}</p>
|
||||
@@ -210,7 +211,7 @@ function ModuleSettings({ serverId, module, onSaved }: { serverId: string; modul
|
||||
async function save() {
|
||||
const errors: Record<string, string> = {};
|
||||
for (const [key, value] of Object.entries(edits)) {
|
||||
const field = moduleField(key, locale);
|
||||
const field = moduleField(key, locale, items?.find(item => item.key === key)?.field);
|
||||
if (field && ["int", "float", "range"].includes(field.type)) {
|
||||
const number = Number(value);
|
||||
const message = !value.trim() || !Number.isFinite(number) ? t("set.enterNumber")
|
||||
@@ -248,13 +249,13 @@ function ModuleSettings({ serverId, module, onSaved }: { serverId: string; modul
|
||||
return next;
|
||||
});
|
||||
const available = items?.filter(s => s.key !== moduleEnableKey(module.id)) ?? [];
|
||||
const advancedCount = available.filter(s => !auctionWeightKey(s.key) && (!moduleField(s.key, locale) || moduleField(s.key, locale)?.advanced)).length;
|
||||
const advancedCount = available.filter(s => !auctionWeightKey(s.key) && (!moduleField(s.key, locale, s.field) || moduleField(s.key, locale, s.field)?.advanced)).length;
|
||||
const visible = available.filter(s => {
|
||||
if (module.id === "ah-bot" && auctionWeightKey(s.key)) return false;
|
||||
const field = moduleField(s.key, locale);
|
||||
const field = moduleField(s.key, locale, s.field);
|
||||
if (!advanced && !query.trim() && (!field || field.advanced)) return false;
|
||||
const title = field ? sx.title({ key: s.key, title: field.title }) : s.key;
|
||||
const description = field ? sx.description({ key: s.key, description: field.description }) : s.doc;
|
||||
const title = field ? (s.field ? field.title : sx.title({ key: s.key, title: field.title })) : s.key;
|
||||
const description = field ? (s.field ? field.description : sx.description({ key: s.key, description: field.description })) : s.doc;
|
||||
return `${title} ${description} ${s.key}`.toLocaleLowerCase(locale).includes(query.trim().toLocaleLowerCase(locale));
|
||||
});
|
||||
return (
|
||||
@@ -278,9 +279,9 @@ function ModuleSettings({ serverId, module, onSaved }: { serverId: string; modul
|
||||
{items && !visible.length && !available.some(s => module.id === "ah-bot" && auctionWeightKey(s.key)) && <p className="py-3 text-sm text-muted">{t(available.length ? "all.none" : "mod.noSettings")}</p>}
|
||||
<ul className="divide-y divide-line">
|
||||
{visible.map((s) => {
|
||||
const field = moduleField(s.key, locale);
|
||||
const title = field ? sx.title({ key: s.key, title: field.title }) : s.key;
|
||||
const description = field ? sx.description({ key: s.key, description: field.description }) : s.doc;
|
||||
const field = moduleField(s.key, locale, s.field);
|
||||
const title = field ? (s.field ? field.title : sx.title({ key: s.key, title: field.title })) : s.key;
|
||||
const description = field ? (s.field ? field.description : sx.description({ key: s.key, description: field.description })) : s.doc;
|
||||
const value = edits[s.key] ?? s.value;
|
||||
const normalized = canonicalModuleValue(s.key, value);
|
||||
const options = field?.options ?? [];
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -178,12 +178,15 @@ export function SettingsPage(props: { serverId: string; scope: Scope; botModule?
|
||||
const [raw, setRaw] = useState<AllSetting[] | null>(null);
|
||||
const [rawEdits, setRawEdits] = useState<Record<string, string>>({});
|
||||
const [onlyChanged, setOnlyChanged] = useState(false);
|
||||
const [squidVersion, setSquidVersion] = useState<string | null>(null);
|
||||
const [cols, setCols] = useState<ModuleSetting[]>([]);
|
||||
const [colEdits, setColEdits] = useState<Record<string, string>>({});
|
||||
|
||||
const load = useCallback(async () => {
|
||||
try {
|
||||
const v = squid ? squidSettingsView(await api.moduleSettings(serverId, "playerbots"), locale) : await api.settings(serverId, scope);
|
||||
const data = squid ? await Promise.all([api.moduleSettings(serverId, "playerbots"), api.modulesList(serverId)]) : null;
|
||||
if (data) setSquidVersion(data[1].find(module => module.id === "playerbots")?.version ?? null);
|
||||
const v = data ? squidSettingsView(data[0], locale) : await api.settings(serverId, scope);
|
||||
setView(v);
|
||||
setDraft({});
|
||||
setErrors({});
|
||||
@@ -363,7 +366,7 @@ export function SettingsPage(props: { serverId: string; scope: Scope; botModule?
|
||||
return (
|
||||
<div className="max-w-3xl pb-24">
|
||||
<h1 className="text-2xl font-semibold">{props.title}</h1>
|
||||
<p className="mt-1 text-muted">{squid ? "SQUID’s Playerbots" : props.question}</p>
|
||||
<p className="mt-1 text-muted">{squid ? `SQUID’s Playerbots${squidVersion ? " · " + squidVersion : ""}` : props.question}</p>
|
||||
|
||||
{scope === "bots" && !squid && <CompanionsCard serverId={serverId} />}
|
||||
|
||||
|
||||
@@ -67,3 +67,15 @@ for (const locale of ["en", "ru", "de", "fr", "es", "zh"]) {
|
||||
if (view.categories.some(c => !c.title)) throw new Error("SQUID categories must be translated");
|
||||
}
|
||||
console.log("SQUID Bots view: typed values, upstream defaults, categories and hidden managed settings verified");
|
||||
|
||||
const upstream = squidSettingsView([{ key: "AiPlayerbot.FutureOption", value: "2.5", default: "1", doc: "old description", field: {key:"AiPlayerbot.FutureOption",type:"float",title:"Future option",description:"From the release JSON",group:"new-group",group_title:"New activity",min:0,max:3} }], "ru");
|
||||
const future = upstream.settings[0];
|
||||
if (future.title !== "Future option" || future.description !== "From the release JSON" || future.type !== "float" || future.min !== 0 || future.max !== 3 || future.advanced || future.category !== "squid.new-group" || upstream.categories.find(c=>c.id===future.category)?.title !== "New activity") throw new Error("New upstream JSON options must appear without handwritten definitions");
|
||||
console.log("Upstream metadata: new fields, titles, ranges and arbitrary groups verified");
|
||||
|
||||
const localized = moduleField("AiPlayerbot.MaxRandomBots", "ru", { key:"AiPlayerbot.MaxRandomBots", type:"int", title:"Upstream English title", description:"Upstream English description", group:"population", min:10, max:1234 });
|
||||
const original = moduleField("AiPlayerbot.MaxRandomBots", "ru");
|
||||
if (localized.title !== original.title || localized.description !== original.description || localized.max !== 1234) throw new Error("Existing translations must survive upstream metadata while ranges stay current");
|
||||
const localizedGroup = squidSettingsView([{key:"AiPlayerbot.MaxRandomBots",value:"100",default:"500",doc:"",field:{key:"AiPlayerbot.MaxRandomBots",type:"int",title:"English",description:"English",group:"population",group_title:"English population"}}],"ru");
|
||||
if (localizedGroup.categories.find(c=>c.id==="squid.population")?.title !== "Население мира") throw new Error("Known groups must retain translated captions");
|
||||
console.log("Existing setting/group translations retained with upstream English fallback");
|
||||
@@ -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