mirror of
https://github.com/Corfirean/coa-server-manager.git
synced 2026-11-22 11:25:56 +00:00
feat(phase15): release and security hardening, DPAPI key store, probe & protocol hardening, secret redaction, audit and readiness report
This commit is contained in:
1 parent
b69fa6b867
commit
51e0f136d6
207 files changed
+38235
-7770
No files matched your search
@@ -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();
|
||||
|
||||
@@ -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();
|
||||
}
|
||||
@@ -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()
|
||||
);
|
||||
}
|
||||
@@ -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()),
|
||||
|
||||
@@ -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}"),
|
||||
|
||||
@@ -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()))?
|
||||
}
|
||||
@@ -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());
|
||||
}
|
||||
@@ -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: ®istry, 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: ®istry,
|
||||
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()
|
||||
);
|
||||
}
|
||||
@@ -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,
|
||||
|
||||
@@ -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());
|
||||
}
|
||||
|
||||
@@ -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(())
|
||||
}
|
||||
@@ -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(())
|
||||
})?;
|
||||
|
||||
@@ -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(®_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: ®istry, 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: ®istry,
|
||||
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");
|
||||
|
||||
@@ -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: ®, 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: ®,
|
||||
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());
|
||||
}
|
||||
@@ -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: ®, 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: ®,
|
||||
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());
|
||||
}
|
||||
@@ -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()
|
||||
);
|
||||
}
|
||||
@@ -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
|
||||
);
|
||||
}
|
||||
@@ -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());
|
||||
}
|
||||
@@ -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(())
|
||||
|
||||
@@ -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"),
|
||||
}
|
||||
}
|
||||
@@ -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(), ®istry).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(),
|
||||
®istry,
|
||||
)
|
||||
.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(),
|
||||
|
||||
@@ -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");
|
||||
|
||||
@@ -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.");
|
||||
|
||||
@@ -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(())
|
||||
|
||||
@@ -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());
|
||||
|
||||
@@ -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());
|
||||
|
||||
@@ -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.");
|
||||
|
||||
@@ -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}");
|
||||
}
|
||||
@@ -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}");
|
||||
|
||||
@@ -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");
|
||||
}
|
||||
@@ -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(())
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
|
||||
@@ -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
|
||||
);
|
||||
}
|
||||
@@ -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) {
|
||||
|
||||
@@ -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(())
|
||||
})?;
|
||||
|
||||
Reference in new issue
Block a user