mirror of
https://github.com/Corfirean/coa-server-manager.git
synced 2026-11-19 11:25:56 +00:00
Add CoA / Wildcard realm profiles for v0.5.0 (#10)
* Add isolated Wildcard realm profiles and release v0.5.0 * Document realm validation and align npm lock version
This commit is contained in:
1 parent
831685dbd7
commit
1bcef5f8c2
35 files changed
+872
-37
No files matched your search
@@ -0,0 +1,92 @@
|
||||
//! Native smoke checks for the disposable fixture created by tools/make-fixture.ps1.
|
||||
//! Never point these probes at an owned server.
|
||||
use std::path::Path;
|
||||
|
||||
use coa_core::db::{Account, Db};
|
||||
use coa_core::driver::{self, Verb};
|
||||
use coa_core::realms::{self, Mode};
|
||||
use coa_core::{Error, Result};
|
||||
|
||||
fn main() -> Result<()> {
|
||||
let args: Vec<String> = std::env::args().collect();
|
||||
let root = Path::new("C:/games/coa-wildcard-fixture");
|
||||
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 };
|
||||
println!("{}", serde_json::to_string(&realms::select(root, mode)?)?);
|
||||
}
|
||||
"start" | "stop" => {
|
||||
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())); }
|
||||
}
|
||||
"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")?);
|
||||
}
|
||||
"mark" => {
|
||||
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}"))?;
|
||||
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}");
|
||||
}
|
||||
assert!(backup::verify(&meta, &point.id)?.ok);
|
||||
println!("Verified both realm backups: {}", point.id);
|
||||
}
|
||||
"database-checks" => {
|
||||
use coa_core::backup::{self, Kind, Trigger};
|
||||
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 };
|
||||
env.ensure_stopped()?;
|
||||
let staged = root.join("fixture-migrations");
|
||||
let mut manifest: Manifest = serde_json::from_value(serde_json::json!({
|
||||
"schema": 1, "kind": "update", "version": "0.5.0", "core": {"commit": null},
|
||||
"builtAt": "fixture", "minManagerVersion": "0.5.0"
|
||||
}))?;
|
||||
for kind in ["characters", "world", "auth"] {
|
||||
let sql = format!("CREATE TABLE acore_{kind}.manager_migration_probe (value INT); INSERT INTO acore_{kind}.manager_migration_probe VALUES (42);");
|
||||
let path = staged.join(format!("{kind}/manager_realm_fixture.sql"));
|
||||
std::fs::create_dir_all(path.parent().unwrap())?;
|
||||
std::fs::write(&path, sql)?;
|
||||
manifest.migrations.push(Migration { id: "manager_realm_fixture".into(), db: kind.into(), sha256: coa_core::fsx::sha256_file(&path)?, destructive: false });
|
||||
}
|
||||
let result = env.migrate(&manifest, &staged)?;
|
||||
assert!(result.failed.is_none());
|
||||
backup::with_database(root, |db| {
|
||||
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");
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
})?;
|
||||
assert!(env.migrate(&manifest, &staged)?.applied.is_empty());
|
||||
let point = backup::create(root, &meta, Kind::Quick, Trigger::Manual, None, &|_| {})?;
|
||||
backup::with_database(root, |db| {
|
||||
db.query("INSERT INTO acore_characters.manager_profile_probe VALUES (22);")?;
|
||||
Ok(())
|
||||
})?;
|
||||
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");
|
||||
Ok(())
|
||||
})?;
|
||||
println!("Both realms migrated once; shared auth migrated once; Wildcard restore left CoA intact.");
|
||||
}
|
||||
"view" => println!("{}", serde_json::to_string(&realms::view(root)?)?),
|
||||
_ => return Err(Error::Invalid("Unknown fixture action".into())),
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
@@ -63,6 +63,8 @@ pub struct RecoveryPoint {
|
||||
pub created_at: String,
|
||||
pub manager_version: String,
|
||||
pub components: Vec<Component>,
|
||||
#[serde(default)]
|
||||
pub realm: crate::realms::Mode,
|
||||
}
|
||||
|
||||
fn backups_dir(meta: &Path) -> PathBuf {
|
||||
@@ -127,6 +129,8 @@ pub fn config_files(root: &Path) -> Vec<String> {
|
||||
if root.join("RELEASE.json").is_file() {
|
||||
out.push("RELEASE.json".into());
|
||||
}
|
||||
walk(root, &root.join("Settings/realm-profiles"), &mut out);
|
||||
if root.join("Settings/realm-profile.json").is_file() { out.push("Settings/realm-profile.json".into()); }
|
||||
out.sort();
|
||||
out
|
||||
}
|
||||
@@ -191,16 +195,24 @@ pub fn create(root: &Path, meta: &Path, kind: Kind, trigger: Trigger, label: Opt
|
||||
|
||||
let build = || -> Result<Vec<Component>> {
|
||||
let mut components = Vec::new();
|
||||
for name in wanted_databases(kind) {
|
||||
let schema = db::schema_of(name)?;
|
||||
let realm = crate::realms::state(root)?;
|
||||
let mut databases: Vec<(String, &str)> = wanted_databases(kind).iter()
|
||||
.map(|name| Ok((name.to_string(), realm.active.schema(name)?))).collect::<Result<_>>()?;
|
||||
if realm.wildcard_created && kind != Kind::Config {
|
||||
let other = if realm.active == crate::realms::Mode::Coa { crate::realms::Mode::Wildcard } else { crate::realms::Mode::Coa };
|
||||
databases.push((format!("{}-characters", other.name()), other.schema("characters")?));
|
||||
if kind == Kind::Full { databases.push((format!("{}-world", other.name()), other.schema("world")?)); }
|
||||
}
|
||||
for (name, schema) in databases {
|
||||
progress(&format!("Backing up {name} database"));
|
||||
let component = with_database(root, |db| {
|
||||
let db = db.clone().for_realm(crate::realms::Mode::Coa);
|
||||
let size = db.schema_bytes(schema)?;
|
||||
fsx::require_space(&partial, size / 2 + 32 * 1024 * 1024)?;
|
||||
let tables = db.tables(schema)?.len();
|
||||
let file = format!("{name}.sql.zst");
|
||||
let (bytes, sha) = db.dump_to(schema, &partial.join(&file))?;
|
||||
Ok(Component { name: (*name).into(), path: file, bytes, sha256: Some(sha), tables: Some(tables), files: None })
|
||||
Ok(Component { name, path: file, bytes, sha256: Some(sha), tables: Some(tables), files: None })
|
||||
})?;
|
||||
components.push(component);
|
||||
}
|
||||
@@ -219,6 +231,7 @@ pub fn create(root: &Path, meta: &Path, kind: Kind, trigger: Trigger, label: Opt
|
||||
}
|
||||
};
|
||||
let point = RecoveryPoint {
|
||||
realm: crate::realms::state(root)?.active,
|
||||
schema: 1,
|
||||
id: id.clone(),
|
||||
kind,
|
||||
@@ -289,6 +302,9 @@ pub fn delete(meta: &Path, id: &str) -> Result<()> {
|
||||
/// Put configuration files back. Files the backup does not contain are left alone. A safety point is taken first.
|
||||
pub fn restore_configs(root: &Path, meta: &Path, id: &str) -> Result<RecoveryPoint> {
|
||||
let point = get(meta, id)?;
|
||||
if point.realm != crate::realms::state(root)?.active {
|
||||
return Err(Error::Invalid("Select the realm this backup belongs to before restoring it.".into()));
|
||||
}
|
||||
let comp = point.components.iter().find(|c| c.name == "configs").ok_or_else(|| Error::Invalid("this backup has no configuration".into()))?;
|
||||
if !verify(meta, id)?.ok {
|
||||
return Err(Error::Invalid("This backup is damaged and cannot be restored.".into()));
|
||||
@@ -314,6 +330,9 @@ pub struct DbRestore {
|
||||
/// import into a staging schema, sanity-check it, then swap tables atomically and keep the old schema.
|
||||
pub fn restore_database(root: &Path, meta: &Path, id: &str, name: &str) -> Result<DbRestore> {
|
||||
let point = get(meta, id)?;
|
||||
if point.realm != crate::realms::state(root)?.active {
|
||||
return Err(Error::Invalid("Select the realm this backup belongs to before restoring it.".into()));
|
||||
}
|
||||
let comp = point.components.iter().find(|c| c.name == name && c.sha256.is_some()).ok_or_else(|| Error::Invalid(format!("this backup has no {name} database")))?;
|
||||
if !verify(meta, id)?.ok {
|
||||
return Err(Error::Invalid("This backup is damaged and cannot be restored.".into()));
|
||||
@@ -322,7 +341,7 @@ pub fn restore_database(root: &Path, meta: &Path, id: &str, name: &str) -> Resul
|
||||
if now.world.state != ServiceState::Stopped || now.auth.state != ServiceState::Stopped {
|
||||
return Err(Error::Invalid("Stop the server before restoring a database.".into()));
|
||||
}
|
||||
let live = db::schema_of(name)?;
|
||||
let live = if name.contains('-') { db::schema_of(name)? } else { point.realm.schema(name)? };
|
||||
let expected_tables = comp.tables.unwrap_or(0);
|
||||
let dump = point_dir(meta, id)?.join(&comp.path);
|
||||
let stamp = chrono::Utc::now().format("%Y%m%d%H%M%S").to_string();
|
||||
@@ -331,6 +350,7 @@ pub fn restore_database(root: &Path, meta: &Path, id: &str, name: &str) -> Resul
|
||||
let safety = create(root, meta, Kind::Database, Trigger::BeforeRestore, Some(format!("before restoring {name} from {id}")), &|_| {})?;
|
||||
|
||||
with_database(root, |db| {
|
||||
let db = db.clone().for_realm(crate::realms::Mode::Coa);
|
||||
let staging = format!("{live}_restore_{stamp}");
|
||||
let old = format!("{live}_before_restore_{stamp}");
|
||||
if db.schema_exists(&staging)? || db.schema_exists(&old)? {
|
||||
|
||||
@@ -436,6 +436,7 @@ fn quiet_debug_loggers(root: &Path) -> Result<Vec<String>> {
|
||||
|
||||
/// Apply validated `changes`. Nothing is written unless every change is valid; previous contents are snapshotted first.
|
||||
pub fn save(root: &Path, meta_dir: &Path, scope: Scope, changes: &BTreeMap<String, Value>) -> Result<SaveReport> {
|
||||
if scope == Scope::Bots { crate::realms::guard_module(root, "companions")?; }
|
||||
let raws = validate(root, scope, changes)?;
|
||||
let schema = scope.schema();
|
||||
let t = targets(root, scope)?;
|
||||
|
||||
@@ -44,6 +44,7 @@ pub struct Db {
|
||||
port: u16,
|
||||
user: &'static str,
|
||||
password: Secret,
|
||||
realm: crate::realms::Mode,
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
@@ -67,6 +68,8 @@ fn no_window(cmd: &mut Command) {
|
||||
pub const SCHEMAS: [(&str, &str); 3] = [("characters", "acore_characters"), ("auth", "acore_auth"), ("world", "acore_world")];
|
||||
|
||||
pub fn schema_of(kind: &str) -> Result<&'static str> {
|
||||
if let Some(kind) = kind.strip_prefix("wildcard-") { return crate::realms::Mode::Wildcard.schema(kind); }
|
||||
if let Some(kind) = kind.strip_prefix("coa-") { return crate::realms::Mode::Coa.schema(kind); }
|
||||
SCHEMAS.iter().find(|(k, _)| *k == kind).map(|(_, s)| *s).ok_or_else(|| Error::Invalid(format!("unknown database {kind}")))
|
||||
}
|
||||
|
||||
@@ -87,7 +90,38 @@ impl Db {
|
||||
Account::Admin => ("root", creds.root_password),
|
||||
Account::App => ("acore", creds.app_password),
|
||||
};
|
||||
Ok(Db { bin, port: ports.mysql, user, password: Secret(password) })
|
||||
Ok(Db { bin, port: ports.mysql, user, password: Secret(password), realm: crate::realms::state(root)?.active })
|
||||
}
|
||||
|
||||
pub fn for_realm(mut self, realm: crate::realms::Mode) -> Self { self.realm = realm; self }
|
||||
|
||||
pub fn realm_schema<'a>(&self, name: &'a str) -> &'a str {
|
||||
if self.realm == crate::realms::Mode::Wildcard {
|
||||
match name {
|
||||
"acore_world" => "acore_world_wildcard",
|
||||
"acore_characters" => "acore_characters_wildcard",
|
||||
_ => name,
|
||||
}
|
||||
} else { name }
|
||||
}
|
||||
|
||||
pub fn clone_structure(&self, source: &str, dest: &str, cache: &Path) -> Result<()> {
|
||||
if !ident_ok(source) || !ident_ok(dest) { return Err(Error::Invalid("Invalid schema name.".into())); }
|
||||
let path = cache.join("characters-structure.sql");
|
||||
self.dump_structure_to(source, &path)?;
|
||||
self.run_sql_file(dest, &path)?;
|
||||
std::fs::remove_file(path)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn dump_structure_to(&self, source: &str, path: &Path) -> Result<()> {
|
||||
if !ident_ok(source) { return Err(Error::Invalid("Invalid schema name.".into())); }
|
||||
let mut c = self.command("mysqldump.exe");
|
||||
c.args(["--no-data", "--no-tablespaces", "--skip-comments", "--default-character-set=utf8mb4", source]);
|
||||
c.stdout(Stdio::from(File::create(&path)?));
|
||||
let out = c.output()?;
|
||||
if !out.status.success() { return Err(self.fail(&out.stderr)); }
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn command(&self, tool: &str) -> Command {
|
||||
@@ -123,9 +157,10 @@ impl Db {
|
||||
pub fn query(&self, sql: &str) -> Result<String> {
|
||||
let mut c = self.command("mysql.exe");
|
||||
c.args(["--batch", "--skip-column-names", "--connect-timeout=5"]);
|
||||
c.args(["--default-character-set=utf8mb4", "--max-allowed-packet=128M"]);
|
||||
c.stdin(Stdio::piped());
|
||||
let mut child = c.spawn()?;
|
||||
child.stdin.take().expect("piped").write_all(sql.as_bytes())?;
|
||||
child.stdin.take().expect("piped").write_all(route_sql(sql, self.realm).as_bytes())?;
|
||||
let out = child.wait_with_output()?;
|
||||
if !out.status.success() {
|
||||
return Err(self.fail(&out.stderr));
|
||||
@@ -134,6 +169,7 @@ impl Db {
|
||||
}
|
||||
|
||||
pub fn schema_exists(&self, name: &str) -> Result<bool> {
|
||||
let name = self.realm_schema(name);
|
||||
if !ident_ok(name) {
|
||||
return Err(Error::Invalid("bad schema name".into()));
|
||||
}
|
||||
@@ -141,6 +177,7 @@ impl Db {
|
||||
}
|
||||
|
||||
pub fn tables(&self, schema: &str) -> Result<Vec<String>> {
|
||||
let schema = self.realm_schema(schema);
|
||||
if !ident_ok(schema) {
|
||||
return Err(Error::Invalid("bad schema name".into()));
|
||||
}
|
||||
@@ -150,6 +187,7 @@ impl Db {
|
||||
|
||||
/// Bytes of data + index the schema occupies (used to estimate backup size).
|
||||
pub fn schema_bytes(&self, schema: &str) -> Result<u64> {
|
||||
let schema = self.realm_schema(schema);
|
||||
if !ident_ok(schema) {
|
||||
return Err(Error::Invalid("bad schema name".into()));
|
||||
}
|
||||
@@ -159,6 +197,7 @@ impl Db {
|
||||
|
||||
/// Stored routines / triggers / views make a table-level swap unsafe; count them.
|
||||
pub fn extra_objects(&self, schema: &str) -> Result<u64> {
|
||||
let schema = self.realm_schema(schema);
|
||||
if !ident_ok(schema) {
|
||||
return Err(Error::Invalid("bad schema name".into()));
|
||||
}
|
||||
@@ -170,6 +209,7 @@ impl Db {
|
||||
|
||||
/// Consistent dump of one schema, zstd-compressed to `out`. Returns (compressed bytes, sha256 of the file).
|
||||
pub fn dump_to(&self, schema: &str, out: &Path) -> Result<(u64, String)> {
|
||||
let schema = self.realm_schema(schema);
|
||||
if !ident_ok(schema) {
|
||||
return Err(Error::Invalid("bad schema name".into()));
|
||||
}
|
||||
@@ -203,9 +243,15 @@ impl Db {
|
||||
|
||||
/// Run a plain SQL file against `schema`; the first error aborts and is returned.
|
||||
pub fn run_sql_file(&self, schema: &str, file: &Path) -> Result<()> {
|
||||
let schema = self.realm_schema(schema);
|
||||
if !ident_ok(schema) {
|
||||
return Err(Error::Invalid("bad schema name".into()));
|
||||
}
|
||||
if self.realm == crate::realms::Mode::Wildcard {
|
||||
let sql = std::fs::read_to_string(file)?;
|
||||
self.query(&format!("SET NAMES utf8mb4 COLLATE utf8mb4_unicode_ci; USE `{schema}`;\n{sql}"))?;
|
||||
return Ok(());
|
||||
}
|
||||
let mut c = self.command("mysql.exe");
|
||||
c.args(["--default-character-set=utf8mb4", "--init-command=SET NAMES utf8mb4 COLLATE utf8mb4_unicode_ci", "--max-allowed-packet=128M"]);
|
||||
c.arg(schema);
|
||||
@@ -219,6 +265,7 @@ impl Db {
|
||||
|
||||
/// Import a dump produced by `dump_to` into `schema` (which must already exist and be empty).
|
||||
pub fn import_from(&self, schema: &str, dump: &Path) -> Result<()> {
|
||||
let schema = self.realm_schema(schema);
|
||||
if !ident_ok(schema) {
|
||||
return Err(Error::Invalid("bad schema name".into()));
|
||||
}
|
||||
@@ -278,3 +325,50 @@ pub fn write_console_credentials(root: &Path, password: &str) -> Result<()> {
|
||||
pub fn valid_identifier(name: &str) -> bool {
|
||||
ident_ok(name)
|
||||
}
|
||||
|
||||
// Route only SQL identifiers. User names, values, comments and longer identifiers remain untouched.
|
||||
fn route_sql(sql: &str, realm: crate::realms::Mode) -> String {
|
||||
if realm == crate::realms::Mode::Coa { return sql.into(); }
|
||||
let bytes = sql.as_bytes();
|
||||
let mut out = String::new();
|
||||
let mut i = 0;
|
||||
while i < bytes.len() {
|
||||
let start = i;
|
||||
if matches!(bytes[i], b'\'' | b'"') {
|
||||
let quote = bytes[i]; i += 1;
|
||||
while i < bytes.len() {
|
||||
if bytes[i] == b'\\' { i = (i + 2).min(bytes.len()); }
|
||||
else if bytes[i] == quote {
|
||||
i += 1;
|
||||
if i < bytes.len() && bytes[i] == quote { i += 1; } else { break; }
|
||||
} else { i += 1; }
|
||||
}
|
||||
out.push_str(&sql[start..i]);
|
||||
} else if bytes[i] == b'#' || sql[i..].starts_with("--") || sql[i..].starts_with("/*") {
|
||||
if sql[i..].starts_with("/*") {
|
||||
i = sql[i + 2..].find("*/").map(|p| i + p + 4).unwrap_or(bytes.len());
|
||||
} else { i = sql[i..].find('\n').map(|p| i + p).unwrap_or(bytes.len()); }
|
||||
out.push_str(&sql[start..i]);
|
||||
} else if bytes[i].is_ascii_alphanumeric() || bytes[i] == b'_' {
|
||||
while i < bytes.len() && (bytes[i].is_ascii_alphanumeric() || bytes[i] == b'_') { i += 1; }
|
||||
out.push_str(match &sql[start..i] {
|
||||
"acore_world" => "acore_world_wildcard",
|
||||
"acore_characters" => "acore_characters_wildcard",
|
||||
other => other,
|
||||
});
|
||||
} else {
|
||||
let c = sql[i..].chars().next().unwrap(); out.push(c); i += c.len_utf8();
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod realm_tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn routes_schema_identifiers_without_rewriting_account_values() {
|
||||
let sql = "SELECT * FROM `acore_characters`.characters WHERE name='acore_world' AND x=\"acore_characters\"; -- acore_world\nSELECT * FROM acore_world.items;";
|
||||
assert_eq!(route_sql(sql, crate::realms::Mode::Wildcard), "SELECT * FROM `acore_characters_wildcard`.characters WHERE name='acore_world' AND x=\"acore_characters\"; -- acore_world\nSELECT * FROM acore_world_wildcard.items;");
|
||||
}
|
||||
}
|
||||
@@ -80,6 +80,17 @@ fn launcher(root: &Path) -> Result<(PathBuf, PathBuf)> {
|
||||
/// Run a launcher verb to completion (blocking; call from a worker thread).
|
||||
pub fn run(root: &Path, verb: Verb) -> Result<DriverOutcome> {
|
||||
let root = fsx::canonicalize_lenient(root)?;
|
||||
if verb == Verb::StartAll {
|
||||
crate::realms::before_start(&root)?;
|
||||
if root.join("Settings/realm-profile.json").exists() {
|
||||
let db = crate::db::Db::from_repack(&root, crate::db::Account::Admin)?;
|
||||
if !db.ping() {
|
||||
let out = run(&root, Verb::StartMysql)?;
|
||||
if !out.ok { return Ok(out); }
|
||||
}
|
||||
crate::realms::setup_realmlist(&root)?;
|
||||
}
|
||||
}
|
||||
let (python, script) = launcher(&root)?;
|
||||
let mut cmd = Command::new(&python);
|
||||
cmd.arg("-B").arg(&script).arg(verb.arg()).current_dir(&root).stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::piped());
|
||||
|
||||
@@ -117,7 +117,8 @@ pub fn apply_realm_address(root: &Path, host: &str) -> Result<()> {
|
||||
return Err(Error::Invalid("That address is not valid.".into()));
|
||||
}
|
||||
let db = Db::from_repack(root, Account::Admin)?;
|
||||
db.query(&format!("UPDATE acore_auth.realmlist SET address='{host}', localAddress='{host}' WHERE id=1;"))?;
|
||||
let realm = crate::realms::state(root)?.active.realm_id();
|
||||
db.query(&format!("UPDATE acore_auth.realmlist SET address='{host}', localAddress='{host}' WHERE id={realm};"))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
|
||||
@@ -29,6 +29,7 @@ pub mod ra;
|
||||
pub mod allsettings;
|
||||
pub mod modules;
|
||||
pub mod realmlist;
|
||||
pub mod realms;
|
||||
pub mod registry;
|
||||
pub mod release;
|
||||
pub mod update;
|
||||
|
||||
@@ -97,6 +97,7 @@ pub struct ModuleView {
|
||||
pub icon: String,
|
||||
pub page: Option<String>,
|
||||
pub hidden: bool,
|
||||
pub compatibility: String,
|
||||
}
|
||||
|
||||
pub fn list(root: &Path) -> Vec<ModuleView> {
|
||||
@@ -116,6 +117,7 @@ fn conf_name(root: &Path, e: &Entry) -> String {
|
||||
}
|
||||
|
||||
fn list_in(cat: &[Entry], root: &Path) -> Vec<ModuleView> {
|
||||
let wildcard = crate::realms::state(root).map(|s| s.active == crate::realms::Mode::Wildcard).unwrap_or(true);
|
||||
cat.iter()
|
||||
.cloned()
|
||||
.map(|e| {
|
||||
@@ -126,14 +128,16 @@ fn list_in(cat: &[Entry], root: &Path) -> Vec<ModuleView> {
|
||||
// the active file decides; without one the documented default is what the server will use
|
||||
let enabled = !e.switchable
|
||||
|| read(&conf).or_else(|| read(&dist)).and_then(|c| c.get(&e.enable_key).map(truthy)).unwrap_or(e.default_on);
|
||||
let blocked = wildcard && matches!(e.id.as_str(), "companions" | "playerbots");
|
||||
ModuleView {
|
||||
compatibility: if blocked { "unsupported" } else if wildcard && e.id != "client-compat" { "experimental" } else { "compatible" }.into(),
|
||||
id: e.id,
|
||||
name: e.name,
|
||||
description: e.description,
|
||||
repo: e.repo,
|
||||
installed,
|
||||
enabled,
|
||||
switchable: e.switchable,
|
||||
enabled: enabled && !blocked,
|
||||
switchable: e.switchable && !blocked,
|
||||
status: e.status,
|
||||
icon: e.icon,
|
||||
page: e.page,
|
||||
@@ -164,6 +168,7 @@ fn backup(meta: &Path, conf: &Path) -> Result<()> {
|
||||
}
|
||||
|
||||
pub fn set_enabled(root: &Path, meta: &Path, id: &str, on: bool) -> Result<()> {
|
||||
if on { crate::realms::guard_module(root, id)?; }
|
||||
set_enabled_in(&catalog(), root, meta, id, on)
|
||||
}
|
||||
|
||||
@@ -217,6 +222,7 @@ fn settings_in(cat: &[Entry], root: &Path, id: &str) -> Result<Vec<Setting>> {
|
||||
|
||||
/// Change values of settings the module already has. A value is one line of at most 500 characters.
|
||||
pub fn save_settings(root: &Path, meta: &Path, id: &str, changes: &BTreeMap<String, String>) -> Result<Vec<String>> {
|
||||
crate::realms::guard_module(root, id)?;
|
||||
save_settings_in(&catalog(), root, meta, id, changes)
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,371 @@
|
||||
use std::collections::BTreeMap;
|
||||
use std::fs;
|
||||
use std::path::Path;
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::config::parser::ConfFile;
|
||||
use crate::db::{Account, Db};
|
||||
use crate::error::{Error, Result};
|
||||
use crate::{fsx, layout, process};
|
||||
|
||||
const STATE: &str = "Settings/realm-profile.json";
|
||||
const JOURNAL: &str = "Settings/realm-switch.json";
|
||||
|
||||
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "lowercase")]
|
||||
pub enum Mode {
|
||||
#[default]
|
||||
Coa,
|
||||
Wildcard,
|
||||
}
|
||||
|
||||
impl Mode {
|
||||
pub fn name(self) -> &'static str {
|
||||
match self { Self::Coa => "coa", Self::Wildcard => "wildcard" }
|
||||
}
|
||||
pub fn realm_id(self) -> u32 { if self == Self::Coa { 1 } else { 2 } }
|
||||
pub fn schema(self, kind: &str) -> Result<&'static str> {
|
||||
match (self, kind) {
|
||||
(_, "auth") => Ok("acore_auth"),
|
||||
(Self::Coa, "characters") => Ok("acore_characters"),
|
||||
(Self::Coa, "world") => Ok("acore_world"),
|
||||
(Self::Wildcard, "characters") => Ok("acore_characters_wildcard"),
|
||||
(Self::Wildcard, "world") => Ok("acore_world_wildcard"),
|
||||
_ => Err(Error::Invalid("Unknown realm database.".into())),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
|
||||
pub struct RealmState {
|
||||
pub active: Mode,
|
||||
pub wildcard_created: bool,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize)]
|
||||
pub struct View {
|
||||
pub active: Mode,
|
||||
pub wildcard_created: bool,
|
||||
pub supported: bool,
|
||||
pub recovery_pending: bool,
|
||||
}
|
||||
|
||||
pub fn state(root: &Path) -> Result<RealmState> {
|
||||
if !root.join(STATE).exists() { return Ok(RealmState::default()); }
|
||||
fsx::read_json(&root.join(STATE))
|
||||
}
|
||||
|
||||
pub fn view(root: &Path) -> Result<View> {
|
||||
let s = state(root)?;
|
||||
// Inspect the binary itself; templates or an old log cannot prove installed support.
|
||||
let supported = fs::read(root.join("Core/worldserver.exe"))?
|
||||
.windows(b"Wildcard synergy settings".len()).any(|w| w == b"Wildcard synergy settings");
|
||||
Ok(View { active: s.active, wildcard_created: s.wildcard_created, supported, recovery_pending: root.join(JOURNAL).exists() })
|
||||
}
|
||||
|
||||
pub fn guard_module(root: &Path, id: &str) -> Result<()> {
|
||||
if state(root)?.active == Mode::Wildcard && matches!(id, "companions" | "playerbots") {
|
||||
return Err(Error::Invalid("CoA companion class mechanics have not been validated for Wildcard. This module is unavailable on this realm.".into()));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
type Files = BTreeMap<String, Vec<u8>>;
|
||||
|
||||
fn configs(root: &Path) -> Result<Files> {
|
||||
let mut files = Files::new();
|
||||
for rel in crate::backup::config_files(root) {
|
||||
if rel.starts_with("Core/configs/") && rel.ends_with(".conf")
|
||||
|| rel.starts_with("Settings/") && rel.ends_with(".template") {
|
||||
files.insert(rel.clone(), fs::read(fsx::safe_join(root, &rel)?)?);
|
||||
}
|
||||
}
|
||||
Ok(files)
|
||||
}
|
||||
|
||||
fn snapshot(root: &Path, mode: Mode) -> std::path::PathBuf {
|
||||
root.join(format!("Settings/realm-profiles/{}.json", mode.name()))
|
||||
}
|
||||
|
||||
fn write_configs(root: &Path, files: &Files) -> Result<()> {
|
||||
for rel in configs(root)?.keys() {
|
||||
if !files.contains_key(rel) { fs::remove_file(fsx::safe_join(root, rel)?)?; }
|
||||
}
|
||||
for (rel, bytes) in files {
|
||||
if !(rel.starts_with("Core/configs/") && rel.ends_with(".conf")
|
||||
|| rel.starts_with("Settings/") && rel.ends_with(".template")) {
|
||||
return Err(Error::Invalid("Invalid realm configuration path.".into()));
|
||||
}
|
||||
fsx::atomic_write(&fsx::ensure_within(root, &fsx::safe_join(root, rel)?)?, bytes)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn set(files: &mut Files, path: &str, key: &str, value: &str) -> Result<()> {
|
||||
let mut conf = ConfFile::parse_bytes(files.entry(path.into()).or_insert_with(|| b"[worldserver]\n".to_vec()))?;
|
||||
conf.set(key, value, &[]);
|
||||
files.insert(path.into(), conf.to_text().into_bytes());
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn wildcard_configs(mut files: Files) -> Result<Files> {
|
||||
for (key, value) in [
|
||||
("CoA.ClassModel", "\"hero\""), ("CoA.GameModeMask", "64"),
|
||||
("CoA.MapClass10ToWarrior", "0"), ("CoA.RealmType", "\"live seasonal\""),
|
||||
("CoA.ClientBooleanConfigs", "\"CONFIG_LEGACY_CHARACTER_ADVANCEMENT_ENABLED=0\""),
|
||||
] { set(&mut files, "Core/configs/modules/coa.conf", key, value)?; }
|
||||
set(&mut files, "Core/configs/modules/mod-coa-challenges.conf", "CoAChallenges.GameModes.Realm", "WildCard")?;
|
||||
set(&mut files, "Core/configs/modules/mod-coa-challenges.conf", "CoAChallenges.GameModes.Enable", "1")?;
|
||||
for (key, value) in [("ChancePercent", "65"), ("LinkWeight", "3"), ("RelatedWeight", "2"), ("SpecTagWeight", "2"), ("SchoolTagWeight", "1"), ("TooltipWeight", "3"), ("TalentsNeedTarget", "1"), ("LogRolls", "1")] {
|
||||
set(&mut files, "Core/configs/modules/wildcard.conf", &format!("Wildcard.Synergy.{key}"), value)?;
|
||||
}
|
||||
for path in ["Settings/worldserver.conf.template", "Core/configs/worldserver.conf"] {
|
||||
if files.contains_key(path) {
|
||||
for (key, value) in [("RealmID", "2"), ("AlwaysMaxSkillForLevel", "1"), ("PlayerStart.CustomSpells", "1")] {
|
||||
set(&mut files, path, key, value)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
for (key, value) in [("CoaBots.Enable", "0"), ("CoaBots.AutoLoginOnStartup", "0")] {
|
||||
set(&mut files, "Core/configs/modules/mod_coa_playerbots.conf", key, value)?;
|
||||
}
|
||||
Ok(files)
|
||||
}
|
||||
|
||||
#[derive(Serialize, Deserialize)]
|
||||
struct Journal { before: RealmState, files: Files }
|
||||
|
||||
fn require_world_stopped(root: &Path) -> Result<()> {
|
||||
let observed = process::observe(root, &layout::read_ports(root));
|
||||
if observed.world.state != process::ServiceState::Stopped || observed.auth.state != process::ServiceState::Stopped {
|
||||
return Err(Error::Invalid("Stop the server before switching realms. Your characters will be saved.".into()));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn recover(root: &Path) -> Result<()> {
|
||||
if !root.join(JOURNAL).exists() { return Ok(()); }
|
||||
require_world_stopped(root)?;
|
||||
let journal: Journal = fsx::read_json(&root.join(JOURNAL))?;
|
||||
write_configs(root, &journal.files)?;
|
||||
fsx::atomic_write_json(&root.join(STATE), &journal.before)?;
|
||||
fs::remove_file(root.join(JOURNAL))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn create_databases(root: &Path) -> Result<()> {
|
||||
crate::backup::with_database(root, |_| {
|
||||
let db = Db::from_repack(root, Account::Admin)?.for_realm(Mode::Coa);
|
||||
if db.query("SELECT COUNT(*) FROM acore_auth.realmlist WHERE id=2;")? != "0" {
|
||||
return Err(Error::Invalid("Realm ID 2 is already in use. Its settings were left intact.".into()));
|
||||
}
|
||||
for kind in ["world", "characters"] {
|
||||
let source = Mode::Coa.schema(kind)?;
|
||||
let dest = Mode::Wildcard.schema(kind)?;
|
||||
if db.schema_exists(dest)? {
|
||||
return Err(Error::Invalid(format!("Database {dest} already exists. It was left intact; inspect it before creating a realm.")));
|
||||
}
|
||||
if db.extra_objects(source)? != 0 {
|
||||
return Err(Error::Invalid("Realm creation does not support databases with routines, triggers or views.".into()));
|
||||
}
|
||||
}
|
||||
for (schema, tables) in [
|
||||
("acore_world", &["ascension_wildcard_boss_marks", "ascension_wildcard_tooltip_links"][..]),
|
||||
("acore_characters", &["coa_wildcard_skill_card", "coa_wildcard_skill_card_pending", "coa_wildcard_skill_card_account", "coa_wildcard_skill_card_purchase", "coa_wildcard_specialization_cache"][..]),
|
||||
] {
|
||||
let present = db.tables(schema)?;
|
||||
if tables.iter().any(|table| !present.iter().any(|p| p == table)) {
|
||||
return Err(Error::Invalid("Wildcard database migrations are missing. Update the server database before creating this realm.".into()));
|
||||
}
|
||||
}
|
||||
let cache = root.join("Settings/realm-profiles/staging");
|
||||
fs::create_dir_all(&cache)?;
|
||||
fsx::require_space(&cache, db.schema_bytes("acore_world")?.saturating_mul(2) + 512 * 1024 * 1024)?;
|
||||
let dump = cache.join("world.sql.zst");
|
||||
db.dump_to("acore_world", &dump)?;
|
||||
let stage_world = format!("coa_realm_world_{}", uuid::Uuid::new_v4().simple());
|
||||
let stage_chars = format!("coa_realm_chars_{}", uuid::Uuid::new_v4().simple());
|
||||
db.query(&format!("CREATE DATABASE `{stage_world}` CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci; CREATE DATABASE `{stage_chars}` CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;"))?;
|
||||
db.import_from(&stage_world, &dump)?;
|
||||
db.clone_structure("acore_characters", &stage_chars, &cache)?;
|
||||
for table in ["active_arena_season", "addons", "updates", "updates_include", "warden_action"] {
|
||||
db.query(&format!("INSERT INTO `{stage_chars}`.`{table}` SELECT * FROM acore_characters.`{table}`;"))?;
|
||||
}
|
||||
// The newly empty realm inherits schema migration history, never the owner's characters or cards.
|
||||
if db.tables("acore_world")?.iter().any(|t| t == "coa_manager_migrations") {
|
||||
db.query(&format!("CREATE TABLE IF NOT EXISTS `{stage_world}`.coa_manager_migrations LIKE acore_world.coa_manager_migrations;"))?;
|
||||
}
|
||||
db.query("CREATE DATABASE acore_world_wildcard CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci; CREATE DATABASE acore_characters_wildcard CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;")?;
|
||||
let mut renames = Vec::new();
|
||||
for (stage, dest) in [(&stage_world, "acore_world_wildcard"), (&stage_chars, "acore_characters_wildcard")] {
|
||||
for table in db.tables(stage)? {
|
||||
if !crate::db::valid_identifier(&table) { return Err(Error::Invalid("Unsupported table name.".into())); }
|
||||
renames.push(format!("`{stage}`.`{table}` TO `{dest}`.`{table}`"));
|
||||
}
|
||||
}
|
||||
db.query(&format!("RENAME TABLE {};", renames.join(", ")))?;
|
||||
for host in db.query("SELECT host FROM mysql.user WHERE user='acore';")?.lines() {
|
||||
let host = hex::encode(host.as_bytes());
|
||||
// Host names are trusted database data, but still quote them through a hex SQL literal.
|
||||
db.query(&format!("SET @host=CONVERT(UNHEX('{host}') USING utf8mb4); SET @grant=CONCAT('GRANT ALL ON acore_world_wildcard.* TO ', QUOTE('acore'), '@', QUOTE(@host)); PREPARE realm_grant FROM @grant; EXECUTE realm_grant; DEALLOCATE PREPARE realm_grant; SET @grant=CONCAT('GRANT ALL ON acore_characters_wildcard.* TO ', QUOTE('acore'), '@', QUOTE(@host)); PREPARE realm_grant FROM @grant; EXECUTE realm_grant; DEALLOCATE PREPARE realm_grant;"))?;
|
||||
}
|
||||
db.query(&format!("DROP DATABASE `{stage_world}`; DROP DATABASE `{stage_chars}`;"))?;
|
||||
fs::remove_file(&dump)?;
|
||||
Ok(())
|
||||
})
|
||||
}
|
||||
|
||||
pub fn select(root: &Path, mode: Mode) -> Result<View> {
|
||||
require_world_stopped(root)?;
|
||||
recover(root)?;
|
||||
let mut s = state(root)?;
|
||||
if mode == s.active { return view(root); }
|
||||
if mode == Mode::Wildcard && !view(root)?.supported {
|
||||
return Err(Error::Invalid("Update the server to a build with Wildcard support first.".into()));
|
||||
}
|
||||
// Verify launcher support before creating databases or changing the selected realm.
|
||||
prepare_launcher(root)?;
|
||||
let before = configs(root)?;
|
||||
fsx::atomic_write_json(&snapshot(root, s.active), &before)?;
|
||||
if mode == Mode::Wildcard && !s.wildcard_created {
|
||||
fsx::atomic_write_json(&snapshot(root, mode), &wildcard_configs(before.clone())?)?;
|
||||
create_databases(root)?;
|
||||
s.wildcard_created = true;
|
||||
fsx::atomic_write_json(&root.join(STATE), &s)?;
|
||||
}
|
||||
let target: Files = fsx::read_json(&snapshot(root, mode))?;
|
||||
// The launcher and batch files share this lock; recheck after the potentially long database copy.
|
||||
fs::create_dir_all(root.join(".state"))?;
|
||||
let lock = fs::OpenOptions::new().read(true).write(true).create(true).truncate(false).open(root.join(".state/control.lock"))?;
|
||||
fs4::fs_std::FileExt::try_lock_exclusive(&lock).map_err(|_| Error::Invalid("Another start/stop action is in progress.".into()))?;
|
||||
require_world_stopped(root)?;
|
||||
let original = state(root)?;
|
||||
fsx::atomic_write_json(&root.join(JOURNAL), &Journal { before: original, files: before })?;
|
||||
let result = (|| {
|
||||
write_configs(root, &target)?;
|
||||
s.active = mode;
|
||||
fsx::atomic_write_json(&root.join(STATE), &s)?;
|
||||
Ok(())
|
||||
})();
|
||||
if let Err(e) = result { drop(lock); recover(root)?; return Err(e); }
|
||||
fs::remove_file(root.join(JOURNAL))?;
|
||||
view(root)
|
||||
}
|
||||
|
||||
/// Adapt the bundled launcher's canonical schema and realm choices without changing its supervision logic.
|
||||
pub fn prepare_launcher(root: &Path) -> Result<()> {
|
||||
let path = root.join("Scripts/manage.py");
|
||||
let source = fs::read_to_string(&path)?;
|
||||
let patched = patch_launcher(&source)?;
|
||||
if patched != source { fsx::atomic_write(&path, patched.as_bytes())?; }
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn patch_launcher(source: &str) -> Result<String> {
|
||||
if source.contains("# coa-manager-realm-profiles-v1") { return Ok(source.into()); }
|
||||
let replacements = [
|
||||
("(\"WorldDatabaseInfo\", \"acore_world\")", "(\"WorldDatabaseInfo\", \"acore_world_wildcard\" if coa_realm() == 'wildcard' else \"acore_world\")"),
|
||||
("(\"CharacterDatabaseInfo\", \"acore_characters\")", "(\"CharacterDatabaseInfo\", \"acore_characters_wildcard\" if coa_realm() == 'wildcard' else \"acore_characters\")"),
|
||||
("SET name='AzerothCore',address=", "SET name='{coa_realm_name()}',address="),
|
||||
("WHERE id=1;", "WHERE id={coa_realm_id()};"),
|
||||
("mysql(\"UPDATE acore_auth.realmlist SET flag=0", "mysql(f\"UPDATE acore_auth.realmlist SET flag=0"),
|
||||
];
|
||||
let mut out = source.to_string();
|
||||
for (from, to) in replacements {
|
||||
if !out.contains(from) { return Err(Error::Invalid("This launcher does not support realm profiles. Update the server package first.".into())); }
|
||||
out = out.replace(from, to);
|
||||
}
|
||||
let insert = "# coa-manager-realm-profiles-v1\ndef coa_realm():\n path = ROOT / 'Settings/realm-profile.json'\n return json.loads(path.read_text(encoding='utf-8')).get('active', 'coa') if path.exists() else 'coa'\n\ndef coa_realm_id():\n return 2 if coa_realm() == 'wildcard' else 1\n\ndef coa_realm_name():\n return 'Wildcard' if coa_realm() == 'wildcard' else 'Conquest of Azeroth'\n\n";
|
||||
// Insert before the entry point so ROOT, json and functions are all defined when called.
|
||||
let marker = "if __name__ == \"__main__\":";
|
||||
if !out.contains(marker) { return Err(Error::Invalid("Unrecognised server launcher entry point.".into())); }
|
||||
Ok(out.replace(marker, &format!("{insert}{marker}")))
|
||||
}
|
||||
|
||||
pub fn before_start(root: &Path) -> Result<()> {
|
||||
recover(root)?;
|
||||
let s = state(root)?;
|
||||
if !root.join(STATE).exists() { return Ok(()); }
|
||||
prepare_launcher(root)?;
|
||||
if s.active == Mode::Wildcard {
|
||||
if !view(root)?.supported { return Err(Error::Invalid("The installed server build does not support Wildcard.".into())); }
|
||||
let path = root.join("Core/configs/modules/mod_coa_playerbots.conf");
|
||||
let mut conf = ConfFile::parse_bytes(&fs::read(&path)?)?;
|
||||
conf.set("CoaBots.Enable", "0", &[]);
|
||||
fsx::atomic_write(&path, conf.to_text().as_bytes())?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn setup_realmlist(root: &Path) -> Result<()> {
|
||||
let s = state(root)?;
|
||||
if !root.join(STATE).exists() || !s.wildcard_created { return Ok(()); }
|
||||
let db = Db::from_repack(root, Account::Admin)?;
|
||||
let port = layout::read_ports(root).world;
|
||||
db.query(&format!("INSERT INTO acore_auth.realmlist (id,name,address,localAddress,localSubnetMask,port,icon,flag,timezone,gamebuild) SELECT 2,'Wildcard',address,localAddress,localSubnetMask,{port},icon,2,timezone,gamebuild FROM acore_auth.realmlist WHERE id=1 ON DUPLICATE KEY UPDATE port={port}; UPDATE acore_auth.realmlist SET flag=2 WHERE id IN (1,2) AND id<>{};", s.active.realm_id()))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn fresh_wildcard_disables_bots_and_preserves_scaling() {
|
||||
let mut f = Files::new();
|
||||
f.insert("Core/configs/modules/mod-coa-content-scaling.conf".into(), b"[worldserver]\nCoAContentScaling.Enable = 1\n".to_vec());
|
||||
f.insert("Settings/worldserver.conf.template".into(), b"[worldserver]\nRealmID = 1\n".to_vec());
|
||||
let w = wildcard_configs(f.clone()).unwrap();
|
||||
assert_eq!(w["Core/configs/modules/mod-coa-content-scaling.conf"], f["Core/configs/modules/mod-coa-content-scaling.conf"]);
|
||||
let c = ConfFile::parse_bytes(&w["Core/configs/modules/mod_coa_playerbots.conf"]).unwrap();
|
||||
assert_eq!(c.get("CoaBots.Enable"), Some("0"));
|
||||
assert_eq!(ConfFile::parse_bytes(&w["Settings/worldserver.conf.template"]).unwrap().get("RealmID"), Some("2"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn corrupt_state_is_not_silently_treated_as_coa() {
|
||||
let t = tempfile::tempdir().unwrap();
|
||||
fs::create_dir(t.path().join("Settings")).unwrap();
|
||||
fs::write(t.path().join(STATE), "broken").unwrap();
|
||||
assert!(state(t.path()).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn recovery_restores_original_settings() {
|
||||
let t = tempfile::tempdir().unwrap();
|
||||
let mut files = Files::new();
|
||||
files.insert("Core/configs/modules/coa.conf".into(), b"CoA.ClassModel = coa\n".to_vec());
|
||||
fsx::atomic_write_json(&t.path().join(JOURNAL), &Journal { before: RealmState::default(), files }).unwrap();
|
||||
recover(t.path()).unwrap();
|
||||
assert_eq!(state(t.path()).unwrap().active, Mode::Coa);
|
||||
assert_eq!(fs::read_to_string(t.path().join("Core/configs/modules/coa.conf")).unwrap(), "CoA.ClassModel = coa\n");
|
||||
assert!(!t.path().join(JOURNAL).exists());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reverting_to_coa_removes_wildcard_only_config_files() {
|
||||
let t = tempfile::tempdir().unwrap();
|
||||
let mut coa = Files::new();
|
||||
coa.insert("Core/configs/modules/coa.conf".into(), b"[worldserver]\nCoA.ClassModel = coa\n".to_vec());
|
||||
let wildcard = wildcard_configs(coa.clone()).unwrap();
|
||||
write_configs(t.path(), &wildcard).unwrap();
|
||||
write_configs(t.path(), &coa).unwrap();
|
||||
assert!(!t.path().join("Core/configs/modules/mod-coa-challenges.conf").exists());
|
||||
assert_eq!(configs(t.path()).unwrap(), coa);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wildcard_blocks_bot_settings_and_enable_calls() {
|
||||
let t = tempfile::tempdir().unwrap();
|
||||
fsx::atomic_write_json(&t.path().join(STATE), &RealmState { active: Mode::Wildcard, wildcard_created: true }).unwrap();
|
||||
assert!(crate::modules::set_enabled(t.path(), t.path(), "companions", true).is_err());
|
||||
assert!(crate::config::save(t.path(), t.path(), crate::config::Scope::Bots, &BTreeMap::new()).is_err());
|
||||
assert!(guard_module(t.path(), "content-scaling").is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unknown_launcher_is_refused_without_partial_patching() {
|
||||
assert!(patch_launcher("print('custom launcher')").is_err());
|
||||
}
|
||||
}
|
||||
@@ -476,9 +476,24 @@ impl Env for RepackEnv<'_> {
|
||||
fn migrate(&self, manifest: &Manifest, staged: &Path) -> Result<ApplyReport> {
|
||||
let (root, meta) = (self.root, self.meta_dir);
|
||||
crate::backup::with_database(root, |db| {
|
||||
crate::migrations::apply_pending(db, &manifest.migrations, staged, &|| {
|
||||
Ok(crate::backup::create(root, meta, crate::backup::Kind::Database, crate::backup::Trigger::BeforeMigration, None, &|_| {})?.id)
|
||||
})
|
||||
let realms = crate::realms::state(root)?;
|
||||
let mut result = crate::migrations::apply_pending(db, &manifest.migrations, staged, &|| {
|
||||
Ok(crate::backup::create(root, meta, crate::backup::Kind::Full, crate::backup::Trigger::BeforeMigration, None, &|_| {})?.id)
|
||||
})?;
|
||||
if realms.wildcard_created && result.failed.is_none() {
|
||||
let other = if realms.active == crate::realms::Mode::Coa { crate::realms::Mode::Wildcard } else { crate::realms::Mode::Coa };
|
||||
let other_db = db.clone().for_realm(other);
|
||||
let shared_snapshot = result.snapshot.clone();
|
||||
let migrations: Vec<_> = manifest.migrations.iter().filter(|m| m.db != "auth").cloned().collect();
|
||||
let extra = crate::migrations::apply_pending(&other_db, &migrations, staged, &|| {
|
||||
if let Some(id) = &shared_snapshot { return Ok(id.clone()); }
|
||||
Ok(crate::backup::create(root, meta, crate::backup::Kind::Full, crate::backup::Trigger::BeforeMigration, None, &|_| {})?.id)
|
||||
})?;
|
||||
result.applied.extend(extra.applied);
|
||||
result.failed = extra.failed;
|
||||
if result.snapshot.is_none() { result.snapshot = extra.snapshot; }
|
||||
}
|
||||
Ok(result)
|
||||
})
|
||||
}
|
||||
|
||||
|
||||
Reference in new issue
Block a user