feat(phase15): release and security hardening, DPAPI key store, probe & protocol hardening, secret redaction, audit and readiness report

This commit is contained in:
Дмитрий committed 2026-10-09 21:59:44 +05:00
1 parent b69fa6b867
commit 51e0f136d6
207 files changed
+38235 -7770

No files matched your search

+54 -10
View File
@@ -3,15 +3,37 @@ use coa_core::backup::{self, Kind, Trigger};
use std::path::Path;
fn main() {
let root = std::env::args().nth(1).expect("usage: backup_e2e <fixture folder>");
assert!(root.to_lowercase().contains("fixture"), "refusing: not a fixture folder");
let root = std::env::args()
.nth(1)
.expect("usage: backup_e2e <fixture folder>");
assert!(
root.to_lowercase().contains("fixture"),
"refusing: not a fixture folder"
);
let root = Path::new(&root);
let meta = coa_core::registry::metadata_dir_for(root).unwrap();
std::fs::create_dir_all(&meta).unwrap();
let t = std::time::Instant::now();
let point = backup::create(root, &meta, Kind::Quick, Trigger::Manual, Some("e2e".into()), &|s| println!(" .. {s}")).expect("backup");
println!("quick backup {} in {:?}: {:?}", point.id, t.elapsed(), point.components.iter().map(|c| (&c.name, c.bytes, c.tables)).collect::<Vec<_>>());
let point = backup::create(
root,
&meta,
Kind::Quick,
Trigger::Manual,
Some("e2e".into()),
&|s| println!(" .. {s}"),
)
.expect("backup");
println!(
"quick backup {} in {:?}: {:?}",
point.id,
t.elapsed(),
point
.components
.iter()
.map(|c| (&c.name, c.bytes, c.tables))
.collect::<Vec<_>>()
);
assert!(backup::verify(&meta, &point.id).unwrap().ok);
// Change live state after the backup.
@@ -23,22 +45,44 @@ fn main() {
.unwrap();
let r = backup::restore_database(root, &meta, &point.id, "characters").expect("restore");
println!("restored {} tables; previous database kept as {}; safety backup {}", r.tables_restored, r.previous_schema, r.safety_backup);
println!(
"restored {} tables; previous database kept as {}; safety backup {}",
r.tables_restored, r.previous_schema, r.safety_backup
);
backup::with_database(root, |db| {
let live = db.tables("acore_characters")?;
assert!(!live.contains(&"manager_marker".to_string()), "marker must be gone from the restored database");
assert!(
!live.contains(&"manager_marker".to_string()),
"marker must be gone from the restored database"
);
let old = db.tables(&r.previous_schema)?;
assert!(old.contains(&"manager_marker".to_string()), "the replaced database keeps the marker");
assert_eq!(db.query(&format!("SELECT id FROM {}.manager_marker;", r.previous_schema))?, "42");
assert!(
old.contains(&"manager_marker".to_string()),
"the replaced database keeps the marker"
);
assert_eq!(
db.query(&format!(
"SELECT id FROM {}.manager_marker;",
r.previous_schema
))?,
"42"
);
assert_eq!(live.len(), r.tables_restored);
println!("OK: live tables {}, old schema tables {}", live.len(), old.len());
println!(
"OK: live tables {}, old schema tables {}",
live.len(),
old.len()
);
Ok(())
})
.unwrap();
// A rejected restore (server "running" is simulated by a damaged backup) must change nothing.
let victim = meta.join("backups").join(&point.id).join("characters.sql.zst");
let victim = meta
.join("backups")
.join(&point.id)
.join("characters.sql.zst");
let mut bytes = std::fs::read(&victim).unwrap();
bytes[10] ^= 0xFF;
std::fs::write(&victim, bytes).unwrap();
+52 -8
View File
@@ -7,25 +7,69 @@ use coa_core::download::{Cancel, HttpTransport};
fn main() {
let full = clientdl::fetch_latest().expect("manifest");
println!("version {} · {} files · {:.1} GB", full.version, full.files.len(), full.total_bytes() as f64 / 1e9);
println!(
"version {} · {} files · {:.1} GB",
full.version,
full.files.len(),
full.total_bytes() as f64 / 1e9
);
let mut small = full.files.clone();
small.sort_by_key(|f| f.size);
let skip: usize = std::env::var("PROBE_SKIP").ok().and_then(|v| v.parse().ok()).unwrap_or(0);
let skip: usize = std::env::var("PROBE_SKIP")
.ok()
.and_then(|v| v.parse().ok())
.unwrap_or(0);
let small: Vec<_> = small.into_iter().skip(skip).take(6).collect();
let manifest = Manifest { version: full.version.clone(), published_at: None, files: small };
let manifest = Manifest {
version: full.version.clone(),
published_at: None,
files: small,
};
let dir = std::env::temp_dir().join(format!("coa-client-probe-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let cancel = Cancel::default();
let plan = clientdl::plan(&dir, &manifest, &Default::default(), &cancel, &|_| {}).unwrap();
println!("plan: {} files, {} bytes", plan.items.len(), plan.download_bytes);
println!(
"plan: {} files, {} bytes",
plan.items.len(),
plan.download_bytes
);
let transport = HttpTransport::new().unwrap();
clientdl::apply(
&Apply { client: &dir, manifest: &manifest, plan: &plan, keep_modified: false, transport: &transport, objects_url: clientdl::OBJECTS_URL, cancel: &cancel },
&|s| println!("{} {}/{} {}", s.phase, s.done, s.total, s.file.unwrap_or_default()),
&Apply {
client: &dir,
manifest: &manifest,
plan: &plan,
keep_modified: false,
transport: &transport,
objects_url: clientdl::OBJECTS_URL,
cancel: &cancel,
},
&|s| {
println!(
"{} {}/{} {}",
s.phase,
s.done,
s.total,
s.file.unwrap_or_default()
)
},
)
.expect("apply");
let again = clientdl::plan(&dir, &manifest, &clientdl::load_state(&dir).unwrap(), &cancel, &|_| {}).unwrap();
println!("second plan: {} to do, {} up to date, version {:?}", again.items.len(), again.up_to_date_files, clientdl::local(&dir).version);
let again = clientdl::plan(
&dir,
&manifest,
&clientdl::load_state(&dir).unwrap(),
&cancel,
&|_| {},
)
.unwrap();
println!(
"second plan: {} to do, {} up to date, version {:?}",
again.items.len(),
again.up_to_date_files,
clientdl::local(&dir).version
);
std::fs::remove_dir_all(&dir).unwrap();
}
+5 -1
View File
@@ -1,4 +1,8 @@
fn main() {
let p = std::env::args().nth(1).expect("client folder");
println!("{}", serde_json::to_string_pretty(&coa_core::client::detect(std::path::Path::new(&p), None)).unwrap());
println!(
"{}",
serde_json::to_string_pretty(&coa_core::client::detect(std::path::Path::new(&p), None))
.unwrap()
);
}
+16 -4
View File
@@ -5,12 +5,24 @@ use coa_core::db::{Account, Db};
fn main() {
let a: Vec<String> = std::env::args().skip(1).collect();
let root = std::path::PathBuf::from(&a[0]);
assert!(a[0].to_lowercase().contains("installtest"), "refusing to touch a server that is not a disposable test install");
assert!(
a[0].to_lowercase().contains("installtest"),
"refusing to touch a server that is not a disposable test install"
);
let count: u32 = a[1].parse().unwrap();
let db = Db::from_repack(&root, Account::Admin).expect("db");
println!("templates before: {}", coa_core::companions::template_count(&db).unwrap());
println!("added: {}", coa_core::companions::ensure_templates(&db).unwrap());
println!("templates after: {}", coa_core::companions::template_count(&db).unwrap());
println!(
"templates before: {}",
coa_core::companions::template_count(&db).unwrap()
);
println!(
"added: {}",
coa_core::companions::ensure_templates(&db).unwrap()
);
println!(
"templates after: {}",
coa_core::companions::template_count(&db).unwrap()
);
let t = std::time::Instant::now();
match coa_core::companions::offline_create(&root, &root.join("companions-e2e.log"), count) {
Ok(tail) => println!("offline create ok in {:?}:\n{tail}", t.elapsed()),
+34 -7
View File
@@ -3,12 +3,16 @@ use coa_core::config::{self, parser::ConfFile, Scope};
use std::path::Path;
fn main() {
let root = std::env::args().nth(1).expect("usage: config_check <server folder>");
let root = std::env::args()
.nth(1)
.expect("usage: config_check <server folder>");
let root = Path::new(&root);
let mut files = 0;
for dir in ["Core/configs", "Core/configs/modules", "Settings"] {
let Ok(rd) = std::fs::read_dir(root.join(dir)) else { continue };
let Ok(rd) = std::fs::read_dir(root.join(dir)) else {
continue;
};
for e in rd.flatten() {
let p = e.path();
let name = p.file_name().unwrap().to_string_lossy().to_lowercase();
@@ -18,7 +22,12 @@ fn main() {
let bytes = std::fs::read(&p).unwrap();
match ConfFile::parse_bytes(&bytes) {
Ok(c) => {
assert_eq!(c.to_text().as_bytes(), &bytes[..], "round-trip mismatch: {}", p.display());
assert_eq!(
c.to_text().as_bytes(),
&bytes[..],
"round-trip mismatch: {}",
p.display()
);
files += 1;
}
Err(e) => println!("skipped {}: {e}", p.display()),
@@ -31,16 +40,34 @@ fn main() {
match config::load(root, scope) {
Ok(v) => {
let present = v.settings.iter().filter(|s| s.present).count();
let problems: Vec<_> = v.settings.iter().filter(|s| s.problem.is_some()).map(|s| (&s.meta.key, s.problem.clone().unwrap())).collect();
let missing: Vec<_> = v.settings.iter().filter(|s| !s.present).map(|s| s.meta.key.as_str()).collect();
let non_default = v.settings.iter().filter(|s| s.present && !s.is_default).count();
let problems: Vec<_> = v
.settings
.iter()
.filter(|s| s.problem.is_some())
.map(|s| (&s.meta.key, s.problem.clone().unwrap()))
.collect();
let missing: Vec<_> = v
.settings
.iter()
.filter(|s| !s.present)
.map(|s| s.meta.key.as_str())
.collect();
let non_default = v
.settings
.iter()
.filter(|s| s.present && !s.is_default)
.count();
println!(
"{scope:?}: {} settings, {present} present, {non_default} non-default, {} unknown keys, drift {:?}\n problems {:?}\n missing {:?}",
v.settings.len(), v.unknown_keys, v.drift_keys, problems, missing
);
for p in scope.presets() {
let pv = config::preview_preset(root, scope, &p.id).unwrap();
println!(" preset {:<14} would change {} settings", p.id, pv.changes.len());
println!(
" preset {:<14} would change {} settings",
p.id,
pv.changes.len()
);
}
}
Err(e) => println!("{scope:?}: {e}"),
+50 -14
View File
@@ -1,5 +1,10 @@
use coa_core::{
manifest::{Kind, Manifest},
package::{self, BuildOptions},
pkgsource::{self, Source},
release, signing, Result,
};
use std::{fs, path::PathBuf};
use coa_core::{manifest::{Kind, Manifest}, package::{self, BuildOptions}, pkgsource::{self, Source}, release, signing, Result};
fn main() -> Result<()> {
let args: Vec<String> = std::env::args().skip(1).collect();
@@ -9,30 +14,61 @@ fn main() -> Result<()> {
if args[0] == "extract" {
assert!(!tree.exists(), "Use a new release tree");
package::extract(&PathBuf::from(&args[1]), &previous, &tree, &|_, _| {})?;
println!("Verified and extracted {}: {} historical migrations", previous.version, previous.migrations.len());
println!(
"Verified and extracted {}: {} historical migrations",
previous.version,
previous.migrations.len()
);
return Ok(());
}
assert_eq!(args[0], "pack");
let out = PathBuf::from(&args[3]);
assert!(!out.exists(), "Release addresses must be immutable");
for migration in &previous.migrations {
let entry = previous.files.iter().find(|file| file.path.starts_with("_migrations/") && file.sha256 == migration.sha256).expect("Historical SQL entry");
assert_eq!(coa_core::fsx::sha256_file(&tree.join(&entry.path))?, entry.sha256, "Historical SQL changed: {}", migration.id);
let entry = previous
.files
.iter()
.find(|file| file.path.starts_with("_migrations/") && file.sha256 == migration.sha256)
.expect("Historical SQL entry");
assert_eq!(
coa_core::fsx::sha256_file(&tree.join(&entry.path))?,
entry.sha256,
"Historical SQL changed: {}",
migration.id
);
}
let mut manifest = package::build(&tree, &out, &BuildOptions {
kind: Kind::Update, version: args[4].clone(), core_commit: Some(args[5].clone()),
bots_commit: previous.bots.and_then(|revision| revision.commit),
built_at: chrono::Utc::now().to_rfc3339(), part_size: package::DEFAULT_PART_SIZE,
migrations: previous.migrations.clone(),
}, &|line| println!("{line}"))?;
let mut manifest = package::build(
&tree,
&out,
&BuildOptions {
kind: Kind::Update,
version: args[4].clone(),
core_commit: Some(args[5].clone()),
bots_commit: previous.bots.and_then(|revision| revision.commit),
built_at: chrono::Utc::now().to_rfc3339(),
part_size: package::DEFAULT_PART_SIZE,
migrations: previous.migrations.clone(),
},
&|line| println!("{line}"),
)?;
manifest.min_manager_version = "0.6.5".into();
manifest.validate()?;
coa_core::fsx::atomic_write(&out.join("manifest.json"), &serde_json::to_vec_pretty(&manifest)?)?;
let key_path = PathBuf::from(std::env::var("USERPROFILE").unwrap()).join(".coa-manager/signing/manifest-signing.key");
coa_core::fsx::atomic_write(
&out.join("manifest.json"),
&serde_json::to_vec_pretty(&manifest)?,
)?;
let key_path = PathBuf::from(std::env::var("USERPROFILE").unwrap())
.join(".coa-manager/signing/manifest-signing.key");
release::sign_manifest(&out, &fs::read_to_string(key_path)?)?;
coa_core::release_schema::verify_package(&out, signing::EMBEDDED_PUBLIC_KEY)?;
let reread: Manifest = serde_json::from_slice(&fs::read(out.join("manifest.json"))?)?;
assert_eq!(serde_json::to_value(reread.migrations)?, serde_json::to_value(previous.migrations)?);
println!("PASS: signed {}; all historical migration bytes, checksums, aliases and order preserved", manifest.version);
assert_eq!(
serde_json::to_value(reread.migrations)?,
serde_json::to_value(previous.migrations)?
);
println!(
"PASS: signed {}; all historical migration bytes, checksums, aliases and order preserved",
manifest.version
);
Ok(())
}
@@ -1,64 +1,131 @@
use std::path::{Path, PathBuf};
use coa_core::{backup, driver, fsx, Result};
use std::path::{Path, PathBuf};
fn set(root: &Path, filename: &str, values: &[(&str, &str)]) -> Result<()> {
let path = root.join("Core/configs/modules").join(filename);
let mut config = coa_core::config::parser::ConfFile::parse_bytes(&std::fs::read(&path)?)?;
for (key, value) in values { config.set(key, value, &[]); }
for (key, value) in values {
config.set(key, value, &[]);
}
fsx::atomic_write(&path, config.to_text().as_bytes())
}
fn ledgers(root: &Path) -> Result<Vec<String>> {
backup::with_database(root, |db| ["acore_playerbots", "acore_world", "acore_characters"].into_iter()
.map(|schema| db.query(&format!("SELECT path,sha256 FROM `{schema}`.coa_squid_migrations ORDER BY path;"))).collect())
backup::with_database(root, |db| {
["acore_playerbots", "acore_world", "acore_characters"]
.into_iter()
.map(|schema| {
db.query(&format!(
"SELECT path,sha256 FROM `{schema}`.coa_squid_migrations ORDER BY path;"
))
})
.collect()
})
}
fn exercise(root: &Path) -> Result<()> {
let meta = coa_core::registry::metadata_dir_for(root)?;
let point = backup::create(root, &meta, backup::Kind::Full, backup::Trigger::Manual, Some("Disposable SQUID acceptance".into()), &|stage| println!("{stage}"))?;
let point = backup::create(
root,
&meta,
backup::Kind::Full,
backup::Trigger::Manual,
Some("Disposable SQUID acceptance".into()),
&|stage| println!("{stage}"),
)?;
assert!(backup::verify(&meta, &point.id)?.ok);
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| -> Result<()> {
backup::with_database(root, |db| db.query("DROP DATABASE IF EXISTS acore_playerbots;").map(|_| ()))?;
assert!(driver::run(root, driver::Verb::StartAll)?.ok, "Disabled SQUID must start without its database");
backup::with_database(root, |db| {
db.query("DROP DATABASE IF EXISTS acore_playerbots;")
.map(|_| ())
})?;
assert!(
driver::run(root, driver::Verb::StartAll)?.ok,
"Disabled SQUID must start without its database"
);
assert!(driver::run(root, driver::Verb::StopAll)?.ok);
coa_core::multiworld::set_enabled(root, false)?;
coa_core::realms::select(root, coa_core::realms::Mode::Coa)?;
set(root, "mod_coa_playerbots.conf", &[("CoaBots.Enable", "0")])?;
set(root, "playerbots.conf", &[("AiPlayerbot.Enabled", "1"), ("AiPlayerbot.RandomBotAutologin", "0"), ("AiPlayerbot.MinRandomBots", "0"), ("AiPlayerbot.MaxRandomBots", "0"), ("AiPlayerbot.RandomBotGuildCount", "0"), ("AiPlayerbot.RandomBotAccountCount", "0")])?;
set(
root,
"playerbots.conf",
&[
("AiPlayerbot.Enabled", "1"),
("AiPlayerbot.RandomBotAutologin", "0"),
("AiPlayerbot.MinRandomBots", "0"),
("AiPlayerbot.MaxRandomBots", "0"),
("AiPlayerbot.RandomBotGuildCount", "0"),
("AiPlayerbot.RandomBotAccountCount", "0"),
],
)?;
let started = driver::run(root, driver::Verb::StartAll)?;
assert!(started.ok, "Fresh SQUID startup: {}", coa_core::diag::redact(&started.output));
assert!(
started.ok,
"Fresh SQUID startup: {}",
coa_core::diag::redact(&started.output)
);
let before = ledgers(root)?;
assert!(!before[0].is_empty(), "Fresh SQUID history missing");
assert!(driver::run(root, driver::Verb::StopAll)?.ok);
let started = driver::run(root, driver::Verb::StartAll)?;
assert!(started.ok, "Repeated SQUID startup: {}", coa_core::diag::redact(&started.output));
assert_eq!(ledgers(root)?, before, "SQUID replay changed its migration history");
assert!(
started.ok,
"Repeated SQUID startup: {}",
coa_core::diag::redact(&started.output)
);
assert_eq!(
ledgers(root)?,
before,
"SQUID replay changed its migration history"
);
println!("PASS: SQUID-disabled dual startup without its database; fresh enabled SQUID import and startup; repeated startup preserves all three histories");
Ok(())
}));
assert!(driver::run(root, driver::Verb::StopAll)?.ok);
restore(root, &meta, &point)?;
result.map_err(|_| coa_core::Error::Invalid("SQUID acceptance failed; disposable databases and configurations restored".into()))?
result.map_err(|_| {
coa_core::Error::Invalid(
"SQUID acceptance failed; disposable databases and configurations restored".into(),
)
})?
}
fn restore(root: &Path, meta: &Path, point: &backup::RecoveryPoint) -> Result<()> {
assert!(backup::verify(meta, &point.id)?.ok);
assert!(driver::run(root, driver::Verb::StopAll)?.ok);
coa_core::realms::select(root, point.realm)?;
for component in point.components.iter().filter(|component| component.name != "configs") {
for component in point
.components
.iter()
.filter(|component| component.name != "configs")
{
backup::restore_database(root, meta, &point.id, &component.name)?;
}
backup::restore_configs(root, meta, &point.id)?;
assert!(driver::run(root, driver::Verb::StopAll)?.ok);
println!("PASS: disposable SQUID acceptance databases and original realm configurations restored");
println!(
"PASS: disposable SQUID acceptance databases and original realm configurations restored"
);
Ok(())
}
fn main() -> Result<()> {
let root = PathBuf::from(std::env::args().nth(1).unwrap());
assert!(root.file_name().unwrap().to_string_lossy().starts_with("coa-schema-fixture-chaos-064-transition-"));
assert_eq!(std::fs::read(root.join(".transition-fixture"))?, b"disposable published-064 transition fixture");
assert!(!root.join("Data").symlink_metadata()?.file_type().is_symlink());
assert!(root
.file_name()
.unwrap()
.to_string_lossy()
.starts_with("coa-schema-fixture-chaos-064-transition-"));
assert_eq!(
std::fs::read(root.join(".transition-fixture"))?,
b"disposable published-064 transition fixture"
);
assert!(!root
.join("Data")
.symlink_metadata()?
.file_type()
.is_symlink());
assert!(driver::run(&root, driver::Verb::StopAll)?.ok);
if let Some(id) = std::env::args().nth(2) {
let meta = coa_core::registry::metadata_dir_for(&root)?;
@@ -1,5 +1,10 @@
use coa_core::{
backup, driver,
registry::MetaDir,
update::{self, RepackEnv},
Result,
};
use std::{collections::BTreeMap, path::PathBuf};
use coa_core::{backup, driver, registry::MetaDir, update::{self, RepackEnv}, Result};
fn players(db: &coa_core::db::Db) -> Result<String> {
db.query("SELECT CONCAT(id,':',username,':',HEX(salt),':',HEX(verifier)) FROM acore_auth.account WHERE id=900001; SELECT CONCAT(guid,':',account,':',name,':',level,':',money) FROM acore_characters.characters WHERE guid=900001; SELECT CONCAT(guid,':',itemEntry,':',owner_guid,':',enchantments) FROM acore_characters.item_instance WHERE guid=900001; SELECT CONCAT(guid,':',bag,':',slot,':',item) FROM acore_characters.character_inventory WHERE guid=900001;")
@@ -8,22 +13,73 @@ fn players(db: &coa_core::db::Db) -> Result<String> {
fn exercise(root: &std::path::Path, package: &str) -> Result<()> {
let meta_dir = coa_core::registry::metadata_dir_for(root)?;
let (_, meta) = MetaDir::open(&meta_dir)?;
let expected = backup::with_database(root, |db| [coa_core::realms::Mode::Coa, coa_core::realms::Mode::Wildcard].into_iter().map(|mode| players(&db.clone().for_realm(mode))).collect::<Result<Vec<_>>>())?;
let expected = backup::with_database(root, |db| {
[
coa_core::realms::Mode::Coa,
coa_core::realms::Mode::Wildcard,
]
.into_iter()
.map(|mode| players(&db.clone().for_realm(mode)))
.collect::<Result<Vec<_>>>()
})?;
assert!(driver::run(root, driver::Verb::StopAll)?.ok);
let source = coa_core::pkgsource::Source::Dir(package.into());
let preview = update::preview(root, &meta, &source, coa_core::signing::EMBEDDED_PUBLIC_KEY, &BTreeMap::new())?;
assert_eq!(preview.pending_migrations, 0, "Historical SQL must not replay");
assert!(!preview.items.iter().any(|item| item.action == update::Action::Conflict), "Unresolved candidate files: {:?}", preview.items);
let environment = RepackEnv { root, meta_dir: &meta_dir };
let outcome = update::apply(&update::Params {
root, meta_dir: &meta_dir, source, trusted_key: coa_core::signing::EMBEDDED_PUBLIC_KEY,
resolutions: BTreeMap::new(), cancel: Default::default(), env: &environment, fail_after_ops: None,
}, &|stage, progress| println!("{progress}% {stage}"))?;
assert_eq!(outcome.txn.state, update::State::Committed, "{:?}", outcome.txn);
let preview = update::preview(
root,
&meta,
&source,
coa_core::signing::EMBEDDED_PUBLIC_KEY,
&BTreeMap::new(),
)?;
assert_eq!(
preview.pending_migrations, 0,
"Historical SQL must not replay"
);
assert!(
!preview
.items
.iter()
.any(|item| item.action == update::Action::Conflict),
"Unresolved candidate files: {:?}",
preview.items
);
let environment = RepackEnv {
root,
meta_dir: &meta_dir,
};
let outcome = update::apply(
&update::Params {
root,
meta_dir: &meta_dir,
source,
trusted_key: coa_core::signing::EMBEDDED_PUBLIC_KEY,
resolutions: BTreeMap::new(),
cancel: Default::default(),
env: &environment,
fail_after_ops: None,
},
&|stage, progress| println!("{progress}% {stage}"),
)?;
assert_eq!(
outcome.txn.state,
update::State::Committed,
"{:?}",
outcome.txn
);
backup::with_database(root, |db| {
for (index, mode) in [coa_core::realms::Mode::Coa, coa_core::realms::Mode::Wildcard].into_iter().enumerate() {
for (index, mode) in [
coa_core::realms::Mode::Coa,
coa_core::realms::Mode::Wildcard,
]
.into_iter()
.enumerate()
{
let realm = db.clone().for_realm(mode);
assert_eq!(players(&realm)?, expected[index], "Player data changed in {mode:?}");
assert_eq!(
players(&realm)?,
expected[index],
"Player data changed in {mode:?}"
);
let problems = coa_core::schema_check::check(&realm, root)?;
assert!(problems.is_empty(), "{problems:?}");
}
@@ -33,9 +89,22 @@ fn exercise(root: &std::path::Path, package: &str) -> Result<()> {
println!("SQUID metadata: {release:?}");
assert_eq!(coa_core::squid::fields(root)?.len(), 40);
let (_, installed) = MetaDir::open(&meta_dir)?;
let repeated = update::preview(root, &installed, &coa_core::pkgsource::Source::Dir(package.into()), coa_core::signing::EMBEDDED_PUBLIC_KEY, &BTreeMap::new())?;
let repeated = update::preview(
root,
&installed,
&coa_core::pkgsource::Source::Dir(package.into()),
coa_core::signing::EMBEDDED_PUBLIC_KEY,
&BTreeMap::new(),
)?;
assert_eq!(repeated.pending_migrations, 0);
assert!(repeated.items.iter().all(|item| item.action == update::Action::Skip), "{:?}", repeated.items);
assert!(
repeated
.items
.iter()
.all(|item| item.action == update::Action::Skip),
"{:?}",
repeated.items
);
println!("PASS: coordinated update committed, both realms started, player fields preserved, historical SQL skipped, repeated preview clean");
Ok(())
}
@@ -43,12 +112,30 @@ fn exercise(root: &std::path::Path, package: &str) -> Result<()> {
fn main() -> Result<()> {
let args: Vec<String> = std::env::args().skip(1).collect();
let root = PathBuf::from(&args[0]);
assert!(root.file_name().unwrap().to_string_lossy().starts_with("coa-schema-fixture-chaos-064-transition-"));
assert_eq!(std::fs::read(root.join(".transition-fixture"))?, b"disposable published-064 transition fixture");
assert_eq!(std::fs::read(root.join(".release-schema-fixture"))?, b"disposable release-schema fixture");
assert!(!root.join("Data").symlink_metadata()?.file_type().is_symlink());
assert!(root
.file_name()
.unwrap()
.to_string_lossy()
.starts_with("coa-schema-fixture-chaos-064-transition-"));
assert_eq!(
std::fs::read(root.join(".transition-fixture"))?,
b"disposable published-064 transition fixture"
);
assert_eq!(
std::fs::read(root.join(".release-schema-fixture"))?,
b"disposable release-schema fixture"
);
assert!(!root
.join("Data")
.symlink_metadata()?
.file_type()
.is_symlink());
assert!(driver::run(&root, driver::Verb::StopAll)?.ok);
let outcome = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| exercise(&root, &args[1])));
assert!(driver::run(&root, driver::Verb::StopAll)?.ok, "Fixture shutdown failed");
let outcome =
std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| exercise(&root, &args[1])));
assert!(
driver::run(&root, driver::Verb::StopAll)?.ok,
"Fixture shutdown failed"
);
outcome.map_err(|_| coa_core::Error::Invalid("Disposable coordinated acceptance failed; stopped services and retained recovery copies".into()))?
}
+9 -2
View File
@@ -1,7 +1,14 @@
fn main() {
let a: Vec<String> = std::env::args().skip(1).collect();
let job = coa_core::download::Job { url: a[0].clone(), dest: a[1].clone().into(), sha256: a[2].clone(), size: a[3].parse().unwrap() };
let job = coa_core::download::Job {
url: a[0].clone(),
dest: a[1].clone().into(),
sha256: a[2].clone(),
size: a[3].parse().unwrap(),
};
let t = std::time::Instant::now();
let r = coa_core::download::fetch(&job, &Default::default(), &|p| eprintln!("{}/{}", p.downloaded, p.total));
let r = coa_core::download::fetch(&job, &Default::default(), &|p| {
eprintln!("{}/{}", p.downloaded, p.total)
});
println!("{r:?} in {:?}", t.elapsed());
}
+26 -4
View File
@@ -9,13 +9,35 @@ use std::path::PathBuf;
fn main() {
let a: Vec<String> = std::env::args().skip(1).collect();
assert!(a.len() == 4, "usage: docker_install <package folder> <destination> <game data folder> <public key>");
assert!(
a.len() == 4,
"usage: docker_install <package folder> <destination> <game data folder> <public key>"
);
let registry = Registry::at(std::env::temp_dir().join("coa-docker-install/installs.json"));
let t = std::time::Instant::now();
let done = install(
&Params { source: Source::Dir(PathBuf::from(&a[0])), dest: PathBuf::from(&a[1]), data_dir: PathBuf::from(&a[2]), trusted_key: &a[3], registry: &registry, cancel: Cancel::default() },
&|s| eprintln!(" {:>3}% {} {}", s.percent, s.step, s.detail.unwrap_or_default()),
&Params {
source: Source::Dir(PathBuf::from(&a[0])),
dest: PathBuf::from(&a[1]),
data_dir: PathBuf::from(&a[2]),
trusted_key: &a[3],
registry: &registry,
cancel: Cancel::default(),
},
&|s| {
eprintln!(
" {:>3}% {} {}",
s.percent,
s.step,
s.detail.unwrap_or_default()
)
},
)
.unwrap_or_else(|e| panic!("install failed: {e}"));
println!("installed {} at {} in {:?}", done.version, done.path, t.elapsed());
println!(
"installed {} at {} in {:?}",
done.version,
done.path,
t.elapsed()
);
}
+3 -1
View File
@@ -2,7 +2,9 @@ use std::path::Path;
fn main() {
let mut args = std::env::args().skip(1);
let root = args.next().expect("usage: drive <server folder> <start|stop>");
let root = args
.next()
.expect("usage: drive <server folder> <start|stop>");
let verb = match args.next().as_deref() {
Some("start") => coa_core::driver::Verb::StartAll,
Some("mysql") => coa_core::driver::Verb::StartMysql,
+142 -34
View File
@@ -1,11 +1,27 @@
//! Verify published checksum compatibility on a disposable real database, without running SQL migrations.
use std::{path::{Path, PathBuf}, sync::atomic::{AtomicUsize, Ordering}};
use coa_core::{backup, db::Db, migrations::{self, LedgerRow, Status, Store}, pkgsource::{self, Source}, Result};
use coa_core::{
backup,
db::Db,
migrations::{self, LedgerRow, Status, Store},
pkgsource::{self, Source},
Result,
};
use std::{
path::{Path, PathBuf},
sync::atomic::{AtomicUsize, Ordering},
};
struct Observed<'a> { db: &'a Db, executions: AtomicUsize }
struct Observed<'a> {
db: &'a Db,
executions: AtomicUsize,
}
impl Store for Observed<'_> {
fn load(&self) -> Result<Vec<LedgerRow>> { self.db.load() }
fn put(&self, row: &LedgerRow) -> Result<()> { self.db.put(row) }
fn load(&self) -> Result<Vec<LedgerRow>> {
self.db.load()
}
fn put(&self, row: &LedgerRow) -> Result<()> {
self.db.put(row)
}
fn run_file(&self, _: &str, _: &Path) -> Result<()> {
self.executions.fetch_add(1, Ordering::SeqCst);
panic!("Historical SQL must never be replayed");
@@ -15,62 +31,149 @@ impl Store for Observed<'_> {
fn main() -> Result<()> {
let args: Vec<_> = std::env::args().skip(1).collect();
let root = PathBuf::from(&args[0]);
assert!(root.file_name().unwrap().to_string_lossy().starts_with("coa-schema-fixture-chaos-"));
assert_eq!(std::fs::read(root.join(".coa-chaos-fixture"))?, b"disposable update chaos fixture");
assert_eq!(std::fs::read(root.join(".release-schema-fixture"))?, b"disposable release-schema fixture");
assert!(root
.file_name()
.unwrap()
.to_string_lossy()
.starts_with("coa-schema-fixture-chaos-"));
assert_eq!(
std::fs::read(root.join(".coa-chaos-fixture"))?,
b"disposable update chaos fixture"
);
assert_eq!(
std::fs::read(root.join(".release-schema-fixture"))?,
b"disposable release-schema fixture"
);
let source = Source::Dir(PathBuf::from(&args[1]));
let package = pkgsource::fetch_manifest(&source, coa_core::signing::EMBEDDED_PUBLIC_KEY)?.0;
let staging = tempfile::tempdir()?;
let parts = pkgsource::fetch_parts(&source, &package, &staging.path().join("download"), &Default::default(), &|_, _| {})?;
let parts = pkgsource::fetch_parts(
&source,
&package,
&staging.path().join("download"),
&Default::default(),
&|_, _| {},
)?;
coa_core::package::extract(&parts, &package, &staging.path().join("tree"), &|_, _| {})?;
migrations::verify_files(&package.migrations, &staging.path().join("tree/_migrations"))?;
println!("PASS: all {} signed-package SQL artifacts verified before any database mutation", package.migrations.len());
let migration = package.migrations.iter().find(|m| m.id == "manager_repair__20261005_missing_wildcard_tables").unwrap();
let hashes = ["c1d8dbf2271234283a48a39e4b4aea1106b83b70581f1e3c4aa9fff438e8e4d2", "9e4a36245c3f83255415c122c01f08ceb3e3b83898d3d427ac4e2fbcf61e9638"];
for hash in hashes { assert!(migration.sha256 == hash || migration.compatible_sha256.iter().any(|h| h == hash)); }
migrations::verify_files(
&package.migrations,
&staging.path().join("tree/_migrations"),
)?;
println!(
"PASS: all {} signed-package SQL artifacts verified before any database mutation",
package.migrations.len()
);
let migration = package
.migrations
.iter()
.find(|m| m.id == "manager_repair__20261005_missing_wildcard_tables")
.unwrap();
let hashes = [
"c1d8dbf2271234283a48a39e4b4aea1106b83b70581f1e3c4aa9fff438e8e4d2",
"9e4a36245c3f83255415c122c01f08ceb3e3b83898d3d427ac4e2fbcf61e9638",
];
for hash in hashes {
assert!(migration.sha256 == hash || migration.compatible_sha256.iter().any(|h| h == hash));
}
let fixture_meta = coa_core::registry::metadata_dir_for(&root)?;
let test_meta = tempfile::tempdir()?;
coa_core::fsx::atomic_write(&test_meta.path().join("install.json"), &std::fs::read(fixture_meta.join("install.json"))?)?;
coa_core::fsx::atomic_write(
&test_meta.path().join("install.json"),
&std::fs::read(fixture_meta.join("install.json"))?,
)?;
coa_core::registry::MetaDir::open(test_meta.path())?;
std::fs::create_dir_all(test_meta.path().join("updates"))?;
let result = backup::with_database(&root, |db| {
let mut modes = vec![coa_core::realms::Mode::Coa];
if coa_core::realms::state(&root)?.wildcard_created { modes.push(coa_core::realms::Mode::Wildcard); }
if coa_core::realms::state(&root)?.wildcard_created {
modes.push(coa_core::realms::Mode::Wildcard);
}
for mode in modes {
let db = db.clone().for_realm(mode);
let saved = db.load()?.into_iter().find(|row| row.id == migration.id && row.db == migration.db).expect("Published repair must already be applied");
let saved = db
.load()?
.into_iter()
.find(|row| row.id == migration.id && row.db == migration.db)
.expect("Published repair must already be applied");
assert_eq!(saved.status, Status::Applied);
let counts = db.query("SELECT CONCAT((SELECT COUNT(*) FROM acore_characters.characters),':',(SELECT COUNT(*) FROM acore_characters.item_instance),':',(SELECT COUNT(*) FROM acore_auth.account));")?;
let check = || -> Result<()> {
for hash in hashes {
db.put(&LedgerRow { sha256: hash.into(), ..saved.clone() })?;
let observed = Observed { db: &db, executions: AtomicUsize::new(0) };
db.put(&LedgerRow {
sha256: hash.into(),
..saved.clone()
})?;
let observed = Observed {
db: &db,
executions: AtomicUsize::new(0),
};
migrations::preflight(&db, std::slice::from_ref(migration))?;
let report = migrations::apply_pending(&observed, std::slice::from_ref(migration), &root.join(".unused-hotfix-sql"), &|| panic!("Already applied SQL needs no snapshot"))?;
let report = migrations::apply_pending(
&observed,
std::slice::from_ref(migration),
&root.join(".unused-hotfix-sql"),
&|| panic!("Already applied SQL needs no snapshot"),
)?;
assert!(report.applied.is_empty());
assert_eq!(observed.executions.load(Ordering::SeqCst), 0);
assert_eq!(db.load()?.into_iter().find(|r| r.id == migration.id && r.db == migration.db).unwrap().sha256, hash);
assert_eq!(
db.load()?
.into_iter()
.find(|r| r.id == migration.id && r.db == migration.db)
.unwrap()
.sha256,
hash
);
}
let meta = test_meta.path();
let file_hash = coa_core::fsx::sha256_file(&root.join("Core/worldserver.exe"))?;
let install_hash = coa_core::fsx::sha256_file(&meta.join("install.json"))?;
let transaction_count = std::fs::read_dir(meta.join("updates"))?.count();
for status in [Status::Running, Status::Failed] {
db.put(&LedgerRow { status, ..saved.clone() })?;
let env = coa_core::update::RepackEnv { root: &root, meta_dir: meta };
let rejected = coa_core::update::apply(&coa_core::update::Params {
root: &root, meta_dir: meta, source: Source::Dir(PathBuf::from(&args[1])),
trusted_key: coa_core::signing::EMBEDDED_PUBLIC_KEY, cancel: Default::default(),
resolutions: Default::default(), env: &env, fail_after_ops: None,
}, &|_, _| {});
db.put(&LedgerRow {
status,
..saved.clone()
})?;
let env = coa_core::update::RepackEnv {
root: &root,
meta_dir: meta,
};
let rejected = coa_core::update::apply(
&coa_core::update::Params {
root: &root,
meta_dir: meta,
source: Source::Dir(PathBuf::from(&args[1])),
trusted_key: coa_core::signing::EMBEDDED_PUBLIC_KEY,
cancel: Default::default(),
resolutions: Default::default(),
env: &env,
fail_after_ops: None,
},
&|_, _| {},
);
let message = rejected.unwrap_err().to_string();
assert!(message.contains("partially applied"), "Unexpected rejection: {message}");
assert_eq!(std::fs::read_dir(meta.join("updates"))?.count(), transaction_count);
assert_eq!(coa_core::fsx::sha256_file(&root.join("Core/worldserver.exe"))?, file_hash);
assert_eq!(coa_core::fsx::sha256_file(&meta.join("install.json"))?, install_hash);
assert!(
message.contains("partially applied"),
"Unexpected rejection: {message}"
);
assert_eq!(
std::fs::read_dir(meta.join("updates"))?.count(),
transaction_count
);
assert_eq!(
coa_core::fsx::sha256_file(&root.join("Core/worldserver.exe"))?,
file_hash
);
assert_eq!(
coa_core::fsx::sha256_file(&meta.join("install.json"))?,
install_hash
);
}
db.put(&saved)?;
let env = coa_core::update::RepackEnv { root: &root, meta_dir: meta };
let env = coa_core::update::RepackEnv {
root: &root,
meta_dir: meta,
};
let pending_before = env.pending_migrations(&package)?;
db.query("DELETE FROM acore_world.coa_manager_migrations WHERE db='characters' AND id='manager_repair__20261005_missing_wildcard_tables';")?;
assert_eq!(env.pending_migrations(&package)?, pending_before + 1,
@@ -81,7 +184,12 @@ fn main() -> Result<()> {
};
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(check));
db.put(&saved)?;
result.map_err(|_| coa_core::Error::Invalid("History regression assertion failed; the injected ledger row was restored.".into()))??;
result.map_err(|_| {
coa_core::Error::Invalid(
"History regression assertion failed; the injected ledger row was restored."
.into(),
)
})??;
assert_eq!(db.query("SELECT CONCAT((SELECT COUNT(*) FROM acore_characters.characters),':',(SELECT COUNT(*) FROM acore_characters.item_instance),':',(SELECT COUNT(*) FROM acore_auth.account));")?, counts);
println!("PASS: {} published checksums; Running/Failed rejected before staging; missing migration counted; zero SQL replays; history and player counts preserved", mode.name());
}
+39 -12
View File
@@ -1,16 +1,43 @@
//! Read-only update preview against the marked disposable acceptance fixture.
use std::{collections::BTreeMap,path::PathBuf};
fn main()->coa_core::Result<()> {
let args:Vec<_>=std::env::args().skip(1).collect();
let root=PathBuf::from(&args[0]);
assert!(root.file_name().unwrap().to_string_lossy().starts_with("coa-schema-fixture-chaos-064-transition-"));
assert_eq!(std::fs::read(root.join(".transition-fixture"))?,b"disposable published-064 transition fixture");
let meta_dir=coa_core::registry::metadata_dir_for(&root)?;
let (_,meta)=coa_core::registry::MetaDir::open(&meta_dir)?;
let preview=coa_core::update::preview(&root,&meta,&coa_core::pkgsource::Source::Dir(args[1].clone().into()),coa_core::signing::EMBEDDED_PUBLIC_KEY,&BTreeMap::new())?;
assert_eq!(preview.from_version.as_deref(),Some(preview.to_version.as_str()));
assert_eq!(preview.pending_migrations,0);
assert!(preview.items.iter().all(|item|item.action==coa_core::update::Action::Skip),"{:?}",preview.items.iter().filter(|item|item.action!=coa_core::update::Action::Skip).collect::<Vec<_>>());
use std::{collections::BTreeMap, path::PathBuf};
fn main() -> coa_core::Result<()> {
let args: Vec<_> = std::env::args().skip(1).collect();
let root = PathBuf::from(&args[0]);
assert!(root
.file_name()
.unwrap()
.to_string_lossy()
.starts_with("coa-schema-fixture-chaos-064-transition-"));
assert_eq!(
std::fs::read(root.join(".transition-fixture"))?,
b"disposable published-064 transition fixture"
);
let meta_dir = coa_core::registry::metadata_dir_for(&root)?;
let (_, meta) = coa_core::registry::MetaDir::open(&meta_dir)?;
let preview = coa_core::update::preview(
&root,
&meta,
&coa_core::pkgsource::Source::Dir(args[1].clone().into()),
coa_core::signing::EMBEDDED_PUBLIC_KEY,
&BTreeMap::new(),
)?;
assert_eq!(
preview.from_version.as_deref(),
Some(preview.to_version.as_str())
);
assert_eq!(preview.pending_migrations, 0);
assert!(
preview
.items
.iter()
.all(|item| item.action == coa_core::update::Action::Skip),
"{:?}",
preview
.items
.iter()
.filter(|item| item.action != coa_core::update::Action::Skip)
.collect::<Vec<_>>()
);
println!("PASS: real fixture repeated preview: {} files unchanged, zero pending SQL, no update offered",preview.items.len());
Ok(())
}
+261 -113
View File
@@ -1,23 +1,48 @@
//! Real signed-package transition on an independent, explicitly marked disposable copy.
//! The Env wrapper instruments only launcher isolation; migration/backup/update code is production code.
use std::{collections::BTreeMap, path::{Path, PathBuf}};
use coa_core::{backup, driver, fsx, migrations, pkgsource::{self, Source}, registry::{InstallMeta, MetaDir}, update::{self, Env, RepackEnv}, Result};
use coa_core::{
backup, driver, fsx, migrations,
pkgsource::{self, Source},
registry::{InstallMeta, MetaDir},
update::{self, Env, RepackEnv},
Result,
};
use std::{
collections::BTreeMap,
path::{Path, PathBuf},
};
struct Offline<'a>(RepackEnv<'a>);
impl Env for Offline<'_> {
fn ensure_stopped(&self) -> Result<()> { self.0.ensure_stopped() }
fn preflight(&self, m: &coa_core::manifest::Manifest) -> Result<()> { self.0.preflight(m) }
fn verify_snapshot(&self, id: &str) -> Result<()> { self.0.verify_snapshot(id) }
fn snapshot(&self) -> Result<String> { self.0.snapshot() }
fn restore_snapshot(&self, id: &str) -> Result<()> { self.0.restore_snapshot(id) }
fn migrate(&self, m: &coa_core::manifest::Manifest, p: &Path) -> Result<migrations::ApplyReport> { self.0.migrate(m,p) }
fn ensure_stopped(&self) -> Result<()> {
self.0.ensure_stopped()
}
fn preflight(&self, m: &coa_core::manifest::Manifest) -> Result<()> {
self.0.preflight(m)
}
fn verify_snapshot(&self, id: &str) -> Result<()> {
self.0.verify_snapshot(id)
}
fn snapshot(&self) -> Result<String> {
self.0.snapshot()
}
fn restore_snapshot(&self, id: &str) -> Result<()> {
self.0.restore_snapshot(id)
}
fn migrate(
&self,
m: &coa_core::manifest::Manifest,
p: &Path,
) -> Result<migrations::ApplyReport> {
self.0.migrate(m, p)
}
fn validate(&self) -> Result<()> {
let path=self.0.root.join("Scripts/manage.py");
let source=std::fs::read_to_string(&path)?.replace("\r\n", "\n");
let path = self.0.root.join("Scripts/manage.py");
let source = std::fs::read_to_string(&path)?.replace("\r\n", "\n");
// Explicit test instrumentation prevents relay transmissions and binds services locally.
let guarded=source.replace("def spawn(name, command, cwd, log):\n", "def spawn(name, command, cwd, log):\n for filename in ('worldserver.conf', 'authserver.conf'):\n path = ROOT / 'Core/configs' / filename\n if path.exists():\n text = path.read_text(encoding='utf-8-sig')\n for key, value in (('BindIP', '\"127.0.0.1\"'), ('Ra.IP', '\"127.0.0.1\"'), ('SOAP.Enabled', '0')):\n text = re.sub(r'(?m)^\\s*' + re.escape(key) + r'\\s*=.*$', '', text)\n text += '\\n' + key + ' = ' + value + '\\n'\n path.write_text(text, encoding='utf-8')\n").replace("def relay_worker():\n", "def relay_worker():\n save_process('relay-ready', os.getpid())\n while not (STATE / 'stop-relay').exists():\n time.sleep(0.5)\n return\n");
assert_ne!(source,guarded,"Fixture launcher isolation failed");
fsx::atomic_write(&path,guarded.as_bytes())?;
assert_ne!(source, guarded, "Fixture launcher isolation failed");
fsx::atomic_write(&path, guarded.as_bytes())?;
self.0.validate()
}
}
@@ -25,138 +50,261 @@ fn players(db: &coa_core::db::Db) -> Result<String> {
db.query("SELECT CONCAT(id,':',username,':',HEX(salt),':',HEX(verifier)) FROM acore_auth.account WHERE id=900001; SELECT CONCAT(guid,':',account,':',name,':',level,':',money) FROM acore_characters.characters WHERE guid=900001; SELECT CONCAT(guid,':',itemEntry,':',owner_guid,':',enchantments) FROM acore_characters.item_instance WHERE guid=900001; SELECT CONCAT(guid,':',bag,':',slot,':',item) FROM acore_characters.character_inventory WHERE guid=900001;")
}
fn main() -> Result<()> {
let args:Vec<_>=std::env::args().skip(1).collect();
let root=PathBuf::from(&args[0]);
assert!(root.file_name().unwrap().to_string_lossy().starts_with("coa-schema-fixture-chaos-064-transition-"));
assert_eq!(std::fs::read(root.join(".transition-fixture"))?,b"disposable published-064 transition fixture");
if args.get(3).is_some_and(|mode| mode=="legacy-recovery") {
return run_fixture(&root,||legacy_recovery(&root));
let args: Vec<_> = std::env::args().skip(1).collect();
let root = PathBuf::from(&args[0]);
assert!(root
.file_name()
.unwrap()
.to_string_lossy()
.starts_with("coa-schema-fixture-chaos-064-transition-"));
assert_eq!(
std::fs::read(root.join(".transition-fixture"))?,
b"disposable published-064 transition fixture"
);
if args.get(3).is_some_and(|mode| mode == "legacy-recovery") {
return run_fixture(&root, || legacy_recovery(&root));
}
assert!(!root.join(".transition-started").exists(),"Use a new independent fixture");
fsx::atomic_write(&root.join(".transition-started"),b"started")?;
let meta=coa_core::registry::metadata_dir_for(&root)?;
assert!(!meta.exists(),"Do not reuse experimental or user metadata");
run_fixture(&root,||exercise(&root,&meta,&args[1],&args[2]))
assert!(
!root.join(".transition-started").exists(),
"Use a new independent fixture"
);
fsx::atomic_write(&root.join(".transition-started"), b"started")?;
let meta = coa_core::registry::metadata_dir_for(&root)?;
assert!(!meta.exists(), "Do not reuse experimental or user metadata");
run_fixture(&root, || exercise(&root, &meta, &args[1], &args[2]))
}
fn run_fixture(root:&Path,operation:impl FnOnce()->Result<()>)->Result<()> {
let result=std::panic::catch_unwind(std::panic::AssertUnwindSafe(operation));
assert!(driver::run(root,driver::Verb::StopAll)?.ok,"Fixture shutdown failed");
fn run_fixture(root: &Path, operation: impl FnOnce() -> Result<()>) -> Result<()> {
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(operation));
assert!(
driver::run(root, driver::Verb::StopAll)?.ok,
"Fixture shutdown failed"
);
result.map_err(|_|coa_core::Error::Invalid("Disposable acceptance assertion failed; services were stopped and recovery copies retained.".into()))?
}
fn legacy_recovery(root:&Path)->Result<()> {
let meta=coa_core::registry::metadata_dir_for(root)?;
assert!(driver::run(root,driver::Verb::StopAll)?.ok);
let expected=backup::with_database(root,|db| [coa_core::realms::Mode::Coa,coa_core::realms::Mode::Wildcard].into_iter().map(|mode|players(&db.clone().for_realm(mode))).collect::<Result<Vec<_>>>())?;
assert!(driver::run(root,driver::Verb::StopAll)?.ok);
let dirs=std::fs::read_dir(meta.join("updates"))?.collect::<std::io::Result<Vec<_>>>()?;
assert_eq!(dirs.len(),1,"Requires exactly the preceding successful disposable transition");
let txn_dir=dirs[0].path();
let journal=txn_dir.join("txn.json");
let mut legacy:serde_json::Value=fsx::read_json(&journal)?;
assert_eq!(legacy["state"],"committed");
let point=legacy["recovery_point"].as_str().unwrap().to_string();
let point_path=meta.join("backups").join(&point).join("backup.json");
let mut point_json:serde_json::Value=fsx::read_json(&point_path)?;
point_json["manager_version"]="0.6.4".into();
for component in point_json["components"].as_array_mut().unwrap() { component.as_object_mut().unwrap().remove("file_sha256"); }
fsx::atomic_write_json(&point_path,&point_json)?;
fn legacy_recovery(root: &Path) -> Result<()> {
let meta = coa_core::registry::metadata_dir_for(root)?;
assert!(driver::run(root, driver::Verb::StopAll)?.ok);
let expected = backup::with_database(root, |db| {
[
coa_core::realms::Mode::Coa,
coa_core::realms::Mode::Wildcard,
]
.into_iter()
.map(|mode| players(&db.clone().for_realm(mode)))
.collect::<Result<Vec<_>>>()
})?;
assert!(driver::run(root, driver::Verb::StopAll)?.ok);
let dirs = std::fs::read_dir(meta.join("updates"))?.collect::<std::io::Result<Vec<_>>>()?;
assert_eq!(
dirs.len(),
1,
"Requires exactly the preceding successful disposable transition"
);
let txn_dir = dirs[0].path();
let journal = txn_dir.join("txn.json");
let mut legacy: serde_json::Value = fsx::read_json(&journal)?;
assert_eq!(legacy["state"], "committed");
let point = legacy["recovery_point"].as_str().unwrap().to_string();
let point_path = meta.join("backups").join(&point).join("backup.json");
let mut point_json: serde_json::Value = fsx::read_json(&point_path)?;
point_json["manager_version"] = "0.6.4".into();
for component in point_json["components"].as_array_mut().unwrap() {
component.as_object_mut().unwrap().remove("file_sha256");
}
fsx::atomic_write_json(&point_path, &point_json)?;
legacy.as_object_mut().unwrap().remove("recovery_hashes");
legacy.as_object_mut().unwrap().remove("databases_started");
legacy["state"]="applied".into();
fsx::atomic_write_json(&journal,&legacy)?;
assert!(update::ensure_recovered(&meta).is_err(),"Legacy unfinished update must block startup");
let id=legacy["id"].as_str().unwrap();
let env=RepackEnv {root,meta_dir:&meta};
legacy["state"] = "applied".into();
fsx::atomic_write_json(&journal, &legacy)?;
assert!(
update::ensure_recovered(&meta).is_err(),
"Legacy unfinished update must block startup"
);
let id = legacy["id"].as_str().unwrap();
let env = RepackEnv {
root,
meta_dir: &meta,
};
println!("Recovering legacy-format transaction and recovery point on disposable installation");
assert_eq!(update::rollback(root,&meta,id,&env)?.state,update::State::RolledBack);
assert_eq!(
update::rollback(root, &meta, id, &env)?.state,
update::State::RolledBack
);
for op in legacy["ops"].as_array().unwrap() {
let relative=op["path"].as_str().unwrap();
if op["had_previous"]==true {
assert_eq!(fsx::sha256_file(&fsx::safe_join(root,relative)?)?,fsx::sha256_file(&fsx::safe_join(&txn_dir.join("before"),relative)?)?,"Legacy file restoration mismatch: {relative}");
} else { assert!(!fsx::safe_join(root,relative)?.exists()); }
let relative = op["path"].as_str().unwrap();
if op["had_previous"] == true {
assert_eq!(
fsx::sha256_file(&fsx::safe_join(root, relative)?)?,
fsx::sha256_file(&fsx::safe_join(&txn_dir.join("before"), relative)?)?,
"Legacy file restoration mismatch: {relative}"
);
} else {
assert!(!fsx::safe_join(root, relative)?.exists());
}
}
assert_eq!(std::fs::read(meta.join("install.json"))?,std::fs::read(txn_dir.join("before/manager-install.json"))?);
backup::with_database(root,|db| {
for (index,mode) in [coa_core::realms::Mode::Coa,coa_core::realms::Mode::Wildcard].into_iter().enumerate() {
let db=db.clone().for_realm(mode);
assert_eq!(players(&db)?,expected[index]);
assert_eq!(
std::fs::read(meta.join("install.json"))?,
std::fs::read(txn_dir.join("before/manager-install.json"))?
);
backup::with_database(root, |db| {
for (index, mode) in [
coa_core::realms::Mode::Coa,
coa_core::realms::Mode::Wildcard,
]
.into_iter()
.enumerate()
{
let db = db.clone().for_realm(mode);
assert_eq!(players(&db)?, expected[index]);
assert_eq!(db.query("SELECT COUNT(*) FROM acore_world.coa_manager_migrations WHERE id IN ('manager_repair__20261005_reconcile_wildcard_tables','manager_repair__20261005_reconcile_missing_class_starts');")?,"0");
assert_eq!(db.query("SELECT sha256 FROM acore_world.coa_manager_migrations WHERE id='manager_repair__20261005_missing_wildcard_tables';")?,"9e4a36245c3f83255415c122c01f08ceb3e3b83898d3d427ac4e2fbcf61e9638");
}
Ok(())
})?;
assert!(driver::run(root,driver::Verb::StopAll)?.ok);
assert!(driver::run(root, driver::Verb::StopAll)?.ok);
assert!(update::pending_checked(&meta)?.is_none());
assert!(update::rollback(root,&meta,id,&env).is_err(),"Completed recovery must not run again");
assert!(
update::rollback(root, &meta, id, &env).is_err(),
"Completed recovery must not run again"
);
println!("PASS: legacy journal blocked startup; old files, metadata, migration histories and player fields restored; completed recovery rejects replay. Original baseline had a missing table, so healthy startup is not claimed after rollback.");
Ok(())
}
fn exercise(root:&Path,meta:&Path,baseline:&str,candidate:&str)->Result<()> {
let mut install:InstallMeta=fsx::read_json(&PathBuf::from("C:/games/coa-schema-fixture-chaos-20261005-v1.manager/install.json"))?;
install.server_path=root.to_string_lossy().into_owned();
install.id=uuid::Uuid::new_v4().to_string();
install.manager_version="0.6.4".into();
MetaDir::create(root,&install)?;
fn exercise(root: &Path, meta: &Path, baseline: &str, candidate: &str) -> Result<()> {
let mut install: InstallMeta = fsx::read_json(&PathBuf::from(
"C:/games/coa-schema-fixture-chaos-20261005-v1.manager/install.json",
))?;
install.server_path = root.to_string_lossy().into_owned();
install.id = uuid::Uuid::new_v4().to_string();
install.manager_version = "0.6.4".into();
MetaDir::create(root, &install)?;
// Private ports, and no inherited PID records or paths to the source database.
let mut cfg:serde_json::Value=fsx::read_json(&root.join("Settings/repack.json"))?;
let mut listeners=Vec::new();
for key in ["mysqlPort","authPort","worldPort","raPort"] {
let listener=std::net::TcpListener::bind("127.0.0.1:0")?;
cfg[key]=listener.local_addr()?.port().into(); listeners.push(listener);
let mut cfg: serde_json::Value = fsx::read_json(&root.join("Settings/repack.json"))?;
let mut listeners = Vec::new();
for key in ["mysqlPort", "authPort", "worldPort", "raPort"] {
let listener = std::net::TcpListener::bind("127.0.0.1:0")?;
cfg[key] = listener.local_addr()?.port().into();
listeners.push(listener);
}
fsx::atomic_write_json(&root.join("Settings/repack.json"),&cfg)?;
let mut profile:serde_json::Value=fsx::read_json(&root.join("Settings/realm-profile.json"))?;
for key in ["secondary_world_port","secondary_ra_port"] {
let listener=std::net::TcpListener::bind("127.0.0.1:0")?;
profile[key]=listener.local_addr()?.port().into(); listeners.push(listener);
fsx::atomic_write_json(&root.join("Settings/repack.json"), &cfg)?;
let mut profile: serde_json::Value = fsx::read_json(&root.join("Settings/realm-profile.json"))?;
for key in ["secondary_world_port", "secondary_ra_port"] {
let listener = std::net::TcpListener::bind("127.0.0.1:0")?;
profile[key] = listener.local_addr()?.port().into();
listeners.push(listener);
}
fsx::atomic_write_json(&root.join("Settings/realm-profile.json"),&profile)?;
fsx::atomic_write_json(&root.join("Settings/realm-profile.json"), &profile)?;
drop(listeners);
let state=root.join(".state");
if state.exists() { std::fs::remove_dir_all(&state)?; }
let secondary_state=root.join(".realms/secondary/.state");
if secondary_state.exists() { std::fs::remove_dir_all(&secondary_state)?; }
let source=Source::Dir(baseline.into());
let (manifest,_)=pkgsource::fetch_manifest(&source,coa_core::signing::EMBEDDED_PUBLIC_KEY)?;
let temp=tempfile::tempdir()?;
let parts=pkgsource::fetch_parts(&source,&manifest,&temp.path().join("download"),&Default::default(),&|_,_|{})?;
let tree=temp.path().join("tree");
coa_core::package::extract(&parts,&manifest,&tree,&|_,_|{})?;
let state = root.join(".state");
if state.exists() {
std::fs::remove_dir_all(&state)?;
}
let secondary_state = root.join(".realms/secondary/.state");
if secondary_state.exists() {
std::fs::remove_dir_all(&secondary_state)?;
}
let source = Source::Dir(baseline.into());
let (manifest, _) = pkgsource::fetch_manifest(&source, coa_core::signing::EMBEDDED_PUBLIC_KEY)?;
let temp = tempfile::tempdir()?;
let parts = pkgsource::fetch_parts(
&source,
&manifest,
&temp.path().join("download"),
&Default::default(),
&|_, _| {},
)?;
let tree = temp.path().join("tree");
coa_core::package::extract(&parts, &manifest, &tree, &|_, _| {})?;
for file in &manifest.files {
if file.path.starts_with("_migrations/") {continue;}
fsx::atomic_write(&fsx::safe_join(root,&file.path)?,&std::fs::read(fsx::safe_join(&tree,&file.path)?)?)?;
install.original_hashes.insert(file.path.clone(),file.sha256.clone());
if file.path.starts_with("_migrations/") {
continue;
}
fsx::atomic_write(
&fsx::safe_join(root, &file.path)?,
&std::fs::read(fsx::safe_join(&tree, &file.path)?)?,
)?;
install
.original_hashes
.insert(file.path.clone(), file.sha256.clone());
}
install.core.version=Some(manifest.version);
fsx::atomic_write_json(&meta.join("install.json"),&install)?;
install.core.version = Some(manifest.version);
fsx::atomic_write_json(&meta.join("install.json"), &install)?;
// Both worlds must remain local, including generated secondary configuration.
for relative in ["Settings/worldserver.conf.template","Settings/authserver.conf.template"] {
let p=root.join(relative);
let mut conf=coa_core::config::parser::ConfFile::parse_bytes(&std::fs::read(&p)?)?;
conf.set("BindIP","\"127.0.0.1\"",&[]); conf.set("Ra.IP","\"127.0.0.1\"",&[]); conf.set("SOAP.Enabled","0",&[]);
fsx::atomic_write(&p,conf.to_text().as_bytes())?;
for relative in [
"Settings/worldserver.conf.template",
"Settings/authserver.conf.template",
] {
let p = root.join(relative);
let mut conf = coa_core::config::parser::ConfFile::parse_bytes(&std::fs::read(&p)?)?;
conf.set("BindIP", "\"127.0.0.1\"", &[]);
conf.set("Ra.IP", "\"127.0.0.1\"", &[]);
conf.set("SOAP.Enabled", "0", &[]);
fsx::atomic_write(&p, conf.to_text().as_bytes())?;
}
let expected=backup::with_database(root,|db| {
let mut saved=Vec::new();
for mode in [coa_core::realms::Mode::Coa,coa_core::realms::Mode::Wildcard] {
let db=db.clone().for_realm(mode);
let expected = backup::with_database(root, |db| {
let mut saved = Vec::new();
for mode in [
coa_core::realms::Mode::Coa,
coa_core::realms::Mode::Wildcard,
] {
let db = db.clone().for_realm(mode);
saved.push(players(&db)?);
db.query("DROP TABLE IF EXISTS acore_characters.coa_wildcard_skill_card; DELETE FROM acore_world.coa_manager_migrations WHERE id IN ('manager_repair__20261005_reconcile_wildcard_tables','manager_repair__20261005_reconcile_missing_class_starts'); UPDATE acore_world.coa_manager_migrations SET sha256='9e4a36245c3f83255415c122c01f08ceb3e3b83898d3d427ac4e2fbcf61e9638' WHERE id='manager_repair__20261005_missing_wildcard_tables' AND status='applied';")?;
}
Ok(saved)
})?;
let source=Source::Dir(candidate.into());
let candidate_manifest=pkgsource::fetch_manifest(&source,coa_core::signing::EMBEDDED_PUBLIC_KEY)?.0;
let choices:BTreeMap<_,_>=update::plan(root,&install,&candidate_manifest,&BTreeMap::new(),None)?.into_iter().filter(|p|p.action==update::Action::Conflict).map(|p|(p.path,update::Resolution::Replace)).collect();
let env=Offline(RepackEnv{root,meta_dir:meta});
let outcome=update::apply(&update::Params {root,meta_dir:meta,source,trusted_key:coa_core::signing::EMBEDDED_PUBLIC_KEY,cancel:Default::default(),resolutions:choices,env:&env,fail_after_ops:None},&|stage,pct|println!("{pct}% {stage}"))?;
assert_eq!(outcome.txn.state,update::State::Committed,"{:?}",outcome.txn.message);
backup::with_database(root,|db| {
for (index,mode) in [coa_core::realms::Mode::Coa,coa_core::realms::Mode::Wildcard].into_iter().enumerate() {
let db=db.clone().for_realm(mode);
assert_eq!(players(&db)?,expected[index],"Player data changed in {}",mode.name());
assert!(coa_core::schema_check::check(&db,root)?.is_empty());
assert_eq!(migrations::pending_count(&db,&candidate_manifest.migrations)?,0);
let source = Source::Dir(candidate.into());
let candidate_manifest =
pkgsource::fetch_manifest(&source, coa_core::signing::EMBEDDED_PUBLIC_KEY)?.0;
let choices: BTreeMap<_, _> =
update::plan(root, &install, &candidate_manifest, &BTreeMap::new(), None)?
.into_iter()
.filter(|p| p.action == update::Action::Conflict)
.map(|p| (p.path, update::Resolution::Replace))
.collect();
let env = Offline(RepackEnv {
root,
meta_dir: meta,
});
let outcome = update::apply(
&update::Params {
root,
meta_dir: meta,
source,
trusted_key: coa_core::signing::EMBEDDED_PUBLIC_KEY,
cancel: Default::default(),
resolutions: choices,
env: &env,
fail_after_ops: None,
},
&|stage, pct| println!("{pct}% {stage}"),
)?;
assert_eq!(
outcome.txn.state,
update::State::Committed,
"{:?}",
outcome.txn.message
);
backup::with_database(root, |db| {
for (index, mode) in [
coa_core::realms::Mode::Coa,
coa_core::realms::Mode::Wildcard,
]
.into_iter()
.enumerate()
{
let db = db.clone().for_realm(mode);
assert_eq!(
players(&db)?,
expected[index],
"Player data changed in {}",
mode.name()
);
assert!(coa_core::schema_check::check(&db, root)?.is_empty());
assert_eq!(
migrations::pending_count(&db, &candidate_manifest.migrations)?,
0
);
}
Ok(())
})?;
+94 -18
View File
@@ -11,47 +11,123 @@ use std::path::PathBuf;
fn main() {
let a: Vec<String> = std::env::args().skip(1).collect();
let (fixture, out, dest) = (PathBuf::from(&a[0]), PathBuf::from(&a[1]), PathBuf::from(&a[2]));
assert!(a[0].to_lowercase().contains("fixture"), "refusing: source is not a fixture");
assert!(std::fs::symlink_metadata(fixture.join("Data")).unwrap().file_type().is_symlink(), "Data junction must be skipped by the packager");
let (fixture, out, dest) = (
PathBuf::from(&a[0]),
PathBuf::from(&a[1]),
PathBuf::from(&a[2]),
);
assert!(
a[0].to_lowercase().contains("fixture"),
"refusing: source is not a fixture"
);
assert!(
std::fs::symlink_metadata(fixture.join("Data"))
.unwrap()
.file_type()
.is_symlink(),
"Data junction must be skipped by the packager"
);
let t = std::time::Instant::now();
let m = build(&fixture, &out, &BuildOptions { kind: coa_core::manifest::Kind::Base, version: "0.1.0".into(), core_commit: None, built_at: chrono::Utc::now().to_rfc3339(), part_size: 256 * 1024 * 1024, bots_commit: None, migrations: vec![] }, &|s| eprintln!(" pack: {s}")).expect("build");
let m = build(
&fixture,
&out,
&BuildOptions {
kind: coa_core::manifest::Kind::Base,
version: "0.1.0".into(),
core_commit: None,
built_at: chrono::Utc::now().to_rfc3339(),
part_size: 256 * 1024 * 1024,
bots_commit: None,
migrations: vec![],
},
&|s| eprintln!(" pack: {s}"),
)
.expect("build");
let arch = m.archive.as_ref().unwrap();
println!("packaged {} files, {:.2} GB -> {} parts, {:.2} GB in {:?}", m.files.len(), arch.unpacked_size as f64 / 1e9, arch.parts.len(), arch.parts.iter().map(|p| p.size).sum::<u64>() as f64 / 1e9, t.elapsed());
println!(
"packaged {} files, {:.2} GB -> {} parts, {:.2} GB in {:?}",
m.files.len(),
arch.unpacked_size as f64 / 1e9,
arch.parts.len(),
arch.parts.iter().map(|p| p.size).sum::<u64>() as f64 / 1e9,
t.elapsed()
);
let key_path = format!("{}/.coa-manager/signing/manifest-signing.key", std::env::var("USERPROFILE").unwrap());
let seed: [u8; 32] = STANDARD.decode(std::fs::read_to_string(key_path).unwrap().trim()).unwrap().try_into().unwrap();
let sig = SigningKey::from_bytes(&seed).sign(&std::fs::read(out.join("manifest.json")).unwrap());
std::fs::write(out.join("manifest.json.sig"), STANDARD.encode(sig.to_bytes())).unwrap();
let key_path = format!(
"{}/.coa-manager/signing/manifest-signing.key",
std::env::var("USERPROFILE").unwrap()
);
let seed: [u8; 32] = STANDARD
.decode(std::fs::read_to_string(key_path).unwrap().trim())
.unwrap()
.try_into()
.unwrap();
let sig =
SigningKey::from_bytes(&seed).sign(&std::fs::read(out.join("manifest.json")).unwrap());
std::fs::write(
out.join("manifest.json.sig"),
STANDARD.encode(sig.to_bytes()),
)
.unwrap();
let reg_dir = std::env::temp_dir().join("coa-install-e2e");
let _ = std::fs::remove_dir_all(&reg_dir);
let registry = Registry::at(reg_dir.join("installs.json"));
let t = std::time::Instant::now();
let installed = install_base(
&Params { source: Source::Dir(out.clone()), dest: dest.clone(), trusted_key: coa_core::signing::EMBEDDED_PUBLIC_KEY, registry: &registry, cancel: Cancel::default() },
&|s| eprintln!(" install: {:>3}% {} {}", s.percent, s.step, s.detail.unwrap_or_default()),
&Params {
source: Source::Dir(out.clone()),
dest: dest.clone(),
trusted_key: coa_core::signing::EMBEDDED_PUBLIC_KEY,
registry: &registry,
cancel: Cancel::default(),
},
&|s| {
eprintln!(
" install: {:>3}% {} {}",
s.percent,
s.step,
s.detail.unwrap_or_default()
)
},
)
.unwrap_or_else(|e| panic!("install failed: {e:?}"));
println!("installed {} at {} in {:?}", installed.version, installed.path, t.elapsed());
println!(
"installed {} at {} in {:?}",
installed.version,
installed.path,
t.elapsed()
);
assert!(!dest.with_file_name("coa-installtest.installing").exists());
assert!(!dest.join("Settings/database.bootstrap.json").exists(), "bootstrap credentials are removed");
assert!(
!dest.join("Settings/database.bootstrap.json").exists(),
"bootstrap credentials are removed"
);
assert!(dest.join("Core/worldserver.exe").is_file());
assert!(dest.with_file_name("coa-installtest.manager/install.json").is_file());
assert!(dest
.with_file_name("coa-installtest.manager/install.json")
.is_file());
assert_eq!(registry.list().unwrap().len(), 1);
// The rotated credentials must differ from the packaged ones and work.
let packaged: serde_json::Value = serde_json::from_slice(&std::fs::read(fixture.join("Settings/database.json")).unwrap()).unwrap();
let now: serde_json::Value = serde_json::from_slice(&std::fs::read(dest.join("Settings/database.json")).unwrap()).unwrap();
let packaged: serde_json::Value =
serde_json::from_slice(&std::fs::read(fixture.join("Settings/database.json")).unwrap())
.unwrap();
let now: serde_json::Value =
serde_json::from_slice(&std::fs::read(dest.join("Settings/database.json")).unwrap())
.unwrap();
assert_ne!(packaged["rootPassword"], now["rootPassword"]);
assert_ne!(packaged["appPassword"], now["appPassword"]);
coa_core::backup::with_database(&dest, |db: &Db| {
assert!(db.ping());
assert_eq!(db.tables("acore_auth")?.len() > 10, true);
assert!(db.tables("acore_auth")?.len() > 10);
let app = Db::from_repack(&dest, Account::App)?;
assert!(app.query("SELECT 1;")? == "1", "the game account works with the new password");
assert!(
app.query("SELECT 1;")? == "1",
"the game account works with the new password"
);
Ok(())
})
.expect("database after install");
+16 -2
View File
@@ -5,9 +5,23 @@ use coa_core::registry::Registry;
fn main() {
let a: Vec<String> = std::env::args().skip(1).collect();
let reg = Registry::at(std::env::temp_dir().join("coa-install-pkg").join("installs.json"));
let reg = Registry::at(
std::env::temp_dir()
.join("coa-install-pkg")
.join("installs.json"),
);
let _ = std::fs::remove_dir_all(std::env::temp_dir().join("coa-install-pkg"));
let t = std::time::Instant::now();
let r = install_base(&Params { source: Source::Dir(a[0].clone().into()), dest: a[1].clone().into(), trusted_key: coa_core::signing::EMBEDDED_PUBLIC_KEY, registry: &reg, cancel: Cancel::default() }, &|s| eprintln!(" {:>3}% {}", s.percent, s.step)).unwrap_or_else(|e| panic!("install failed: {e:?}"));
let r = install_base(
&Params {
source: Source::Dir(a[0].clone().into()),
dest: a[1].clone().into(),
trusted_key: coa_core::signing::EMBEDDED_PUBLIC_KEY,
registry: &reg,
cancel: Cancel::default(),
},
&|s| eprintln!(" {:>3}% {}", s.percent, s.step),
)
.unwrap_or_else(|e| panic!("install failed: {e:?}"));
println!("installed {} at {} in {:?}", r.version, r.path, t.elapsed());
}
+16 -2
View File
@@ -5,9 +5,23 @@ use coa_core::registry::Registry;
fn main() {
let a: Vec<String> = std::env::args().skip(1).collect();
let reg = Registry::at(std::env::temp_dir().join("coa-install-url").join("installs.json"));
let reg = Registry::at(
std::env::temp_dir()
.join("coa-install-url")
.join("installs.json"),
);
let _ = std::fs::remove_dir_all(std::env::temp_dir().join("coa-install-url"));
let t = std::time::Instant::now();
let r = install_base(&Params { source: Source::Url(a[0].clone()), dest: a[1].clone().into(), trusted_key: coa_core::signing::EMBEDDED_PUBLIC_KEY, registry: &reg, cancel: Cancel::default() }, &|s| eprintln!(" {:>3}% {}", s.percent, s.step)).unwrap_or_else(|e| panic!("install failed: {e:?}"));
let r = install_base(
&Params {
source: Source::Url(a[0].clone()),
dest: a[1].clone().into(),
trusted_key: coa_core::signing::EMBEDDED_PUBLIC_KEY,
registry: &reg,
cancel: Cancel::default(),
},
&|s| eprintln!(" {:>3}% {}", s.percent, s.step),
)
.unwrap_or_else(|e| panic!("install failed: {e:?}"));
println!("installed {} at {} in {:?}", r.version, r.path, t.elapsed());
}
+17 -4
View File
@@ -5,14 +5,27 @@ use ed25519_dalek::SigningKey;
use std::{fs, path::PathBuf};
fn main() {
let private = PathBuf::from(std::env::var("USERPROFILE").expect("USERPROFILE")).join(".coa-manager/signing/manifest-signing.key");
let public = PathBuf::from(std::env::args().nth(1).unwrap_or_else(|| "keys/manifest-signing.pub".into()));
let private = PathBuf::from(std::env::var("USERPROFILE").expect("USERPROFILE"))
.join(".coa-manager/signing/manifest-signing.key");
let public = PathBuf::from(
std::env::args()
.nth(1)
.unwrap_or_else(|| "keys/manifest-signing.pub".into()),
);
if private.exists() || public.exists() {
panic!("a key already exists; refusing to overwrite");
}
fs::create_dir_all(private.parent().unwrap()).unwrap();
let sk = SigningKey::generate(&mut rand_core::OsRng);
fs::write(&private, STANDARD.encode(sk.to_bytes())).unwrap();
fs::write(&public, format!("{}\n", STANDARD.encode(sk.verifying_key().to_bytes()))).unwrap();
println!("private key: {}\npublic key: {}", private.display(), public.display());
fs::write(
&public,
format!("{}\n", STANDARD.encode(sk.verifying_key().to_bytes())),
)
.unwrap();
println!(
"private key: {}\npublic key: {}",
private.display(),
public.display()
);
}
+97 -17
View File
@@ -8,14 +8,24 @@ use coa_core::migrations::{apply_pending, status, Status};
use std::path::{Path, PathBuf};
fn sql_files(dir: &Path) -> Vec<PathBuf> {
let mut v: Vec<PathBuf> = std::fs::read_dir(dir).map(|rd| rd.flatten().map(|e| e.path()).filter(|p| p.extension().map(|e| e == "sql").unwrap_or(false)).collect()).unwrap_or_default();
let mut v: Vec<PathBuf> = std::fs::read_dir(dir)
.map(|rd| {
rd.flatten()
.map(|e| e.path())
.filter(|p| p.extension().map(|e| e == "sql").unwrap_or(false))
.collect()
})
.unwrap_or_default();
v.sort();
v
}
fn main() {
let a: Vec<String> = std::env::args().skip(1).collect();
assert!(a[0].to_lowercase().contains("fixture"), "refusing: not a fixture folder");
assert!(
a[0].to_lowercase().contains("fixture"),
"refusing: not a fixture folder"
);
let (root, core) = (PathBuf::from(&a[0]), PathBuf::from(&a[1]));
let staging = std::env::temp_dir().join("coa-migrate-e2e");
let _ = std::fs::remove_dir_all(&staging);
@@ -24,17 +34,37 @@ fn main() {
let mut list: Vec<Migration> = Vec::new();
let mut origin: std::collections::HashMap<(String, String), String> = Default::default();
let mut add = |db: &str, id: String, src: &Path| {
origin.insert((db.to_string(), id.clone()), src.strip_prefix(&core).unwrap().to_string_lossy().replace('\\', "/"));
origin.insert(
(db.to_string(), id.clone()),
src.strip_prefix(&core)
.unwrap()
.to_string_lossy()
.replace('\\', "/"),
);
let bytes = std::fs::read(src).unwrap();
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 { compatible_sha256: vec![], 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 (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 {
for f in sql_files(&core.join("data/sql/updates").join(d)) {
add(kind, f.file_stem().unwrap().to_string_lossy().into_owned(), &f);
add(
kind,
f.file_stem().unwrap().to_string_lossy().into_owned(),
&f,
);
}
}
}
@@ -43,10 +73,21 @@ fn main() {
for kind in ["auth", "characters", "world"] {
let base = m.path().join(format!("data/sql/db-{kind}"));
for f in sql_files(&base.join("base")) {
add(kind, format!("mod_{mname}__base__{}", f.file_stem().unwrap().to_string_lossy()), &f);
add(
kind,
format!(
"mod_{mname}__base__{}",
f.file_stem().unwrap().to_string_lossy()
),
&f,
);
}
for f in sql_files(&base) {
add(kind, format!("mod_{mname}__{}", f.file_stem().unwrap().to_string_lossy()), &f);
add(
kind,
format!("mod_{mname}__{}", f.file_stem().unwrap().to_string_lossy()),
&f,
);
}
}
}
@@ -54,29 +95,68 @@ fn main() {
// table created by a module script that arrived earlier). The release pipeline computes exactly this.
let out = std::process::Command::new("git")
.current_dir(&core)
.args(["log", "--reverse", "--diff-filter=A", "--name-only", "--pretty=format:", "--", "data/sql/updates", "modules"])
.args([
"log",
"--reverse",
"--diff-filter=A",
"--name-only",
"--pretty=format:",
"--",
"data/sql/updates",
"modules",
])
.output()
.unwrap();
let mut rank = std::collections::HashMap::new();
for (i, path) in String::from_utf8_lossy(&out.stdout).lines().filter(|l| l.ends_with(".sql")).enumerate() {
for (i, path) in String::from_utf8_lossy(&out.stdout)
.lines()
.filter(|l| l.ends_with(".sql"))
.enumerate()
{
rank.entry(path.to_string()).or_insert(i);
}
let key = |m: &Migration| -> usize {
origin.get(&(m.db.clone(), m.id.clone())).and_then(|p| rank.get(p)).copied().unwrap_or(usize::MAX)
origin
.get(&(m.db.clone(), m.id.clone()))
.and_then(|p| rank.get(p))
.copied()
.unwrap_or(usize::MAX)
};
list.sort_by_key(|m| key(m));
println!("candidate migrations: {} ({} not found in history)", list.len(), list.iter().filter(|m| key(m) == usize::MAX).count());
println!(
"candidate migrations: {} ({} not found in history)",
list.len(),
list.iter().filter(|m| key(m) == usize::MAX).count()
);
let admin = Db::from_repack(&root, Account::Admin).unwrap();
let _ = &admin;
let t = std::time::Instant::now();
let report = backup::with_database(&root, |db| {
let before = status(db, &list)?;
let pending = before.iter().filter(|i| i.status == Status::Pending).count();
println!("already recorded by the database: {}; pending: {pending}", list.len() - pending);
let pending_list: Vec<Migration> = list.iter().zip(&before).filter(|(_, i)| i.status == Status::Pending).map(|(m, _)| m.clone()).collect();
apply_pending(db, &pending_list, &staging, &|| Ok("(fixture: no backup)".into()))
let pending = before
.iter()
.filter(|i| i.status == Status::Pending)
.count();
println!(
"already recorded by the database: {}; pending: {pending}",
list.len() - pending
);
let pending_list: Vec<Migration> = list
.iter()
.zip(&before)
.filter(|(_, i)| i.status == Status::Pending)
.map(|(m, _)| m.clone())
.collect();
apply_pending(db, &pending_list, &staging, &|| {
Ok("(fixture: no backup)".into())
})
})
.expect("apply");
println!("applied {} in {:?}; failed: {:?}", report.applied.len(), t.elapsed(), report.failed);
println!(
"applied {} in {:?}; failed: {:?}",
report.applied.len(),
t.elapsed(),
report.failed
);
}
+36 -7
View File
@@ -7,19 +7,48 @@ use ed25519_dalek::{Signer, SigningKey};
fn main() {
let a: Vec<String> = std::env::args().skip(1).collect();
let out = std::path::PathBuf::from(&a[0]);
let src = out.with_file_name(format!("{}-src", out.file_name().unwrap().to_string_lossy()));
let src = out.with_file_name(format!(
"{}-src",
out.file_name().unwrap().to_string_lossy()
));
let _ = std::fs::remove_dir_all(&src);
let _ = std::fs::remove_dir_all(&out);
for spec in &a[2..] {
let (p, c) = spec.split_once('=').expect("path=content");
let f = src.join(p);
std::fs::create_dir_all(f.parent().unwrap()).unwrap();
std::fs::write(f, c.replace("\n", "\n")).unwrap();
std::fs::write(f, c.replace("\\n", "\n")).unwrap();
}
build(&src, &out, &BuildOptions { kind: Kind::Update, version: a[1].clone(), core_commit: None, built_at: chrono::Utc::now().to_rfc3339(), part_size: 1 << 20, bots_commit: None, migrations: vec![] }, &|_| {}).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();
let sig = SigningKey::from_bytes(&seed).sign(&std::fs::read(out.join("manifest.json")).unwrap());
std::fs::write(out.join("manifest.json.sig"), STANDARD.encode(sig.to_bytes())).unwrap();
build(
&src,
&out,
&BuildOptions {
kind: Kind::Update,
version: a[1].clone(),
core_commit: None,
built_at: chrono::Utc::now().to_rfc3339(),
part_size: 1 << 20,
bots_commit: None,
migrations: vec![],
},
&|_| {},
)
.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();
let sig =
SigningKey::from_bytes(&seed).sign(&std::fs::read(out.join("manifest.json")).unwrap());
std::fs::write(
out.join("manifest.json.sig"),
STANDARD.encode(sig.to_bytes()),
)
.unwrap();
println!("package {} at {}", a[1], out.display());
}
+43 -10
View File
@@ -1,18 +1,40 @@
//! Probe only a disposable fixture: enable both worlds, verify isolation, gracefully stop both.
use coa_core::{Error, Result, driver::{self, Verb}, realms::{self, Mode}, multiworld, process::{self, ServiceState}};
use coa_core::{
driver::{self, Verb},
multiworld,
process::{self, ServiceState},
realms::{self, Mode},
Error, Result,
};
use std::path::PathBuf;
fn main() -> Result<()> {
let root = PathBuf::from(std::env::args().nth(1).ok_or_else(|| Error::Invalid("fixture path required".into()))?);
if !root.file_name().is_some_and(|n| n.to_string_lossy().contains("fixture")) { return Err(Error::Invalid("Refusing a non-fixture server.".into())); }
let root = PathBuf::from(
std::env::args()
.nth(1)
.ok_or_else(|| Error::Invalid("fixture path required".into()))?,
);
if !root
.file_name()
.is_some_and(|n| n.to_string_lossy().contains("fixture"))
{
return Err(Error::Invalid("Refusing a non-fixture server.".into()));
}
let action = std::env::args().nth(2).unwrap_or_else(|| "smoke".into());
if action == "stop" { driver::run(&root, Verb::StopAll)?; return Ok(()); }
if action == "stop" {
driver::run(&root, Verb::StopAll)?;
return Ok(());
}
driver::run(&root, Verb::StopAll)?;
if action == "wildcard" { realms::select(&root, Mode::Wildcard)?; }
if action == "wildcard" {
realms::select(&root, Mode::Wildcard)?;
}
multiworld::set_enabled(&root, true)?;
let result = (|| {
let out = driver::run(&root, Verb::StartAll)?;
if !out.ok { return Err(Error::Invalid(out.output)); }
if !out.ok {
return Err(Error::Invalid(out.output));
}
let first = process::observe(&root, &coa_core::layout::read_ports(&root));
let second_root = multiworld::root(&root);
let second = process::observe(&second_root, &coa_core::layout::read_ports(&second_root));
@@ -22,21 +44,32 @@ fn main() -> Result<()> {
assert_ne!(first.world.port, second.world.port);
assert!(second.mysql.pid.is_none() && second.auth.pid.is_none());
let db = coa_core::db::Db::from_repack(&root, coa_core::db::Account::Admin)?;
let realms = db.query("SELECT id,port,flag FROM acore_auth.realmlist WHERE id IN (1,2) ORDER BY id;")?;
let realms = db.query(
"SELECT id,port,flag FROM acore_auth.realmlist WHERE id IN (1,2) ORDER BY id;",
)?;
println!("Two distinct world PIDs; shared auth/MySQL; realm rows:\n{realms}");
for mode in [Mode::Coa, Mode::Wildcard] {
let problems = coa_core::schema_check::check(&db.clone().for_realm(mode), &root)?;
println!("{}: {} database problems", mode.name(), problems.len());
for p in problems.iter().take(5) { println!("{}.{}.{}: {}", p.database, p.table, p.column, p.detail); }
for p in problems.iter().take(5) {
println!("{}.{}.{}: {}", p.database, p.table, p.column, p.detail);
}
}
assert!(multiworld::set_enabled(&root, false).is_err());
assert!(realms::select(&root, Mode::Wildcard).is_err());
Ok(())
})();
let stopped = driver::run(&root, Verb::StopAll)?;
if !stopped.ok { return Err(Error::Invalid(stopped.output)); }
if !stopped.ok {
return Err(Error::Invalid(stopped.output));
}
assert!(!multiworld::is_running(&root));
assert_eq!(process::observe(&root, &coa_core::layout::read_ports(&root)).mysql.state, ServiceState::Stopped);
assert_eq!(
process::observe(&root, &coa_core::layout::read_ports(&root))
.mysql
.state,
ServiceState::Stopped
);
result?;
println!("Both worlds shut down before the shared database.");
Ok(())
+9 -2
View File
@@ -3,12 +3,19 @@ fn main() {
let ports = coa_core::layout::read_ports(std::path::Path::new(&root));
println!("LAN address: {:?}", coa_core::net::lan_ip());
for e in coa_core::net::exposure(&ports) {
println!("{:<14} port {:<5} listening={} reachable_from_network={}", e.what, e.port, e.listening, e.reachable_from_network);
println!(
"{:<14} port {:<5} listening={} reachable_from_network={}",
e.what, e.port, e.listening, e.reachable_from_network
);
}
println!("{:?}", coa_core::net::tailscale());
println!("firewall rules: {:?}", coa_core::firewall::status());
match coa_core::upnp::discover() {
Some(gw) => println!("UPnP router: {} -> outside address {:?}", gw.control_url, coa_core::upnp::external_ip(&gw)),
Some(gw) => println!(
"UPnP router: {} -> outside address {:?}",
gw.control_url,
coa_core::upnp::external_ip(&gw)
),
None => println!("UPnP router: none answered"),
}
}
+407 -81
View File
@@ -50,27 +50,68 @@ use coa_core::realms::Mode;
/// The options of a command, with the realm's content profile: assembled from its schema, its client data and (given an RA port) its
/// core, and remembered in the store. Without `--data-dir` there is no profile and nothing is evaluated.
fn with_profile(db: &Db, store: &mut Store, base: &ImportOptions, data_dir: &str, ra_port: Option<u16>, ra_user: &str, server: &str) -> Result<ImportOptions, String> {
fn with_profile(
db: &Db,
store: &mut Store,
base: &ImportOptions,
data_dir: &str,
ra_port: Option<u16>,
ra_user: &str,
server: &str,
) -> Result<ImportOptions, String> {
if data_dir.is_empty() {
return Ok(base.clone());
}
let registry = coa_core::portable::extension::ExtensionRegistry::new();
let mut ra = ra_port.and_then(|port| std::env::var("COA_RA_PASSWORD").ok().and_then(|pw| coa_core::ra::Ra::connect_to(port, ra_user, &pw).ok()));
let mut caps = realm::profile::probe_capabilities(db, Some(std::path::Path::new(data_dir)), ra.as_mut(), &registry).map_err(|e| e.to_string())?;
let mut ra = ra_port.and_then(|port| {
std::env::var("COA_RA_PASSWORD")
.ok()
.and_then(|pw| coa_core::ra::Ra::connect_to(port, ra_user, &pw).ok())
});
let mut caps = realm::profile::probe_capabilities(
db,
Some(std::path::Path::new(data_dir)),
ra.as_mut(),
&registry,
)
.map_err(|e| e.to_string())?;
if ra.is_none() {
let remembered = store.realm_profile(server).map_err(|e| e.to_string())?;
caps = realm::profile::with_remembered_progression(caps, remembered.as_ref()).map_err(|e| e.to_string())?;
caps = realm::profile::with_remembered_progression(caps, remembered.as_ref())
.map_err(|e| e.to_string())?;
if caps.progression.is_none() {
eprintln!("realm {server}: its progression (level cap) has never been read from a running core: start it once and run `capabilities` with --ra-port");
}
}
let change = store.set_realm_profile(server, &caps, if ra.is_some() { "live" } else { "offline" }).map_err(|e| e.to_string())?;
eprintln!("realm {server}: content profile {}{}", &caps.content_profile_hash[..16], if change.changed() { " (new or changed)" } else { "" });
Ok(ImportOptions { capabilities: Some(std::sync::Arc::new(caps)), extensions: Some(std::sync::Arc::new(registry)), ..base.clone() })
let change = store
.set_realm_profile(server, &caps, if ra.is_some() { "live" } else { "offline" })
.map_err(|e| e.to_string())?;
eprintln!(
"realm {server}: content profile {}{}",
&caps.content_profile_hash[..16],
if change.changed() {
" (new or changed)"
} else {
""
}
);
Ok(ImportOptions {
capabilities: Some(std::sync::Arc::new(caps)),
extensions: Some(std::sync::Arc::new(registry)),
..base.clone()
})
}
fn usage() -> ! {
eprintln!("{}", include_str!("portable_smoke.rs").lines().take_while(|l| l.starts_with("//!")).map(|l| l.trim_start_matches("//!").trim_start_matches(' ')).collect::<Vec<_>>().join("\n"));
eprintln!(
"{}",
include_str!("portable_smoke.rs")
.lines()
.take_while(|l| l.starts_with("//!"))
.map(|l| l.trim_start_matches("//!").trim_start_matches(' '))
.collect::<Vec<_>>()
.join("\n")
);
std::process::exit(2)
}
@@ -92,17 +133,26 @@ fn run() -> Result<(), String> {
args.remove(i);
return Ok(v);
}
default.map(str::to_string).ok_or_else(|| format!("{name} is required"))
default
.map(str::to_string)
.ok_or_else(|| format!("{name} is required"))
};
let tools = PathBuf::from(take("--tools", None)?);
let port: u16 = take("--port", None)?.parse().map_err(|_| "--port is not a number".to_string())?;
let port: u16 = take("--port", None)?
.parse()
.map_err(|_| "--port is not a number".to_string())?;
let store_dir = PathBuf::from(take("--store", None)?);
let user = take("--user", Some("root"))?;
let realm_mode = match take("--realm", Some("coa"))?.as_str() {
"coa" => Mode::Coa,
other => return Err(format!("--realm {other}: only coa is supported (Wildcard portable transfer is not supported)")),
other => {
return Err(format!(
"--realm {other}: only coa is supported (Wildcard portable transfer is not supported)"
))
}
};
let password = std::env::var("COA_DB_PASSWORD").map_err(|_| "set COA_DB_PASSWORD".to_string())?;
let password =
std::env::var("COA_DB_PASSWORD").map_err(|_| "set COA_DB_PASSWORD".to_string())?;
// `with_tools` takes a 'static user name; this is a short-lived process
let user: &'static str = Box::leak(user.into_boxed_str());
let db = Db::with_tools(tools, port, user, &password, realm_mode);
@@ -110,102 +160,255 @@ fn run() -> Result<(), String> {
let data_dir = take("--data-dir", Some(""))?;
let knowledge = match data_dir.as_str() {
"" => None,
dir => Some(std::sync::Arc::new(coa_core::portable::realm::knowledge::RealmKnowledge::from_data_dir(std::path::Path::new(dir)).map_err(|e| e.to_string())?)),
dir => Some(std::sync::Arc::new(
coa_core::portable::realm::knowledge::RealmKnowledge::from_data_dir(
std::path::Path::new(dir),
)
.map_err(|e| e.to_string())?,
)),
};
let projection_file = take("--projection", Some(""))?;
let out_file = take("--out", Some(""))?;
let supplied = match projection_file.as_str() {
"" => None,
file => {
let hold: coa_core::portable::projection::ProjectionHold = serde_json::from_slice(&std::fs::read(file).map_err(|e| e.to_string())?).map_err(|e| format!("{file}: {e}"))?;
Some(coa_core::portable::projection::Oracle(std::sync::Arc::new(coa_core::portable::projection::SuppliedDecision(hold))))
let hold: coa_core::portable::projection::ProjectionHold =
serde_json::from_slice(&std::fs::read(file).map_err(|e| e.to_string())?)
.map_err(|e| format!("{file}: {e}"))?;
Some(coa_core::portable::projection::Oracle(std::sync::Arc::new(
coa_core::portable::projection::SuppliedDecision(hold),
)))
}
};
let opts = ImportOptions { game_server_users: vec![user.to_string(), "acore".to_string()], knowledge: knowledge.clone(), projection: supplied, ..ImportOptions::default() };
let host_dir = PathBuf::from(take("--host-store", Some(&format!("{}-host", store_dir.display())))?);
let ra_port: Option<u16> = take("--ra-port", Some("0"))?.parse().ok().filter(|p| *p != 0);
let opts = ImportOptions {
game_server_users: vec![user.to_string(), "acore".to_string()],
knowledge: knowledge.clone(),
projection: supplied,
..ImportOptions::default()
};
let host_dir = PathBuf::from(take(
"--host-store",
Some(&format!("{}-host", store_dir.display())),
)?);
let ra_port: Option<u16> = take("--ra-port", Some("0"))?
.parse()
.ok()
.filter(|p| *p != 0);
let ra_user = take("--ra-user", Some("local"))?;
let job_dir = take("--job-dir", Some(""))?;
let profile_for = |db: &Db, store: &mut Store, server: &str| -> Result<ImportOptions, String> { with_profile(db, store, &opts, &data_dir, ra_port, &ra_user, server) };
let interval: u64 = take("--interval", Some("60"))?.parse().map_err(|_| "--interval is not a number".to_string())?;
let collection_interval: u64 = take("--collection-interval", Some("300"))?.parse().map_err(|_| "--collection-interval is not a number".to_string())?;
let id = |s: &str| -> Result<CharacterId, String> { s.parse().map_err(|_| format!("{s:?} is not a character id")) };
let profile_for = |db: &Db, store: &mut Store, server: &str| -> Result<ImportOptions, String> {
with_profile(db, store, &opts, &data_dir, ra_port, &ra_user, server)
};
let interval: u64 = take("--interval", Some("60"))?
.parse()
.map_err(|_| "--interval is not a number".to_string())?;
let collection_interval: u64 = take("--collection-interval", Some("300"))?
.parse()
.map_err(|_| "--collection-interval is not a number".to_string())?;
let id = |s: &str| -> Result<CharacterId, String> {
s.parse()
.map_err(|_| format!("{s:?} is not a character id"))
};
let command = if args.is_empty() { usage() } else { args.remove(0) };
let command = if args.is_empty() {
usage()
} else {
args.remove(0)
};
match (command.as_str(), args.as_slice()) {
("list", []) => {
for c in realm::inspect_characters(&db).map_err(|e| e.to_string())? {
println!("{}\t{}\tlevel {}\trace {} class {}\t{}", c.local_guid, c.name, c.level, c.race, c.class, if c.eligible() { "ok".to_string() } else { c.blockers.iter().map(|b| b.to_string()).collect::<Vec<_>>().join("; ") });
println!(
"{}\t{}\tlevel {}\trace {} class {}\t{}",
c.local_guid,
c.name,
c.level,
c.race,
c.class,
if c.eligible() {
"ok".to_string()
} else {
c.blockers
.iter()
.map(|b| b.to_string())
.collect::<Vec<_>>()
.join("; ")
}
);
}
}
("make-portable", [server, guid]) => {
let profile = store.default_profile().map_err(|e| e.to_string())?;
let made = realm::make_portable(&db, &mut store, profile, server, guid.parse().map_err(|_| "guid")?).map_err(|e| e.to_string())?;
println!("portable character {} (revision {}) {}", made.character_id, made.revision, made.warnings.join("; "));
let made = realm::make_portable(
&db,
&mut store,
profile,
server,
guid.parse().map_err(|_| "guid")?,
)
.map_err(|e| e.to_string())?;
println!(
"portable character {} (revision {}) {}",
made.character_id,
made.revision,
made.warnings.join("; ")
);
}
("import", [character, server, account]) => {
let opts = profile_for(&db, &mut store, server)?;
let o = realm::import_character(&db, &mut store, id(character)?, server, account.parse().map_err(|_| "account")?, &opts).map_err(|e| e.to_string())?;
let o = realm::import_character(
&db,
&mut store,
id(character)?,
server,
account.parse().map_err(|_| "account")?,
&opts,
)
.map_err(|e| e.to_string())?;
for line in &o.not_applied {
println!(" not applied: {line}");
}
println!("imported as local character {} \"{}\" ({} items, {} pets, renamed: {})", o.local_guid, o.final_name, o.items, o.pets, o.renamed);
println!(
"imported as local character {} \"{}\" ({} items, {} pets, renamed: {})",
o.local_guid, o.final_name, o.items, o.pets, o.renamed
);
}
("begin-session", [character, server]) => {
let s = realm::begin_session(&db, &mut store, id(character)?, server).map_err(|e| e.to_string())?;
let s = realm::begin_session(&db, &mut store, id(character)?, server)
.map_err(|e| e.to_string())?;
println!("baseline captured at canonical revision {}: {} item(s) held back by the realm, {} of its own", s.c0_revision, s.items_filtered, s.items_realm_local);
}
("reconcile", [character, server, rest @ ..]) => {
let close = rest.iter().any(|a| a == "--close");
let o = realm::reconcile_session(&db, &mut store, id(character)?, server, close, Some("portable_smoke")).map_err(|e| e.to_string())?;
println!("canonical revision {}{}", o.revision, if o.new_revision { " (new)" } else { " (unchanged)" });
let o = realm::reconcile_session(
&db,
&mut store,
id(character)?,
server,
close,
Some("portable_smoke"),
)
.map_err(|e| e.to_string())?;
println!(
"canonical revision {}{}",
o.revision,
if o.new_revision {
" (new)"
} else {
" (unchanged)"
}
);
for c in o.changes {
println!(" {c}");
}
}
("update", [character, server]) => {
let opts = profile_for(&db, &mut store, server)?;
let o = realm::update_realm_character(&db, &mut store, id(character)?, server, &opts).map_err(|e| e.to_string())?;
let o = realm::update_realm_character(&db, &mut store, id(character)?, server, &opts)
.map_err(|e| e.to_string())?;
for line in &o.warnings {
println!(" {line}");
}
println!("{} (revision {} -> {}): {:?}", if o.updated { "updated in place" } else { "already up to date" }, o.from_revision, o.to_revision, o.counts);
println!(
"{} (revision {} -> {}): {:?}",
if o.updated {
"updated in place"
} else {
"already up to date"
},
o.from_revision,
o.to_revision,
o.counts
);
}
("recover", [server]) => {
for r in realm::recover_imports(&db, &mut store, server, &opts).map_err(|e| e.to_string())? {
for r in
realm::recover_imports(&db, &mut store, server, &opts).map_err(|e| e.to_string())?
{
println!("{}: {:?}", r.import_id, r.resolution);
}
}
("session-offer", [character, server, out]) => {
let offer = OwnerService::new(&mut store).offer(id(character)?, server).map_err(|e| e.to_string())?;
std::fs::write(out, serde_json::to_vec_pretty(&offer).map_err(|e| e.to_string())?).map_err(|e| e.to_string())?;
println!("session {} offered at canonical revision {} -> {out}", offer.session_id, offer.canonical_revision);
let offer = OwnerService::new(&mut store)
.offer(id(character)?, server)
.map_err(|e| e.to_string())?;
std::fs::write(
out,
serde_json::to_vec_pretty(&offer).map_err(|e| e.to_string())?,
)
.map_err(|e| e.to_string())?;
println!(
"session {} offered at canonical revision {} -> {out}",
offer.session_id, offer.canonical_revision
);
}
("session-import", [file, account, server]) => {
let offer: SessionOffer = serde_json::from_slice(&std::fs::read(file).map_err(|e| e.to_string())?).map_err(|e| e.to_string())?;
let offer: SessionOffer =
serde_json::from_slice(&std::fs::read(file).map_err(|e| e.to_string())?)
.map_err(|e| e.to_string())?;
let mut host = Store::open(&host_dir).map_err(|e| e.to_string())?;
let profile = host.default_profile().map_err(|e| e.to_string())?;
HostService::new(&mut host, server, HostConfig::default()).accept_offer(profile, &offer).map_err(|e| e.to_string())?;
HostService::new(&mut host, server, HostConfig::default())
.accept_offer(profile, &offer)
.map_err(|e| e.to_string())?;
let account: u32 = account.parse().map_err(|_| "account")?;
let opts = with_profile(&db, &mut host, &opts, &data_dir, ra_port, &ra_user, server)?;
let outcome = match (ra_port, job_dir.is_empty()) {
(Some(port), false) => {
let mut ra = coa_core::ra::Ra::connect_to(port, &ra_user, &std::env::var("COA_RA_PASSWORD").map_err(|_| "set COA_RA_PASSWORD".to_string())?).map_err(|e| e.to_string())?;
realm::online::import_character_online(&mut ra, &mut host, offer.character_id, server, account, &opts, std::path::Path::new(&job_dir), Some(offer.session_id)).map_err(|e| e.to_string())?
let mut ra = coa_core::ra::Ra::connect_to(
port,
&ra_user,
&std::env::var("COA_RA_PASSWORD")
.map_err(|_| "set COA_RA_PASSWORD".to_string())?,
)
.map_err(|e| e.to_string())?;
realm::online::import_character_online(
&mut ra,
&mut host,
offer.character_id,
server,
account,
&opts,
std::path::Path::new(&job_dir),
Some(offer.session_id),
)
.map_err(|e| e.to_string())?
}
_ => realm::import_character_in_session(&db, &mut host, offer.character_id, server, account, &opts, Some(offer.session_id)).map_err(|e| e.to_string())?,
_ => realm::import_character_in_session(
&db,
&mut host,
offer.character_id,
server,
account,
&opts,
Some(offer.session_id),
)
.map_err(|e| e.to_string())?,
};
HostService::new(&mut host, server, HostConfig::default()).bind(offer.session_id, outcome.local_guid).map_err(|e| e.to_string())?;
HostService::new(&mut host, server, HostConfig::default())
.bind(offer.session_id, outcome.local_guid)
.map_err(|e| e.to_string())?;
println!("imported as local character {} \"{}\"; session {} is armed: the realm takes the baseline at its first load", outcome.local_guid, outcome.final_name, offer.session_id);
}
("host-run", [owner_dir, server]) => {
let mut owner = Store::open(&PathBuf::from(owner_dir)).map_err(|e| e.to_string())?;
let mut host = Store::open(&host_dir).map_err(|e| e.to_string())?;
let mut service = HostService::new(&mut host, server, HostConfig { checkpoint_interval_secs: interval, collection_interval_secs: collection_interval });
let mut service = HostService::new(
&mut host,
server,
HostConfig {
checkpoint_interval_secs: interval,
collection_interval_secs: collection_interval,
},
);
let start = std::time::Instant::now();
println!("host running for {server}; Ctrl-C to stop");
loop {
let ra = ra_port.and_then(|port| std::env::var("COA_RA_PASSWORD").ok().and_then(|pw| coa_core::ra::Ra::connect_to(port, &ra_user, &pw).ok()));
let ra = ra_port.and_then(|port| {
std::env::var("COA_RA_PASSWORD")
.ok()
.and_then(|pw| coa_core::ra::Ra::connect_to(port, &ra_user, &pw).ok())
});
let mut bridge = match ra {
Some(ra) => LiveBridge::new(&db, ra),
None => LiveBridge::without_console(&db),
@@ -216,10 +419,17 @@ fn run() -> Result<(), String> {
Err(e) => eprintln!("tick failed: {e}"),
}
for m in service.outbox().map_err(|e| e.to_string())? {
let ack = if m.started { OwnerService::new(&mut owner).handle_started(&m.bytes) } else { OwnerService::new(&mut owner).handle_checkpoint(&m.bytes) };
let ack = if m.started {
OwnerService::new(&mut owner).handle_started(&m.bytes)
} else {
OwnerService::new(&mut owner).handle_checkpoint(&m.bytes)
};
match ack {
Ok(ack) => {
println!("owner: session {} #{}: {:?} (canonical revision {})", ack.session_id, ack.sequence, ack.outcome, ack.canonical_revision);
println!(
"owner: session {} #{}: {:?} (canonical revision {})",
ack.session_id, ack.sequence, ack.outcome, ack.canonical_revision
);
if let Err(e) = service.receive_ack(&mut bridge, &ack) {
eprintln!("acknowledgement failed: {e}");
}
@@ -232,7 +442,9 @@ fn run() -> Result<(), String> {
Ok(ack) => {
println!("owner: {} of account {}: {:?} (collection revision {}, canonical sent back: {})", ack.kind, m.account, ack.outcome, ack.collection_revision, ack.canonical.is_some());
match service.receive_collection_ack(&mut bridge, m.account, &ack) {
Ok(Some(applied)) => println!("host: applied to the realm: {applied:?}"),
Ok(Some(applied)) => {
println!("host: applied to the realm: {applied:?}")
}
Ok(None) => {}
Err(e) => eprintln!("collection acknowledgement failed: {e}"),
}
@@ -244,59 +456,135 @@ fn run() -> Result<(), String> {
}
}
("collection-states", [out]) => {
let states = OwnerService::new(&mut store).collection_states().map_err(|e| e.to_string())?;
let states = OwnerService::new(&mut store)
.collection_states()
.map_err(|e| e.to_string())?;
for s in &states {
println!("{}: revision {}, {} ids", s.kind, s.collection_revision, s.set.count);
println!(
"{}: revision {}, {} ids",
s.kind, s.collection_revision, s.set.count
);
}
std::fs::write(out, serde_json::to_vec(&states).map_err(|e| e.to_string())?).map_err(|e| e.to_string())?;
std::fs::write(out, serde_json::to_vec(&states).map_err(|e| e.to_string())?)
.map_err(|e| e.to_string())?;
}
("collection-apply", [file, account, server]) => {
let states: Vec<coa_core::portable::session::protocol::CollectionState> = serde_json::from_slice(&std::fs::read(file).map_err(|e| e.to_string())?).map_err(|e| e.to_string())?;
let states: Vec<coa_core::portable::session::protocol::CollectionState> =
serde_json::from_slice(&std::fs::read(file).map_err(|e| e.to_string())?)
.map_err(|e| e.to_string())?;
let account: u32 = account.parse().map_err(|_| "account")?;
let mut host = Store::open(&host_dir).map_err(|e| e.to_string())?;
let mut bridge = LiveBridge::without_console(&db).with_knowledge(knowledge.clone());
let mut service = HostService::new(&mut host, server, HostConfig::default());
for state in &states {
let applied = service.receive_collection_state(&mut bridge, account, state).map_err(|e| e.to_string())?;
let applied = service
.receive_collection_state(&mut bridge, account, state)
.map_err(|e| e.to_string())?;
println!("{}: {:?}", state.kind, applied);
}
}
("capabilities", [server]) => {
let caps = profile_for(&db, &mut store, server)?.capabilities.ok_or("give --data-dir to read the realm's client data")?;
println!("{}", serde_json::to_string_pretty(&*caps).map_err(|e| e.to_string())?);
let caps = profile_for(&db, &mut store, server)?
.capabilities
.ok_or("give --data-dir to read the realm's client data")?;
println!(
"{}",
serde_json::to_string_pretty(&*caps).map_err(|e| e.to_string())?
);
}
("preflight", [character, server, rest @ ..]) => {
let opts = profile_for(&db, &mut store, server)?;
let caps = opts.capabilities.clone().ok_or("give --data-dir to read the realm's client data")?;
let model = store.load_current(id(character)?).map_err(|e| e.to_string())?;
let caps = opts
.capabilities
.clone()
.ok_or("give --data-dir to read the realm's client data")?;
let model = store
.load_current(id(character)?)
.map_err(|e| e.to_string())?;
let operation = match rest.first().map(String::as_str) {
Some("online") => coa_core::portable::compat::Operation::OnlineImport,
Some("session") => coa_core::portable::compat::Operation::RuntimeSession,
_ if store.server_mappings(model.character_id).map_err(|e| e.to_string())?.iter().any(|m| &m.server_id == server) => coa_core::portable::compat::Operation::Update,
_ if store
.server_mappings(model.character_id)
.map_err(|e| e.to_string())?
.iter()
.any(|m| &m.server_id == server) =>
{
coa_core::portable::compat::Operation::Update
}
_ => coa_core::portable::compat::Operation::OfflineImport,
};
let report = coa_core::portable::compat::evaluate(&coa_core::portable::compat::Inputs { operation, model: &model, capabilities: &caps, knowledge: opts.knowledge.as_deref(), collections: &[], extensions: opts.extensions.as_deref(), projection_decider: opts.projection.is_some() || matches!(operation, coa_core::portable::compat::Operation::OnlineImport | coa_core::portable::compat::Operation::RuntimeSession) && ra_port.is_some() });
println!("{} on {server} (content profile {}): {:?}", report.operation, &caps.content_profile_hash[..16], report.verdict());
let report =
coa_core::portable::compat::evaluate(&coa_core::portable::compat::Inputs {
operation,
model: &model,
capabilities: &caps,
knowledge: opts.knowledge.as_deref(),
collections: &[],
extensions: opts.extensions.as_deref(),
projection_decider: opts.projection.is_some()
|| matches!(
operation,
coa_core::portable::compat::Operation::OnlineImport
| coa_core::portable::compat::Operation::RuntimeSession
) && ra_port.is_some(),
});
println!(
"{} on {server} (content profile {}): {:?}",
report.operation,
&caps.content_profile_hash[..16],
report.verdict()
);
for o in &report.outcomes {
println!(" {o}");
}
}
("project", [character, server]) => {
let port = ra_port.ok_or("give --ra-port: only a running core can say what a projection holds")?;
let port = ra_port
.ok_or("give --ra-port: only a running core can say what a projection holds")?;
if job_dir.is_empty() {
return Err("give --job-dir (the core's PortableImport.JobDir)".into());
}
let opts = profile_for(&db, &mut store, server)?;
let canonical = store.load_current(id(character)?).map_err(|e| e.to_string())?;
let mut ra = coa_core::ra::Ra::connect_to(port, &ra_user, &std::env::var("COA_RA_PASSWORD").map_err(|_| "set COA_RA_PASSWORD".to_string())?).map_err(|e| e.to_string())?;
let progression = opts.capabilities.as_ref().and_then(|c| c.progression.clone());
match realm::project::decide_with_core(&mut ra, std::path::Path::new(&job_dir), &canonical).map_err(|e| e.to_string())? {
coa_core::portable::projection::Decision::Native => println!("not projected: level {} is within the realm's cap {}", canonical.progression.level, progression.map_or("?".to_string(), |p| p.max_player_level.to_string())),
let canonical = store
.load_current(id(character)?)
.map_err(|e| e.to_string())?;
let mut ra = coa_core::ra::Ra::connect_to(
port,
&ra_user,
&std::env::var("COA_RA_PASSWORD").map_err(|_| "set COA_RA_PASSWORD".to_string())?,
)
.map_err(|e| e.to_string())?;
let progression = opts
.capabilities
.as_ref()
.and_then(|c| c.progression.clone());
match realm::project::decide_with_core(
&mut ra,
std::path::Path::new(&job_dir),
&canonical,
)
.map_err(|e| e.to_string())?
{
coa_core::portable::projection::Decision::Native => println!(
"not projected: level {} is within the realm's cap {}",
canonical.progression.level,
progression.map_or("?".to_string(), |p| p.max_player_level.to_string())
),
coa_core::portable::projection::Decision::Projected(hold) => {
println!("projected level {} -> {} (signature {})", hold.canonical_level, hold.projected_level, &hold.progression_signature[..16]);
println!(
"projected level {} -> {} (signature {})",
hold.canonical_level,
hold.projected_level,
&hold.progression_signature[..16]
);
println!(" held: {} item(s), {} ability(ies), {} button(s), {} build record(s) edited, {} blocked", hold.held_items.len(), hold.held_spells.len(), hold.held_actions.len(), hold.settings.iter().filter(|s| !s.entries.is_empty() || !s.buttons.is_empty()).count(), hold.blocked_settings.len());
if !out_file.is_empty() {
std::fs::write(&out_file, serde_json::to_vec_pretty(&hold).map_err(|e| e.to_string())?).map_err(|e| e.to_string())?;
std::fs::write(
&out_file,
serde_json::to_vec_pretty(&hold).map_err(|e| e.to_string())?,
)
.map_err(|e| e.to_string())?;
println!(" decision written to {out_file}");
}
}
@@ -304,11 +592,18 @@ fn run() -> Result<(), String> {
}
("reevaluate", [character, server]) => {
let opts = profile_for(&db, &mut store, server)?;
let r = realm::reevaluate_realm_character(&db, &mut store, id(character)?, server, &opts).map_err(|e| e.to_string())?;
let r =
realm::reevaluate_realm_character(&db, &mut store, id(character)?, server, &opts)
.map_err(|e| e.to_string())?;
if r.profile_unchanged {
println!("the realm's content profile is the one this character was synchronised under: nothing to look at");
} else {
println!("{}", r.update.map(|u| format!("restored: {:?}", u.changes)).unwrap_or_else(|| "nothing new to show on this realm".into()));
println!(
"{}",
r.update
.map(|u| format!("restored: {:?}", u.changes))
.unwrap_or_else(|| "nothing new to show on this realm".into())
);
for e in r.extensions {
println!(" {e}");
}
@@ -316,36 +611,67 @@ fn run() -> Result<(), String> {
}
("collection-add", [kind, ids @ ..]) => {
let profile = store.default_profile().map_err(|e| e.to_string())?;
let ids = ids.iter().map(|i| i.parse::<u32>().map_err(|_| format!("{i:?} is not an id"))).collect::<Result<Vec<_>, _>>()?;
let set = coa_core::portable::collection::IdSet::from_ids(ids).map_err(|e| e.to_string())?;
let merge = store.merge_collection(profile, kind, &set).map_err(|e| e.to_string())?;
println!("{kind}: {} id(s) added{}", merge.added, merge.info.map(|i| format!(", revision {}, {} ids", i.revision, i.count)).unwrap_or_default());
let ids = ids
.iter()
.map(|i| i.parse::<u32>().map_err(|_| format!("{i:?} is not an id")))
.collect::<Result<Vec<_>, _>>()?;
let set =
coa_core::portable::collection::IdSet::from_ids(ids).map_err(|e| e.to_string())?;
let merge = store
.merge_collection(profile, kind, &set)
.map_err(|e| e.to_string())?;
println!(
"{kind}: {} id(s) added{}",
merge.added,
merge
.info
.map(|i| format!(", revision {}, {} ids", i.revision, i.count))
.unwrap_or_default()
);
}
("collection-show", rest) => {
let profile = store.default_profile().map_err(|e| e.to_string())?;
for kind in coa_core::portable::session::protocol::COLLECTION_KINDS {
match store.collection_info(profile, kind).map_err(|e| e.to_string())? {
Some(i) => println!("owner {kind}: revision {}, {} ids, hash {}", i.revision, i.count, hex::encode(&i.hash[..8])),
match store
.collection_info(profile, kind)
.map_err(|e| e.to_string())?
{
Some(i) => println!(
"owner {kind}: revision {}, {} ids, hash {}",
i.revision,
i.count,
hex::encode(&i.hash[..8])
),
None => println!("owner {kind}: none"),
}
if let [account] = rest {
let account: u32 = account.parse().map_err(|_| "account")?;
let set = coa_core::portable::realm::collections::read_set(&db, account, kind).map_err(|e| e.to_string())?;
let set = coa_core::portable::realm::collections::read_set(&db, account, kind)
.map_err(|e| e.to_string())?;
println!("realm {kind} of account {account}: {} ids", set.len());
}
}
}
("dump", [character]) => {
let model = store.load_current(id(character)?).map_err(|e| e.to_string())?;
let json = coa_core::portable::snapshot::canonical_json(&model).map_err(|e| e.to_string())?;
let model = store
.load_current(id(character)?)
.map_err(|e| e.to_string())?;
let json =
coa_core::portable::snapshot::canonical_json(&model).map_err(|e| e.to_string())?;
println!("{}", String::from_utf8_lossy(&json));
}
("show", [character]) => {
let c = id(character)?;
let r = store.character(c).map_err(|e| e.to_string())?;
println!("{} {} level {} revision {}", r.character_id, r.name, r.level, r.revision);
println!(
"{} {} level {} revision {}",
r.character_id, r.name, r.level, r.revision
);
for m in store.server_mappings(c).map_err(|e| e.to_string())? {
println!(" on {}: local guid {} at revision {} ({:?})", m.server_id, m.local_guid, m.last_revision, m.state);
println!(
" on {}: local guid {} at revision {} ({:?})",
m.server_id, m.local_guid, m.last_revision, m.state
);
}
}
_ => usage(),
+6 -1
View File
@@ -1,7 +1,12 @@
//! Create an account through the Manager's RA client on a RUNNING disposable fixture.
fn main() {
let a: Vec<String> = std::env::args().skip(1).collect();
assert!(a[0].to_lowercase().contains("fixture") || a[0].to_lowercase().contains("installtest") || a[0].to_lowercase().contains("cleaninstall"), "refusing: not a disposable folder");
assert!(
a[0].to_lowercase().contains("fixture")
|| a[0].to_lowercase().contains("installtest")
|| a[0].to_lowercase().contains("cleaninstall"),
"refusing: not a disposable folder"
);
let root = std::path::Path::new(&a[0]);
let mut ra = coa_core::ra::Ra::connect(root).expect("connect");
ra.create_account(&a[1], &a[2]).expect("create");
+75 -14
View File
@@ -13,30 +13,69 @@ fn main() -> Result<()> {
let action = args.get(1).map(String::as_str).unwrap_or("view");
match action {
"select" => {
let mode = if args.get(2).map(String::as_str) == Some("wildcard") { Mode::Wildcard } else { Mode::Coa };
let mode = if args.get(2).map(String::as_str) == Some("wildcard") {
Mode::Wildcard
} else {
Mode::Coa
};
println!("{}", serde_json::to_string(&realms::select(root, mode)?)?);
}
"start" | "stop" => {
let out = driver::run(root, if action == "start" { Verb::StartAll } else { Verb::StopAll })?;
let out = driver::run(
root,
if action == "start" {
Verb::StartAll
} else {
Verb::StopAll
},
)?;
println!("{}", serde_json::to_string(&out)?);
if !out.ok { return Err(Error::Invalid("Fixture operation failed".into())); }
if !out.ok {
return Err(Error::Invalid("Fixture operation failed".into()));
}
}
"probe" => {
let db = Db::from_repack(root, Account::Admin)?;
let s = realms::state(root)?;
println!("{}", db.query("SELECT * FROM acore_characters.manager_profile_probe;")?);
println!("active={} chars={} world={}", s.active.name(), s.active.schema("characters")?, s.active.schema("world")?);
println!(
"{}",
db.query("SELECT * FROM acore_characters.manager_profile_probe;")?
);
println!(
"active={} chars={} world={}",
s.active.name(),
s.active.schema("characters")?,
s.active.schema("world")?
);
}
"mark" => {
Db::from_repack(root, Account::Admin)?.query("INSERT INTO acore_characters.manager_profile_probe VALUES (22);")?;
Db::from_repack(root, Account::Admin)?
.query("INSERT INTO acore_characters.manager_profile_probe VALUES (22);")?;
}
"backup" => {
use coa_core::backup::{self, Kind, Trigger};
let meta = root.join("fixture-manager");
let point = backup::create(root, &meta, Kind::Full, Trigger::Manual, Some("realm isolation check".into()), &|step| println!("{step}"))?;
let point = backup::create(
root,
&meta,
Kind::Full,
Trigger::Manual,
Some("realm isolation check".into()),
&|step| println!("{step}"),
)?;
assert_eq!(point.realm, Mode::Wildcard);
for name in ["characters", "world", "auth", "coa-characters", "coa-world", "configs"] {
assert!(point.components.iter().any(|c| c.name == name), "Missing {name}");
for name in [
"characters",
"world",
"auth",
"coa-characters",
"coa-world",
"configs",
] {
assert!(
point.components.iter().any(|c| c.name == name),
"Missing {name}"
);
}
assert!(backup::verify(&meta, &point.id)?.ok);
println!("Verified both realm backups: {}", point.id);
@@ -46,7 +85,10 @@ fn main() -> Result<()> {
use coa_core::manifest::{Manifest, Migration};
use coa_core::update::{Env, RepackEnv};
let meta = root.join("fixture-manager");
let env = RepackEnv { root, meta_dir: &meta };
let env = RepackEnv {
root,
meta_dir: &meta,
};
env.ensure_stopped()?;
let staged = root.join("fixture-migrations");
let mut manifest: Manifest = serde_json::from_value(serde_json::json!({
@@ -58,7 +100,13 @@ 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 { compatible_sha256: vec![], 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());
@@ -66,7 +114,12 @@ fn main() -> Result<()> {
for mode in [Mode::Coa, Mode::Wildcard] {
let realm = db.clone().for_realm(mode);
for kind in ["characters", "world", "auth"] {
assert_eq!(realm.query(&format!("SELECT COUNT(*) FROM acore_{kind}.manager_migration_probe;"))?, "1");
assert_eq!(
realm.query(&format!(
"SELECT COUNT(*) FROM acore_{kind}.manager_migration_probe;"
))?,
"1"
);
}
}
Ok(())
@@ -79,8 +132,16 @@ fn main() -> Result<()> {
})?;
backup::restore_database(root, &meta, &point.id, "characters")?;
backup::with_database(root, |db| {
assert_eq!(db.query("SELECT COUNT(*) FROM acore_characters.manager_profile_probe;")?, "0");
assert_eq!(db.clone().for_realm(Mode::Coa).query("SELECT value FROM acore_characters.manager_profile_probe;")?, "11");
assert_eq!(
db.query("SELECT COUNT(*) FROM acore_characters.manager_profile_probe;")?,
"0"
);
assert_eq!(
db.clone()
.for_realm(Mode::Coa)
.query("SELECT value FROM acore_characters.manager_profile_probe;")?,
"11"
);
Ok(())
})?;
println!("Both realms migrated once; shared auth migrated once; Wildcard restore left CoA intact.");
+89 -14
View File
@@ -1,12 +1,29 @@
//! Signed-package repair smoke test. Only a disposable fixture may be used.
use std::path::PathBuf;
use base64::{engine::general_purpose::STANDARD, Engine};
use coa_core::{
fsx,
manifest::{Kind, Migration},
package::{self, BuildOptions},
pkgsource::Source,
realms::Mode,
registry::{metadata_dir_for, InstallKind, InstallMeta, MetaDir},
Error, Result,
};
use ed25519_dalek::{Signer, SigningKey};
use coa_core::{Result, Error, fsx, package::{self, BuildOptions}, manifest::{Kind, Migration}, registry::{InstallKind, InstallMeta, MetaDir, metadata_dir_for}, pkgsource::Source, realms::Mode};
use std::path::PathBuf;
fn main() -> Result<()> {
let root = PathBuf::from(std::env::args().nth(1).ok_or_else(|| Error::Invalid("fixture path required".into()))?);
if !root.file_name().is_some_and(|n| n.to_string_lossy().contains("fixture")) { return Err(Error::Invalid("Refusing a non-fixture server.".into())); }
let root = PathBuf::from(
std::env::args()
.nth(1)
.ok_or_else(|| Error::Invalid("fixture path required".into()))?,
);
if !root
.file_name()
.is_some_and(|n| n.to_string_lossy().contains("fixture"))
{
return Err(Error::Invalid("Refusing a non-fixture server.".into()));
}
let work = tempfile::tempdir()?;
let base_tree = work.path().join("base-tree");
let update_tree = work.path().join("update-tree");
@@ -17,15 +34,54 @@ fn main() -> Result<()> {
fsx::atomic_write(&update_tree.join(probe), b"correct official file")?;
let sql = "CREATE TABLE IF NOT EXISTS acore_world.manager_repair_probe (id INT PRIMARY KEY); INSERT IGNORE INTO acore_world.manager_repair_probe VALUES (42);";
let id = "20261004_repair_e2e";
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 { compatible_sha256: vec![], id: id.into(), db: "world".into(), sha256: fsx::sha256_bytes(sql.as_bytes()), destructive: false }]), &|_| {})?;
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 {
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());
for pkg in [&base_pkg, &update_pkg] {
fsx::atomic_write(&pkg.join("manifest.json.sig"), STANDARD.encode(key.sign(&std::fs::read(pkg.join("manifest.json"))?).to_bytes()).as_bytes())?;
fsx::atomic_write(
&pkg.join("manifest.json.sig"),
STANDARD
.encode(
key.sign(&std::fs::read(pkg.join("manifest.json"))?)
.to_bytes(),
)
.as_bytes(),
)?;
}
let dir = metadata_dir_for(&root)?;
let mut meta = InstallMeta::new(InstallKind::New, &root);
@@ -35,24 +91,43 @@ fn main() -> Result<()> {
fsx::atomic_write_json(&dir.join("manifests/update-1.0.1.json"), &update)?;
fsx::atomic_write(&root.join(probe), b"corrupted")?;
let settings = std::fs::read(root.join("Settings/repack.json"))?;
let counts = coa_core::backup::with_database(&root, |db| db.query("SELECT COUNT(*) FROM acore_auth.account; SELECT COUNT(*) FROM acore_characters.characters; SELECT COUNT(*) FROM acore_characters_wildcard.characters;"))?;
let report = coa_core::repair::run(&root, &dir, &Source::Dir(base_pkg), &Source::Dir(update_pkg), &public, &|s,p| println!("{p}% {s}"))?;
let counts = coa_core::backup::with_database(&root, |db| {
db.query("SELECT COUNT(*) FROM acore_auth.account; SELECT COUNT(*) FROM acore_characters.characters; SELECT COUNT(*) FROM acore_characters_wildcard.characters;")
})?;
let report = coa_core::repair::run(
&root,
&dir,
&Source::Dir(base_pkg),
&Source::Dir(update_pkg),
&public,
&|s, p| println!("{p}% {s}"),
)?;
assert_eq!(std::fs::read(root.join(probe))?, b"correct official file");
assert!(report.error.is_none(), "{:?}", report.error);
assert_eq!(report.applied.len(), 2, "Migration must run in both worlds");
assert!(report.database.iter().all(|d| d.problems.is_empty() && d.migrations.iter().all(|m| m.status == coa_core::migrations::Status::Applied)));
assert!(report.database.iter().all(|d| d.problems.is_empty()
&& d.migrations
.iter()
.all(|m| m.status == coa_core::migrations::Status::Applied)));
assert_eq!(std::fs::read(root.join("Settings/repack.json"))?, settings);
assert!(coa_core::backup::verify(&dir, &report.backup)?.ok);
coa_core::backup::with_database(&root, |db| {
assert_eq!(db.query("SELECT COUNT(*) FROM acore_auth.account; SELECT COUNT(*) FROM acore_characters.characters; SELECT COUNT(*) FROM acore_characters_wildcard.characters;")?, counts);
for mode in [Mode::Coa, Mode::Wildcard] {
assert_eq!(db.clone().for_realm(mode).query("SELECT id FROM acore_world.manager_repair_probe;")?, "42");
assert_eq!(
db.clone()
.for_realm(mode)
.query("SELECT id FROM acore_world.manager_repair_probe;")?,
"42"
);
}
// Corrupt only the second realm, proving that checks read its actual schema.
let wildcard = db.clone().for_realm(Mode::Wildcard);
wildcard.query("ALTER TABLE acore_characters.character_action DROP COLUMN type;")?;
let problems = coa_core::schema_check::check(&wildcard, &root)?;
assert!(problems.iter().any(|p| p.table == "character_action" && p.column == "type"));
assert!(problems
.iter()
.any(|p| p.table == "character_action" && p.column == "type"));
assert!(coa_core::schema_check::check(&db.clone().for_realm(Mode::Coa), &root)?.is_empty());
wildcard.query("ALTER TABLE acore_characters.character_action ADD COLUMN type TINYINT UNSIGNED NOT NULL DEFAULT 0;")?;
Ok(())
+7 -2
View File
@@ -3,7 +3,10 @@ fn main() {
let url = std::env::args().nth(1).unwrap();
let mode = std::env::args().nth(2).unwrap();
let t = std::time::Instant::now();
let client = reqwest::blocking::Client::builder().timeout(None::<std::time::Duration>).build().unwrap();
let client = reqwest::blocking::Client::builder()
.timeout(None::<std::time::Duration>)
.build()
.unwrap();
let mut resp = client.get(&url).send().unwrap();
if mode == "bytes" {
let b = resp.bytes().unwrap();
@@ -13,7 +16,9 @@ fn main() {
let mut total = 0;
loop {
let n = resp.read(&mut buf).unwrap();
if n == 0 { break; }
if n == 0 {
break;
}
total += n;
}
println!("read loop {} in {:?}", total, t.elapsed());
+3 -1
View File
@@ -1,7 +1,9 @@
use std::path::Path;
fn main() {
let path = std::env::args().nth(1).expect("usage: scan <server folder>");
let path = std::env::args()
.nth(1)
.expect("usage: scan <server folder>");
let root = Path::new(&path);
let report = coa_core::layout::scan(root).expect("scan failed");
println!("{}", serde_json::to_string_pretty(&report).unwrap());
+17 -5
View File
@@ -1,9 +1,18 @@
//! Check full schema contracts and blocking custom columns, only against a disposable fixture.
use coa_core::{Result, Error, backup, schema_check, realms::Mode};
use coa_core::{backup, realms::Mode, schema_check, Error, Result};
use std::path::PathBuf;
fn main() -> Result<()> {
let root = PathBuf::from(std::env::args().nth(1).ok_or_else(|| Error::Invalid("fixture path required".into()))?);
if !root.file_name().is_some_and(|n| n.to_string_lossy().contains("fixture")) { return Err(Error::Invalid("Refusing a non-fixture server.".into())); }
let root = PathBuf::from(
std::env::args()
.nth(1)
.ok_or_else(|| Error::Invalid("fixture path required".into()))?,
);
if !root
.file_name()
.is_some_and(|n| n.to_string_lossy().contains("fixture"))
{
return Err(Error::Invalid("Refusing a non-fixture server.".into()));
}
backup::with_database(&root, |db| {
let coa = db.clone().for_realm(Mode::Coa);
let wildcard = db.clone().for_realm(Mode::Wildcard);
@@ -14,11 +23,14 @@ fn main() -> Result<()> {
assert!(schema_check::check(&coa, reference.path())?.is_empty());
wildcard.query("ALTER TABLE acore_characters.character_action ADD COLUMN manager_required INT NOT NULL;")?;
let result = (|| {
assert!(schema_check::check(&wildcard, &root)?.iter().any(|p| p.table == "character_action" && p.column == "manager_required"));
assert!(schema_check::check(&wildcard, &root)?
.iter()
.any(|p| p.table == "character_action" && p.column == "manager_required"));
assert!(schema_check::check(&coa, &root)?.is_empty());
Ok(())
})();
wildcard.query("ALTER TABLE acore_characters.character_action DROP COLUMN manager_required;")?;
wildcard
.query("ALTER TABLE acore_characters.character_action DROP COLUMN manager_required;")?;
result
})?;
println!("Full schema contract and a blocking NOT NULL column verified; second-realm corruption does not affect CoA checks.");
+16 -3
View File
@@ -9,13 +9,26 @@ fn main() {
let seed_b64 = match std::env::var("COA_SIGNING_KEY") {
Ok(v) => v,
Err(_) => {
let path = a.next().unwrap_or_else(|| format!("{}/.coa-manager/signing/manifest-signing.key", std::env::var("USERPROFILE").unwrap()));
let path = a.next().unwrap_or_else(|| {
format!(
"{}/.coa-manager/signing/manifest-signing.key",
std::env::var("USERPROFILE").unwrap()
)
});
fs::read_to_string(path).expect("cannot read signing key")
}
};
let seed: [u8; 32] = STANDARD.decode(seed_b64.trim()).unwrap().try_into().expect("key length");
let seed: [u8; 32] = STANDARD
.decode(seed_b64.trim())
.unwrap()
.try_into()
.expect("key length");
let bytes = fs::read(&manifest).unwrap();
let sig = SigningKey::from_bytes(&seed).sign(&bytes);
fs::write(format!("{manifest}.sig"), format!("{}\n", STANDARD.encode(sig.to_bytes()))).unwrap();
fs::write(
format!("{manifest}.sig"),
format!("{}\n", STANDARD.encode(sig.to_bytes())),
)
.unwrap();
println!("signed {manifest}");
}
+4 -1
View File
@@ -1,7 +1,10 @@
//! Read-only helper for a DISPOSABLE fixture: run one query. usage: sqlq <fixture> <sql>
fn main() {
let a: Vec<String> = std::env::args().skip(1).collect();
assert!(a[0].to_lowercase().contains("fixture"), "refusing: not a fixture folder");
assert!(
a[0].to_lowercase().contains("fixture"),
"refusing: not a fixture folder"
);
let root = std::path::Path::new(&a[0]);
let out = coa_core::backup::with_database(root, |db| db.query(&a[1])).expect("query");
println!("{out}");
+91 -16
View File
@@ -19,7 +19,10 @@ fn put(root: &std::path::Path, rel: &str, body: &str) {
fn main() {
let root = PathBuf::from(std::env::args().nth(1).expect("fixture folder"));
assert!(root.to_string_lossy().to_lowercase().contains("fixture"), "refusing: not a fixture folder");
assert!(
root.to_string_lossy().to_lowercase().contains("fixture"),
"refusing: not a fixture folder"
);
let meta_dir = metadata_dir_for(&root).unwrap();
if !meta_dir.join("install.json").is_file() {
MetaDir::create(&root, &InstallMeta::new(InstallKind::Imported, &root)).unwrap();
@@ -28,33 +31,105 @@ fn main() {
let work = std::env::temp_dir().join("coa-update-e2e");
let _ = std::fs::remove_dir_all(&work);
let (src, pkg) = (work.join("src"), work.join("pkg"));
put(&src, "Core/reference/update-e2e.txt", "shipped by the update\n");
put(&src, "Settings/worldserver.conf.template", "[worldserver]\nUpdateE2E.NewSetting = 7\n");
put(
&src,
"Core/reference/update-e2e.txt",
"shipped by the update\n",
);
put(
&src,
"Settings/worldserver.conf.template",
"[worldserver]\nUpdateE2E.NewSetting = 7\n",
);
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 { 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();
let sig = SigningKey::from_bytes(&seed).sign(&std::fs::read(pkg.join("manifest.json")).unwrap());
std::fs::write(pkg.join("manifest.json.sig"), STANDARD.encode(sig.to_bytes())).unwrap();
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 {
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();
let sig =
SigningKey::from_bytes(&seed).sign(&std::fs::read(pkg.join("manifest.json")).unwrap());
std::fs::write(
pkg.join("manifest.json.sig"),
STANDARD.encode(sig.to_bytes()),
)
.unwrap();
let template_before = std::fs::read(root.join("Settings/worldserver.conf.template")).unwrap();
let env = RepackEnv { root: &root, meta_dir: &meta_dir };
let env = RepackEnv {
root: &root,
meta_dir: &meta_dir,
};
let t = std::time::Instant::now();
let out = apply(
&Params { root: &root, meta_dir: &meta_dir, source: Source::Dir(pkg), trusted_key: coa_core::signing::EMBEDDED_PUBLIC_KEY, cancel: Cancel::default(), resolutions: Default::default(), env: &env, fail_after_ops: None },
&Params {
root: &root,
meta_dir: &meta_dir,
source: Source::Dir(pkg),
trusted_key: coa_core::signing::EMBEDDED_PUBLIC_KEY,
cancel: Cancel::default(),
resolutions: Default::default(),
env: &env,
fail_after_ops: None,
},
&|s, p| eprintln!(" {p:>3}% {s}"),
)
.expect("update");
println!("update {:?} in {:?}; recovery point {:?}; migrations {:?}", out.txn.state, t.elapsed(), out.txn.recovery_point, out.migrations.as_ref().map(|r| &r.applied));
println!(
"update {:?} in {:?}; recovery point {:?}; migrations {:?}",
out.txn.state,
t.elapsed(),
out.txn.recovery_point,
out.migrations.as_ref().map(|r| &r.applied)
);
let tpl = std::fs::read_to_string(root.join("Settings/worldserver.conf.template")).unwrap();
assert!(tpl.contains("UpdateE2E.NewSetting = 7"), "new key merged");
assert!(tpl.len() > template_before.len() && tpl.starts_with(&String::from_utf8_lossy(&template_before).into_owned()), "existing template content untouched, key appended");
assert_eq!(std::fs::read_to_string(root.join("Core/reference/update-e2e.txt")).unwrap(), "shipped by the update\n");
let n = backup::with_database(&root, |db| db.query("SELECT COUNT(*) FROM acore_world.coa_manager_update_test;")).unwrap();
assert!(
tpl.len() > template_before.len()
&& tpl.starts_with(&String::from_utf8_lossy(&template_before).into_owned()),
"existing template content untouched, key appended"
);
assert_eq!(
std::fs::read_to_string(root.join("Core/reference/update-e2e.txt")).unwrap(),
"shipped by the update\n"
);
let n = backup::with_database(&root, |db| {
db.query("SELECT COUNT(*) FROM acore_world.coa_manager_update_test;")
})
.unwrap();
assert_eq!(n, "1", "the migration ran");
println!("OK: files, merge, migration and health check verified");
}
+109 -28
View File
@@ -1,18 +1,39 @@
//! Failure injection on a NEW disposable fixture created by tools/make-fixture.ps1.
//! Uses real MySQL dumps, SQL execution, signed packages and update rollback.
use std::{collections::BTreeMap, path::{Path, PathBuf}};
use coa_core::{backup, db::{Account, Db}, download::Cancel, driver::{self, Verb}, fsx,
manifest::{Kind, Migration}, package::{self, BuildOptions}, pkgsource::Source,
registry::{InstallKind, InstallMeta, MetaDir},
update::{self, Env, RepackEnv}, Error, Result};
use base64::Engine;
use coa_core::{
backup,
db::{Account, Db},
download::Cancel,
driver::{self, Verb},
fsx,
manifest::{Kind, Migration},
package::{self, BuildOptions},
pkgsource::Source,
registry::{InstallKind, InstallMeta, MetaDir},
update::{self, Env, RepackEnv},
Error, Result,
};
use ed25519_dalek::{Signer, SigningKey};
use std::{
collections::BTreeMap,
path::{Path, PathBuf},
};
fn main() -> Result<()> {
let arg = std::env::args().nth(1).expect("usage: update_recovery_e2e <new fixture>");
let arg = std::env::args()
.nth(1)
.expect("usage: update_recovery_e2e <new fixture>");
let root = PathBuf::from(arg);
assert!(root.file_name().unwrap().to_string_lossy().starts_with("coa-update-recovery-fixture-"));
assert!(!root.join("recovery-e2e-started").exists(), "Use a new fixture; never reuse an owned server");
assert!(root
.file_name()
.unwrap()
.to_string_lossy()
.starts_with("coa-update-recovery-fixture-"));
assert!(
!root.join("recovery-e2e-started").exists(),
"Use a new fixture; never reuse an owned server"
);
fsx::atomic_write(&root.join("recovery-e2e-started"), b"disposable fixture")?;
let result = exercise(&root);
let stopped = driver::run(&root, Verb::StopAll)?;
@@ -33,41 +54,101 @@ fn exercise(root: &Path) -> Result<()> {
fsx::atomic_write(&source.join("Core/recovery-probe.txt"), b"updated")?;
let mut migrations = Vec::new();
for (db, id, sql) in [
("characters", "probe_chars", "UPDATE manager_recovery_probe SET id=999;"),
("world", "probe_world", "DROP TABLE manager_recovery_probe; THIS IS INTENTIONALLY INVALID SQL;"),
(
"characters",
"probe_chars",
"UPDATE manager_recovery_probe SET id=999;",
),
(
"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 { compatible_sha256: vec![], db: db.into(), id: id.into(), sha256: fsx::sha256_bytes(sql.as_bytes()), destructive: false });
fsx::atomic_write(
&source.join(format!("_migrations/{db}/{id}.sql")),
sql.as_bytes(),
)?;
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 {
kind: Kind::Update, version: "2.0.0".into(), core_commit: None, bots_commit: None,
built_at: "fixture".into(), part_size: 1 << 20, migrations,
}, &|_| {})?;
let manifest = package::build(
&source,
&pkg,
&BuildOptions {
kind: Kind::Update,
version: "2.0.0".into(),
core_commit: None,
bots_commit: None,
built_at: "fixture".into(),
part_size: 1 << 20,
migrations,
},
&|_| {},
)?;
let key = SigningKey::generate(&mut rand_core::OsRng);
let signature = base64::engine::general_purpose::STANDARD.encode(key.sign(&std::fs::read(pkg.join("manifest.json"))?).to_bytes());
let signature = base64::engine::general_purpose::STANDARD.encode(
key.sign(&std::fs::read(pkg.join("manifest.json"))?)
.to_bytes(),
);
fsx::atomic_write(&pkg.join("manifest.json.sig"), signature.as_bytes())?;
let trusted = base64::engine::general_purpose::STANDARD.encode(key.verifying_key().to_bytes());
let env = RepackEnv { root, meta_dir: &meta };
let error = update::apply(&update::Params {
root, meta_dir: &meta, source: Source::Dir(pkg), trusted_key: &trusted,
cancel: Cancel::default(), resolutions: BTreeMap::new(), env: &env, fail_after_ops: None,
}, &|step, pct| println!("{pct}% {step}" )).unwrap_err();
let env = RepackEnv {
root,
meta_dir: &meta,
};
let error = update::apply(
&update::Params {
root,
meta_dir: &meta,
source: Source::Dir(pkg),
trusted_key: &trusted,
cancel: Cancel::default(),
resolutions: BTreeMap::new(),
env: &env,
fail_after_ops: None,
},
&|step, pct| println!("{pct}% {step}"),
)
.unwrap_err();
assert!(error.to_string().contains("probe_world"), "{error}");
assert!(error.to_string().contains("were restored"), "{error}");
assert!(!root.join("Core/recovery-probe.txt").exists());
assert!(update::unfinished(&meta).is_none());
assert_eq!(MetaDir::open(&meta)?.1.core.version.as_deref(), Some("1.0.0"));
assert_eq!(
MetaDir::open(&meta)?.1.core.version.as_deref(),
Some("1.0.0")
);
backup::with_database(root, |db| {
assert_eq!(db.query("SELECT id FROM acore_characters.manager_recovery_probe;")?, "42");
assert_eq!(db.query("SELECT id FROM acore_world.manager_recovery_probe;")?, "43");
assert!(!coa_core::migrations::status(db, &manifest.migrations)?.iter().any(|m| m.status == coa_core::migrations::Status::Applied));
assert_eq!(
db.query("SELECT id FROM acore_characters.manager_recovery_probe;")?,
"42"
);
assert_eq!(
db.query("SELECT id FROM acore_world.manager_recovery_probe;")?,
"43"
);
assert!(!coa_core::migrations::status(db, &manifest.migrations)?
.iter()
.any(|m| m.status == coa_core::migrations::Status::Applied));
Ok(())
})?;
// A recovery point can be reused if the process died midway through restoring multiple schemas.
let point = backup::list(&meta).into_iter().find(|p| p.trigger == backup::Trigger::BeforeUpdate).ok_or_else(|| Error::Invalid("missing backup".into()))?;
let point = backup::list(&meta)
.into_iter()
.find(|p| p.trigger == backup::Trigger::BeforeUpdate)
.ok_or_else(|| Error::Invalid("missing backup".into()))?;
env.restore_snapshot(&point.id)?;
assert_eq!(Db::from_repack(root, Account::Admin)?.realm(), coa_core::realms::Mode::Coa);
assert_eq!(
Db::from_repack(root, Account::Admin)?.realm(),
coa_core::realms::Mode::Coa
);
println!("PASS: failed SQL restored world, characters, ledger, files and version; repeated recovery succeeded");
Ok(())
}
+17 -4
View File
@@ -3,15 +3,28 @@ use std::path::PathBuf;
fn main() {
let root = PathBuf::from(std::env::args().nth(1).expect("disposable fixture path"));
assert_eq!(std::fs::read(root.join(".release-schema-fixture")).unwrap(), b"disposable release-schema fixture");
assert_eq!(
std::fs::read(root.join(".release-schema-fixture")).unwrap(),
b"disposable release-schema fixture"
);
let meta = coa_core::registry::metadata_dir_for(&root).unwrap();
let env = RepackEnv { root: &root, meta_dir: &meta };
let env = RepackEnv {
root: &root,
meta_dir: &meta,
};
let result = env.validate();
let _ = coa_core::driver::run(&root, coa_core::driver::Verb::StopAll);
if let Err(error) = result {
eprintln!("{}", error);
for log in ["Core/Logs/auth-console.log", "Core/Logs/world-console.log", "Core/Logs/supervisor.log"] {
eprintln!("{log}:\n{}", coa_core::diag::redact(&coa_core::health::tail(&root.join(log), 8192)));
for log in [
"Core/Logs/auth-console.log",
"Core/Logs/world-console.log",
"Core/Logs/supervisor.log",
] {
eprintln!(
"{log}:\n{}",
coa_core::diag::redact(&coa_core::health::tail(&root.join(log), 8192))
);
}
std::process::exit(1);
}
+44 -6
View File
@@ -8,18 +8,56 @@ use coa_core::update::{apply, preview, Params, RepackEnv};
fn main() {
let a: Vec<String> = std::env::args().skip(1).collect();
let root = std::path::PathBuf::from(&a[0]);
assert!(a[0].to_lowercase().contains("installtest"), "refusing: not a disposable test install");
assert!(
a[0].to_lowercase().contains("installtest"),
"refusing: not a disposable test install"
);
let dir = metadata_dir_for(&root).unwrap();
let (_, meta) = MetaDir::open(&dir).unwrap();
let src = Source::Url(a[1].clone());
let p = preview(&root, &meta, &src, coa_core::signing::EMBEDDED_PUBLIC_KEY, &Default::default()).unwrap_or_else(|e| panic!("preview failed: {e:?}"));
println!("preview: {} -> {} | download {} bytes | {} files change | {} migrations | conflicts {:?}", p.from_version.clone().unwrap_or_default(), p.to_version, p.download_bytes, p.items.iter().filter(|i| format!("{:?}", i.action) != "Skip").count(), p.migrations, p.conflicts);
let env = RepackEnv { root: &root, meta_dir: &dir };
let p = preview(
&root,
&meta,
&src,
coa_core::signing::EMBEDDED_PUBLIC_KEY,
&Default::default(),
)
.unwrap_or_else(|e| panic!("preview failed: {e:?}"));
println!(
"preview: {} -> {} | download {} bytes | {} files change | {} migrations | conflicts {:?}",
p.from_version.clone().unwrap_or_default(),
p.to_version,
p.download_bytes,
p.items
.iter()
.filter(|i| format!("{:?}", i.action) != "Skip")
.count(),
p.migrations,
p.conflicts
);
let env = RepackEnv {
root: &root,
meta_dir: &dir,
};
let t = std::time::Instant::now();
let out = apply(
&Params { root: &root, meta_dir: &dir, source: src, trusted_key: coa_core::signing::EMBEDDED_PUBLIC_KEY, cancel: Cancel::default(), resolutions: Default::default(), env: &env, fail_after_ops: None },
&Params {
root: &root,
meta_dir: &dir,
source: src,
trusted_key: coa_core::signing::EMBEDDED_PUBLIC_KEY,
cancel: Cancel::default(),
resolutions: Default::default(),
env: &env,
fail_after_ops: None,
},
&|s, pct| eprintln!(" {pct:>3}% {s}"),
)
.unwrap_or_else(|e| panic!("apply failed: {e:?}"));
println!("apply finished in {:?}: state {:?}, to {:?}", t.elapsed(), out.txn.state, out.txn.to_version);
println!(
"apply finished in {:?}: state {:?}, to {:?}",
t.elapsed(),
out.txn.state,
out.txn.to_version
);
}
+3 -1
View File
@@ -1,5 +1,7 @@
fn main() {
let m = std::env::args().nth(1).expect("usage: verify <manifest.json>");
let m = std::env::args()
.nth(1)
.expect("usage: verify <manifest.json>");
let bytes = std::fs::read(&m).unwrap();
let sig = std::fs::read_to_string(format!("{m}.sig")).unwrap();
match coa_core::signing::verify_embedded(&bytes, &sig) {
+93 -22
View File
@@ -1,15 +1,34 @@
//! Reproduce applied migration history with five missing tables on a disposable MySQL fixture.
use coa_core::{
backup, fsx,
manifest::Migration,
migrations::{self, LedgerRow, Status, Store},
release_schema, schema_check, Error, Result,
};
use std::path::PathBuf;
use coa_core::{backup, fsx, manifest::Migration, migrations::{self, LedgerRow, Status, Store}, release_schema, schema_check, Error, Result};
fn main() -> Result<()> {
let mut args = std::env::args().skip(1);
let root = PathBuf::from(args.next().ok_or_else(|| Error::Invalid("fixture path required".into()))?);
let old_sql = PathBuf::from(args.next().ok_or_else(|| Error::Invalid("core SQL directory required".into()))?);
let repairs = PathBuf::from(args.next().ok_or_else(|| Error::Invalid("repair SQL directory required".into()))?);
if !root.file_name().is_some_and(|n| n.to_string_lossy().starts_with("coa-update-recovery-fixture-"))
|| !root.join("recovery-e2e-started").exists() {
return Err(Error::Invalid("Refusing a non-disposable recovery fixture.".into()));
let root = PathBuf::from(
args.next()
.ok_or_else(|| Error::Invalid("fixture path required".into()))?,
);
let old_sql = PathBuf::from(
args.next()
.ok_or_else(|| Error::Invalid("core SQL directory required".into()))?,
);
let repairs = PathBuf::from(
args.next()
.ok_or_else(|| Error::Invalid("repair SQL directory required".into()))?,
);
if !root.file_name().is_some_and(|n| {
n.to_string_lossy()
.starts_with("coa-update-recovery-fixture-")
}) || !root.join("recovery-e2e-started").exists()
{
return Err(Error::Invalid(
"Refusing a non-disposable recovery fixture.".into(),
));
}
let tree = tempfile::tempdir()?;
backup::with_database(&root, |db| {
@@ -18,38 +37,90 @@ fn main() -> Result<()> {
db.load()?;
// Record exactly the old file hashes, as in the user's all-applied report.
let mut migrations = Vec::new();
for name in ["rev_20260929_92_coa_wildcard_skill_cards", "rev_20260929_93_coa_wildcard_skill_card_duplicates", "rev_20260929_94_coa_wildcard_specialization_cache"] {
for name in [
"rev_20260929_92_coa_wildcard_skill_cards",
"rev_20260929_93_coa_wildcard_skill_card_duplicates",
"rev_20260929_94_coa_wildcard_specialization_cache",
] {
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 { compatible_sha256: vec![], db: "characters".into(), id: name.into(), sha256: hash, destructive: false });
db.put(&LedgerRow {
db: "characters".into(),
id: name.into(),
sha256: hash.clone(),
status: Status::Applied,
error: None,
baseline: 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}`;"))?; }
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}`;"))?;
}
}
assert!(migrations::status(&db, &migrations)?.iter().all(|m| m.status == Status::Applied));
assert!(!db.tables("acore_characters")?.iter().any(|t| t == "coa_wildcard_skill_card"));
assert!(migrations::status(&db, &migrations)?
.iter()
.all(|m| m.status == Status::Applied));
assert!(!db
.tables("acore_characters")?
.iter()
.any(|t| t == "coa_wildcard_skill_card"));
let empty_core = tempfile::tempdir()?;
let files = release_schema::collect(empty_core.path(), None, Some(&repairs))?;
assert_eq!(files.len(), 1);
let repair = &files[0];
migrations.push(Migration { compatible_sha256: vec![], 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()))?;
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())
})?;
assert!(report.failed.is_none());
assert_eq!(report.applied, [repair.id.clone()]);
assert_eq!(db.query("SELECT COUNT(*) FROM acore_characters.characters;")?, characters);
assert_eq!(&report.applied, std::slice::from_ref(&repair.id));
assert_eq!(
db.query("SELECT COUNT(*) FROM acore_characters.characters;")?,
characters
);
db.query("INSERT INTO acore_characters.coa_wildcard_skill_card VALUES (77,123,456);")?;
db.run_sql_file("acore_characters", &repair.abs)?;
assert_eq!(db.query("SELECT progress FROM acore_characters.coa_wildcard_skill_card WHERE account=77 AND card=123;")?, "456");
assert!(migrations::apply_pending(&db, &migrations, &tree.path().join("sql"), &|| Ok("disposable fixture".into()))?.applied.is_empty());
assert!(
migrations::apply_pending(&db, &migrations, &tree.path().join("sql"), &|| Ok(
"disposable fixture".into()
))?
.applied
.is_empty()
);
schema_check::capture(&db, tree.path())?;
db.query("DROP TABLE acore_characters.coa_wildcard_skill_card_purchase;")?;
assert!(schema_check::check(&db, tree.path())?.iter().any(|p| p.table == "coa_wildcard_skill_card_purchase" && p.detail == "Missing table"));
assert!(schema_check::check(&db, tree.path())?
.iter()
.any(|p| p.table == "coa_wildcard_skill_card_purchase" && p.detail == "Missing table"));
db.run_sql_file("acore_characters", &repair.abs)?;
db.query("ALTER TABLE acore_characters.coa_wildcard_skill_card DROP COLUMN progress;")?;
assert!(schema_check::check(&db, tree.path())?.iter().any(|p| p.table == "coa_wildcard_skill_card" && p.column == "progress"));
assert!(schema_check::check(&db, tree.path())?
.iter()
.any(|p| p.table == "coa_wildcard_skill_card" && p.column == "progress"));
db.query("ALTER TABLE acore_characters.coa_wildcard_skill_card ADD COLUMN progress INT UNSIGNED NOT NULL DEFAULT 0;")?;
Ok(())
})?;