Merge Manager 0.9.9 (master) into the Modules Preview

Stable packages from 0.261104.94 need Manager 0.9.8; the preview was 0.9.7.
Conflicts kept the preview's module screen and plugin-aware module logic, took
master's requires-squid compatibility value and version 0.9.9 under the
preview's own product name and identifier.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
ДмитрийandClaude Opus 5.5 committed 2026-11-05 16:23:05 +05:00
commit 2bec907fa7
36 files changed
+927 -75

No files matched your search

+27
View File
@@ -718,6 +718,24 @@ pub fn export_package(
"maintenance.json",
serde_json::to_string_pretty(&maintenance)?.as_bytes(),
)?;
for (realm, prefix) in [("primary", ""), ("secondary", ".realms/secondary/"), ("reborn", ".realms/reborn/")] {
let state = root.join(format!("{prefix}.state"));
if let Ok(owner) = fs::read_to_string(state.join("control-owner.json")) {
add(&format!("launcher/{realm}/control-owner.json"), redact_json(&owner).as_bytes())?;
}
for (path, _, _) in newest_files(&state.join("diagnostics"), "jsonl", 20)
.into_iter()
.filter(|(path, _, _)| path.file_name().is_some_and(|name| name.to_string_lossy().starts_with("manage-")))
.take(5)
{
let bytes = tail(&path, 512 * 1024);
let entries: Vec<serde_json::Value> = String::from_utf8_lossy(&bytes).lines().map(|line| {
serde_json::from_str(&redact_json(line)).unwrap_or_else(|_| serde_json::Value::String(redact(line)))
}).collect();
add(&format!("launcher/{realm}/{}.json", path.file_stem().unwrap_or_default().to_string_lossy()),
serde_json::to_string_pretty(&entries)?.as_bytes())?;
}
}
// Logs. The newest update logs of the repack's own updater are added under their own names.
let mut logs: Vec<(String, PathBuf)> = vec![
@@ -1257,6 +1275,12 @@ real error
fs::create_dir_all(meta_dir.join("diagnostics")).unwrap();
fs::write(meta_dir.join("diagnostics/schema-validation-CoA-test.json"), r#"{"problems":[{"table":"creature_display_preset","column":"display_id","detail":"default mismatch"}],"password":"schema-secret"}"#).unwrap();
fs::write(meta_dir.join("diagnostics/database-recovery-test.json"), r#"{"objects":[{"database":"acore_characters","kind":"TRIGGER","name":"user_character_trigger"}],"password":"recovery-secret"}"#).unwrap();
for prefix in ["", ".realms/secondary/", ".realms/reborn/"] {
let state = root.join(format!("{prefix}.state"));
fs::create_dir_all(state.join("diagnostics")).unwrap();
fs::write(state.join("control-owner.json"), r#"{"pid":42,"action":"start-all","password":"launcher-owner-secret"}"#).unwrap();
fs::write(state.join("diagnostics/manage-test.jsonl"), "{\"event\":\"launcher-stage-test\",\"password\":\"launcher-stage-secret\"}\n{\"event\":\"wait_ready.error\",\"port\":3307}\n").unwrap();
}
let meta = InstallMeta::new(InstallKind::Imported, &root);
let report = run(&root, &meta);
let zip_path = d.path().join("diag.zip");
@@ -1289,6 +1313,9 @@ real error
assert!(all.contains("checking updates") && all.contains("1234"));
assert!(all.contains("lockFilePresent") && all.contains("does not establish"));
assert!(!all.contains("owner-secret"));
assert!(all.contains("launcher-stage-test"));
assert!(all.contains("wait_ready.error"));
assert!(!all.contains("launcher-stage-secret"));
assert_eq!(fs::read(meta_dir.join("update.lock")).unwrap(), b"");
assert!(
!all.contains("hunter2")
+4
View File
@@ -233,6 +233,10 @@ fn run_inner_mode(
recover_world_for_forced_stop(&root)?;
}
let mut cmd = Command::new(&python);
if validating_update {
// Isolated startup must use the port from its temporary auth config.
cmd.env_remove("AC_REALM_SERVER_PORT");
}
cmd.arg("-B")
.arg("-c")
.arg(LAUNCH_SCRIPT)
+1
View File
@@ -40,6 +40,7 @@ pub mod health;
pub mod install;
pub mod layout;
pub mod logging;
pub mod server_logging;
pub mod manifest;
pub mod migrations;
pub mod modules;
+21 -21
View File
@@ -1254,6 +1254,27 @@ mod tests {
);
}
#[test]
fn dungeon_clear_requires_squid_and_stays_off_after_squid_is_reenabled() {
let d = tempfile::tempdir().unwrap();
let root = d.path();
fs::create_dir_all(dir(root)).unwrap();
fs::write(dir(root).join("playerbots.conf"), "AiPlayerbot.Enabled = 0\n").unwrap();
fs::write(dir(root).join("mod_coa_playerbots.conf"), "CoaBots.Enable = 0\n").unwrap();
let dungeon = dir(root).join("mod_dungeon_clear.conf");
fs::write(&dungeon, "DungeonClear.Enable = 0\n").unwrap();
let cat = catalog();
assert!(set_enabled_in(&cat, root, root, "dungeon-clear", true).is_err());
assert!(!list_in(&cat, root).iter().find(|entry| entry.id == "dungeon-clear").unwrap().switchable);
set_enabled_in(&cat, root, root, "playerbots", true).unwrap();
set_enabled_in(&cat, root, root, "dungeon-clear", true).unwrap();
assert!(read(&dungeon).unwrap().get("DungeonClear.Enable").map(truthy).unwrap());
set_enabled_in(&cat, root, root, "playerbots", false).unwrap();
assert!(!read(&dungeon).unwrap().get("DungeonClear.Enable").map(truthy).unwrap());
set_enabled_in(&cat, root, root, "playerbots", true).unwrap();
assert!(!read(&dungeon).unwrap().get("DungeonClear.Enable").map(truthy).unwrap());
}
#[test]
fn bot_systems_are_mutually_exclusive_in_both_directions_and_manual_configs() {
let d = tempfile::tempdir().unwrap();
@@ -1922,25 +1943,4 @@ mod tests {
let conf_content = fs::read_to_string(dir(&root).join("npc_buffer.conf")).unwrap();
assert!(conf_content.contains("NpcBuffer.Enable = 0"));
}
#[test]
fn dungeon_clear_requires_squid_and_stays_off_after_squid_is_reenabled() {
let d = tempfile::tempdir().unwrap();
let root = d.path();
fs::create_dir_all(dir(root)).unwrap();
fs::write(dir(root).join("playerbots.conf"), "AiPlayerbot.Enabled = 0\n").unwrap();
fs::write(dir(root).join("mod_coa_playerbots.conf"), "CoaBots.Enable = 0\n").unwrap();
let dungeon = dir(root).join("mod_dungeon_clear.conf");
fs::write(&dungeon, "DungeonClear.Enable = 0\n").unwrap();
let cat = catalog();
assert!(set_enabled_in(&cat, root, root, "dungeon-clear", true).is_err());
assert!(!list_in(&cat, root).iter().find(|entry| entry.id == "dungeon-clear").unwrap().switchable);
set_enabled_in(&cat, root, root, "playerbots", true).unwrap();
set_enabled_in(&cat, root, root, "dungeon-clear", true).unwrap();
assert!(read(&dungeon).unwrap().get("DungeonClear.Enable").map(truthy).unwrap());
set_enabled_in(&cat, root, root, "playerbots", false).unwrap();
assert!(!read(&dungeon).unwrap().get("DungeonClear.Enable").map(truthy).unwrap());
set_enabled_in(&cat, root, root, "playerbots", true).unwrap();
assert!(!read(&dungeon).unwrap().get("DungeonClear.Enable").map(truthy).unwrap());
}
}
+165
View File
@@ -0,0 +1,165 @@
use std::{fs, path::Path};
use crate::{
config::{parser::ConfFile, Scope},
error::{Error, Result},
fsx,
};
fn transform(bytes: &[u8], preset: &str) -> Result<String> {
let level = match preset {
"normal" => 4,
"errors" => 2,
"off" => 0,
_ => return Err(Error::Invalid("Unknown server logging preset.".into())),
};
let mut conf = ConfFile::parse_bytes(bytes)?;
let entries: Vec<_> = conf
.entries()
.map(|(key, value)| (key.to_string(), value.to_string()))
.collect();
for (key, value) in entries {
if key.starts_with("Logger.") {
let Some((_, appenders)) = value.split_once(',') else {
continue;
};
let value = if preset == "normal"
&& matches!(
key.as_str(),
"Logger.network" | "Logger.sql.sql" | "Logger.entities.player"
) {
2
} else {
level
};
conf.set(&key, &format!("{value},{appenders}"), &[]);
} else if key.starts_with("Appender.") {
let mut fields: Vec<_> = value.split(',').map(str::to_string).collect();
if fields.len() >= 3 {
fields[1] = if key == "Appender.Errors" && preset == "normal" {
"2".into()
} else {
level.to_string()
};
conf.set(&key, &fields.join(","), &[]);
}
}
}
Ok(conf.to_text())
}
pub fn apply(root: &Path, meta: &Path, preset: &str) -> Result<()> {
let _operation = crate::update::operation_lock(meta)?;
crate::update::ensure_recovered(meta)?;
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"))?;
if !fs4::fs_std::FileExt::try_lock_exclusive(&lock)? {
return Err(Error::Invalid(
"Another start/stop action is in progress.".into(),
));
}
let mut originals = Vec::new();
let mut texts = Vec::new();
for prefix in ["", ".realms/secondary/", ".realms/reborn/"] {
for name in [
"Settings/worldserver.conf.template",
"Settings/authserver.conf.template",
"Core/configs/worldserver.conf",
"Core/configs/authserver.conf",
] {
let path = fsx::ensure_within(root, &root.join(format!("{prefix}{name}")))?;
if path.is_file() {
let bytes = fs::read(&path)?;
texts.push(transform(&bytes, preset)?);
originals.push((path, bytes));
}
}
let marker = root.join(format!("{prefix}.state/debug-logs.json"));
if marker.is_file() {
originals.push((marker.clone(), fs::read(marker)?));
texts.push("{\"enabled\":false}\n".into());
}
}
if originals.is_empty() {
return Err(Error::Invalid(
"Server configuration files were not found.".into(),
));
}
crate::config::take_snapshot(
meta,
Scope::Server,
"before changing server logging",
&originals,
)?;
for (index, (path, _)) in originals.iter().enumerate() {
if let Err(error) = fsx::atomic_write(path, texts[index].as_bytes()) {
for (path, bytes) in originals.iter().take(index) {
let _ = fsx::atomic_write(path, bytes);
}
return Err(error);
}
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn changes_auth_world_and_templates_in_all_realms_with_restorable_snapshots() {
let temp = tempfile::tempdir().unwrap();
let root = temp.path().join("server");
let meta = temp.path().join("meta");
fs::create_dir_all(&root).unwrap();
let mut files = Vec::new();
for prefix in ["", ".realms/secondary/", ".realms/reborn/"] {
for name in [
"Settings/worldserver.conf.template",
"Settings/authserver.conf.template",
"Core/configs/worldserver.conf",
"Core/configs/authserver.conf",
] {
let path = root.join(format!("{prefix}{name}"));
fs::create_dir_all(path.parent().unwrap()).unwrap();
let bytes =
b"Logger.root=6,Console\r\nAppender.Console=1,6,0\r\nKeep = unchanged\r\n"
.to_vec();
fs::write(&path, &bytes).unwrap();
files.push((path, bytes));
}
}
apply(&root, &meta, "errors").unwrap();
for (path, _) in &files {
assert!(fs::read_to_string(path)
.unwrap()
.contains("Logger.root=2,Console\r\n"));
}
let snapshots = crate::config::list_snapshots(&meta);
assert_eq!(snapshots.len(), 1);
crate::config::restore_snapshot(&meta, &snapshots[0].id).unwrap();
for (path, bytes) in files {
assert_eq!(fs::read(path).unwrap(), bytes);
}
}
#[test]
fn presets_control_dispatch_and_appenders_and_can_restore_useful_logs() {
let original = b"Logger.root=6,Console Server\r\nLogger.sql.sql=6,Console Server\r\nAppender.Console=1,6,0,\"1 9 3 6 5 8\"\r\nAppender.Errors=2,2,0,Errors.log,w\r\nOther = keep\r\n";
let off = transform(original, "off").unwrap();
assert!(off.contains("Logger.root=0,Console Server\r\n"));
assert!(off.contains("Appender.Errors=2,0,0,Errors.log,w\r\n"));
let normal = transform(off.as_bytes(), "normal").unwrap();
assert!(normal.contains("Logger.root=4,Console Server\r\n"));
assert!(normal.contains("Logger.sql.sql=2,Console Server\r\n"));
assert!(normal.contains("Appender.Errors=2,2,0,Errors.log,w\r\n"));
assert!(normal.contains("Other = keep\r\n"));
assert_eq!(transform(normal.as_bytes(), "normal").unwrap(), normal);
assert!(transform(original, "unsupported").is_err());
}
}
+4
View File
@@ -1915,6 +1915,10 @@ impl RepackEnv<'_> {
};
let result = (|| -> Result<()> {
crate::update_isolation::begin(self.root, self.meta_dir)?;
let database = crate::driver::run(self.root, crate::driver::Verb::StartMysql)?;
if !database.ok {
return Err(Error::Invalid(crate::driver::startup_failure(self.root, &database)));
}
use crate::process::{observe, ServiceState};
let identities = crate::backup::with_database(self.root, |db| {
if check_schema {
+158 -19
View File
@@ -41,6 +41,24 @@ struct Saved {
sha256: Option<String>,
}
fn bot_files() -> Vec<String> {
["", ".realms/secondary/", ".realms/reborn/"]
.into_iter()
.flat_map(|prefix| {
[
"mod_coa_playerbots.conf",
"mod_coa_playerbots.conf.dist",
"playerbots.conf",
"playerbots.conf.dist",
"mod_playerbots.conf",
"mod_playerbots.conf.dist",
]
.into_iter()
.map(move |name| format!("{prefix}Core/configs/modules/{name}"))
})
.collect()
}
pub(crate) fn pending(meta: &Path) -> bool {
meta.join("validation-configs.json").exists()
}
@@ -52,15 +70,20 @@ pub(crate) fn begin(root: &Path, meta: &Path) -> Result<()> {
));
}
let mut saved = BTreeMap::new();
for rel in FILES {
let path = fsx::ensure_within(root, &fsx::safe_join(root, rel)?)?;
let modules = bot_files();
for rel in FILES
.iter()
.map(|rel| rel.to_string())
.chain(modules.iter().cloned())
{
let path = fsx::ensure_within(root, &fsx::safe_join(root, &rel)?)?;
let bytes = if path.exists() {
Some(fs::read(path)?)
} else {
None
};
let sha256 = bytes.as_ref().map(|b| fsx::sha256_bytes(b));
saved.insert(*rel, Saved { bytes, sha256 });
saved.insert(rel, Saved { bytes, sha256 });
}
let mut settings: serde_json::Value = fsx::read_json(&root.join("Settings/repack.json"))?;
let mut realm: Option<serde_json::Value> = if root.join("Settings/realm-profile.json").exists()
@@ -101,14 +124,14 @@ pub(crate) fn begin(root: &Path, meta: &Path) -> Result<()> {
}
}
let mut configs = Vec::new();
for rel in [
"Settings/worldserver.conf.template",
"Settings/authserver.conf.template",
"Core/configs/worldserver.conf",
"Core/configs/authserver.conf",
] {
for rel in FILES.iter().copied().filter(|rel| {
rel.ends_with("worldserver.conf.template")
|| rel.ends_with("authserver.conf.template")
|| rel.ends_with("worldserver.conf")
|| rel.ends_with("authserver.conf")
}) {
let path = root.join(rel);
if !path.exists() && rel.ends_with(".template") {
if !path.exists() && rel.ends_with(".template") && !rel.starts_with(".realms/") {
return Err(Error::Invalid(format!(
"Cannot isolate validation without {rel}."
)));
@@ -118,10 +141,34 @@ pub(crate) fn begin(root: &Path, meta: &Path) -> Result<()> {
conf.set("BindIP", "\"127.0.0.1\"", &[]);
if rel.contains("worldserver") {
conf.set("Ra.IP", "\"127.0.0.1\"", &[]);
conf.set("CoA.ValidationMode", "1", &[]);
}
configs.push((path, conf.to_text()));
}
}
for rel in modules {
let path = fsx::ensure_within(root, &fsx::safe_join(root, &rel)?)?;
if !path.exists() {
continue;
}
let mut conf = ConfFile::parse_bytes(&fs::read(&path)?)?;
let keys: &[&str] = if rel.contains("mod_coa_playerbots.") {
&[
"CoaBots.AutoLoginOnStartup",
"CoaBots.RandomSpawn.AutoLogin",
]
} else {
&[
"AiPlayerbot.RandomBotAutologin",
"AiPlayerbot.BotAutologin",
"AiPlayerbot.DeleteRandomBotAccounts",
]
};
for key in keys {
conf.set(key, "0", &[]);
}
configs.push((path, conf.to_text()));
}
fsx::atomic_write_json(&meta.join("validation-configs.json"), &saved)?;
fsx::atomic_write_json(&root.join("Settings/repack.json"), &settings)?;
if let Some(state) = realm {
@@ -139,16 +186,20 @@ pub(crate) fn restore(root: &Path, meta: &Path) -> Result<()> {
}
let journal = meta.join("validation-configs.json");
let saved: BTreeMap<String, Saved> = fsx::read_json(&journal)?;
// Previous managers could journal only the first two profiles. Recover those
// journals too, while continuing to reject missing or unknown legacy entries.
let legacy = saved.len() == FILES.len() - 1
let modules = bot_files();
let complete_core = FILES.iter().all(|rel| saved.contains_key(*rel));
let legacy_core = FILES
.iter()
.filter(|rel| **rel != "Settings/realm-profiles/reborn.json")
.all(|rel| saved.contains_key(*rel));
let current = complete_core
&& saved.len() == FILES.len() + modules.len()
&& modules.iter().all(|rel| saved.contains_key(rel));
let previous = complete_core && saved.len() == FILES.len();
let legacy = legacy_core
&& saved.len() == FILES.len() - 1
&& !saved.contains_key("Settings/realm-profiles/reborn.json");
let required = if legacy {
&FILES[..FILES.len() - 1]
} else {
FILES
};
if saved.len() != required.len() || required.iter().any(|rel| !saved.contains_key(*rel)) {
if !(current || previous || legacy) {
return Err(Error::Invalid(
"Isolated validation configuration journal is incomplete.".into(),
));
@@ -263,4 +314,92 @@ mod tests {
assert!(!pending(&meta));
assert_eq!(fs::read(root.join(FILES[0])).unwrap(), before);
}
#[test]
fn bot_population_is_suppressed_in_all_realms_and_restored_exactly() {
let (_dir, root, meta) = fixture();
let companion = b"[worldserver]\r\n# owner settings\r\nCoaBots.Enable = 1\r\nCoaBots.AutoLoginOnStartup = 1\r\nCoaBots.RandomSpawn.AutoLogin = 1\r\nCoaBots.AutoLogin.MaxCount = 2000\r\n";
let squid = b"[worldserver]\nAiPlayerbot.Enabled = 1\nAiPlayerbot.RandomBotAutologin = 1\nAiPlayerbot.BotAutologin = 1\nAiPlayerbot.DeleteRandomBotAccounts = 1\n";
for rel in bot_files() {
fsx::atomic_write(
&root.join(&rel),
if rel.contains("mod_coa_playerbots.") {
companion
} else {
squid
},
)
.unwrap();
}
begin(&root, &meta).unwrap();
for rel in bot_files() {
let conf = ConfFile::parse_bytes(&fs::read(root.join(&rel)).unwrap()).unwrap();
if rel.contains("mod_coa_playerbots.") {
assert_eq!(conf.get("CoaBots.Enable"), Some("1"));
assert_eq!(conf.get("CoaBots.AutoLoginOnStartup"), Some("0"));
assert_eq!(conf.get("CoaBots.RandomSpawn.AutoLogin"), Some("0"));
assert_eq!(conf.get("CoaBots.AutoLogin.MaxCount"), Some("2000"));
} else {
assert_eq!(conf.get("AiPlayerbot.Enabled"), Some("1"));
assert_eq!(conf.get("AiPlayerbot.RandomBotAutologin"), Some("0"));
assert_eq!(conf.get("AiPlayerbot.BotAutologin"), Some("0"));
assert_eq!(conf.get("AiPlayerbot.DeleteRandomBotAccounts"), Some("0"));
}
}
restore(&root, &meta).unwrap();
for rel in bot_files() {
assert_eq!(
fs::read(root.join(&rel)).unwrap(),
if rel.contains("mod_coa_playerbots.") {
companion.as_slice()
} else {
squid.as_slice()
}
);
}
}
#[test]
fn validation_removes_only_module_configs_created_during_the_check() {
let (_dir, root, meta) = fixture();
let dist = root.join("Core/configs/modules/mod_coa_playerbots.conf.dist");
let active = root.join("Core/configs/modules/mod_coa_playerbots.conf");
let original = b"CoaBots.AutoLoginOnStartup = 1\n";
fsx::atomic_write(&dist, original).unwrap();
begin(&root, &meta).unwrap();
fs::copy(&dist, &active).unwrap();
restore(&root, &meta).unwrap();
assert!(!active.exists());
assert_eq!(fs::read(dist).unwrap(), original);
}
#[test]
fn previous_manager_journals_remain_recoverable() {
for without_reborn in [false, true] {
let (_dir, root, meta) = fixture();
begin(&root, &meta).unwrap();
let journal = meta.join("validation-configs.json");
let mut saved: BTreeMap<String, Saved> = fsx::read_json(&journal).unwrap();
saved.retain(|key, _| FILES.contains(&key.as_str()));
if without_reborn {
saved.remove("Settings/realm-profiles/reborn.json");
}
fsx::atomic_write_json(&journal, &saved).unwrap();
restore(&root, &meta).unwrap();
assert!(!pending(&meta));
}
}
#[test]
fn incomplete_bot_journal_blocks_restoration_before_writing() {
let (_dir, root, meta) = fixture();
begin(&root, &meta).unwrap();
let journal = meta.join("validation-configs.json");
let mut saved: BTreeMap<String, Saved> = fsx::read_json(&journal).unwrap();
saved.remove(&bot_files()[0]);
fsx::atomic_write_json(&journal, &saved).unwrap();
let before = fs::read(root.join(FILES[2])).unwrap();
assert!(restore(&root, &meta).is_err());
assert_eq!(fs::read(root.join(FILES[2])).unwrap(), before);
}
}