Compare commits

..
5 changed files with 50 additions and 58 deletions

No files matched your search

@@ -1,7 +0,0 @@
---
area: manager
type: fixed
audience: admins
title: Diagnostics record blocked startup requests and maintenance owner information
---
A start refused before the launcher runs is now logged with its reason. Exported diagnostics include the last recorded maintenance owner, while clearly distinguishing old metadata from a currently held operating-system lock.
@@ -0,0 +1,7 @@
---
area: manager
type: fixed
audience: admins
title: Starting the server waits for update checks and identifies ongoing maintenance
---
Downloading an update manifest no longer blocks startup. A start waits up to 30 seconds for a check to finish; other active maintenance still blocks it safely and shows its operation, process and start time.
-15
View File
@@ -347,15 +347,6 @@ pub fn export_package(root: &Path, meta_dir: &Path, manager_log: &Path, meta: &I
"wow_client_set": meta.client_path.is_some(),
});
add("summary.json", serde_json::to_string_pretty(&summary)?.as_bytes())?;
let owner = fs::read_to_string(meta_dir.join("update-lock-owner.json")).ok()
.and_then(|text| serde_json::from_str::<serde_json::Value>(&redact_json(&text)).ok());
let maintenance = serde_json::json!({
"lockFilePresent": meta_dir.join("update.lock").is_file(),
"lastRecordedOwner": owner,
"note": "The lock file and owner record may remain after completion. Their presence does not establish whether the OS lock is currently held."
});
add("maintenance.json", serde_json::to_string_pretty(&maintenance)?.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![
@@ -608,8 +599,6 @@ real error
fs::write(root.join("Core/configs/worldserver.conf"), "LoginDatabaseInfo = \"127.0.0.1;3307;acore;SECRETPW;auth\"\nRate.XP.Kill = 1\n").unwrap();
let meta_dir = d.path().join("srv.manager");
fs::create_dir_all(&meta_dir).unwrap();
fs::write(meta_dir.join("update.lock"), b"").unwrap();
fs::write(meta_dir.join("update-lock-owner.json"), r#"{"operation":"checking updates","pid":1234,"started":"2026-10-13T01:00:00Z","token":"owner-secret"}"#).unwrap();
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();
@@ -631,10 +620,6 @@ real error
assert!(!all.contains("schema-secret"));
assert!(all.contains("user_character_trigger") && all.contains("acore_characters"));
assert!(!all.contains("recovery-secret"));
assert!(all.contains("checking updates") && all.contains("1234"));
assert!(all.contains("lockFilePresent") && all.contains("does not establish"));
assert!(!all.contains("owner-secret"));
assert_eq!(fs::read(meta_dir.join("update.lock")).unwrap(), b"");
assert!(!all.contains("hunter2") && !all.contains("SECRETPW") && !all.contains("upstream-secret"));
}
}
+2 -32
View File
@@ -90,12 +90,7 @@ 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> {
tracing::info!(?verb, root = %root.display(), "driver: launcher requested");
let result = run_inner(root, verb, false);
if let Err(error) = &result {
tracing::warn!(?verb, root = %root.display(), %error, "driver: launcher request failed before completion");
}
result
run_inner(root, verb, false)
}
pub(crate) fn validate_update(root: &Path) -> Result<DriverOutcome> {
@@ -105,7 +100,7 @@ pub(crate) fn validate_update(root: &Path) -> Result<DriverOutcome> {
fn run_inner(root: &Path, verb: Verb, validating_update: bool) -> Result<DriverOutcome> {
let root = fsx::canonicalize_lenient(root)?;
let _update_lock = if !validating_update && matches!(verb, Verb::StartAll | Verb::StartWorld) {
Some(crate::update::operation_lock(&crate::registry::metadata_dir_for(&root)?)?)
Some(crate::update::operation_lock_for(&crate::registry::metadata_dir_for(&root)?, "starting server", true)?)
} else { None };
if !validating_update && matches!(verb, Verb::StartAll | Verb::StartWorld) {
crate::update::ensure_recovered(&crate::registry::metadata_dir_for(&root)?)?;
@@ -292,31 +287,6 @@ pub(crate) fn startup_failure(root: &Path, started: &DriverOutcome) -> String {
mod tests {
use super::*;
#[test]
fn a_blocked_start_is_logged_before_any_launcher_is_spawned() {
use std::io::Write;
use std::sync::{Arc, Mutex};
struct Capture(Arc<Mutex<Vec<u8>>>);
impl Write for Capture {
fn write(&mut self, bytes: &[u8]) -> std::io::Result<usize> { self.0.lock().unwrap().extend_from_slice(bytes); Ok(bytes.len()) }
fn flush(&mut self) -> std::io::Result<()> { Ok(()) }
}
let temp = tempfile::tempdir().unwrap();
let root = temp.path().join("server");
std::fs::create_dir(&root).unwrap();
let metadata = crate::registry::metadata_dir_for(&root).unwrap();
let _maintenance = crate::update::operation_lock(&metadata).unwrap();
let buffer = Arc::new(Mutex::new(Vec::new()));
let writer = Arc::clone(&buffer);
let subscriber = tracing_subscriber::fmt().without_time().with_ansi(false).with_writer(move || Capture(Arc::clone(&writer))).finish();
let error = tracing::subscriber::with_default(subscriber, || run(&root, Verb::StartAll)).unwrap_err();
assert!(error.to_string().contains("in progress"));
let text = String::from_utf8(buffer.lock().unwrap().clone()).unwrap();
assert!(text.contains("launcher requested") && text.contains("StartAll"));
assert!(text.contains("launcher request failed before completion") && text.contains("in progress"));
assert!(!text.contains("starting launcher verb"));
}
#[test]
fn background_start_disables_cli_in_template_and_rendered_config() {
let folder = tempfile::tempdir().unwrap();
+41 -4
View File
@@ -308,9 +308,12 @@ pub fn preview(root: &Path, meta: &InstallMeta, source: &Source, trusted_key: &s
pub fn preview_with(root: &Path, meta: &InstallMeta, source: &Source, trusted_key: &str, resolutions: &BTreeMap<String, Resolution>, access: DatabaseAccess) -> Result<Preview> {
refuse_for_docker(root)?;
let meta_dir = crate::registry::metadata_dir_for(root)?;
let _lock = operation_lock(&meta_dir)?;
ensure_recovered(&meta_dir)?;
let observed_version = MetaDir::open(&meta_dir)?.1.core.version;
let (m, _) = fetch_manifest(source, trusted_key)?;
let _lock = operation_lock_for(&meta_dir, "checking updates", false)?;
ensure_recovered(&meta_dir)?;
let (_, current_meta) = MetaDir::open(&meta_dir)?;
let meta = if current_meta.core.version != observed_version { &current_meta } else { meta };
check_manifest(&m)?;
reject_downgrade(meta, &m)?;
let mut items = plan(root, meta, &m, resolutions, None)?;
@@ -780,11 +783,26 @@ pub fn rollback(root: &Path, meta_dir: &Path, id: &str, env: &dyn Env) -> Result
}
pub(crate) fn operation_lock(meta_dir: &Path) -> Result<fs::File> {
operation_lock_for(meta_dir, "server maintenance", false)
}
pub(crate) fn operation_lock_for(meta_dir: &Path, operation: &str, wait_for_check: bool) -> Result<fs::File> {
fs::create_dir_all(meta_dir)?;
let lock = fs::OpenOptions::new().read(true).write(true).create(true).truncate(false).open(meta_dir.join("update.lock"))?;
if !fs4::fs_std::FileExt::try_lock_exclusive(&lock)? {
return Err(Error::Invalid("Another update, repair or recovery is in progress.".into()));
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(30);
loop {
if fs4::fs_std::FileExt::try_lock_exclusive(&lock)? { break; }
let owner = fsx::read_json::<serde_json::Value>(&meta_dir.join("update-lock-owner.json")).ok();
let checking = owner.as_ref().and_then(|owner| owner.get("operation")).and_then(|value| value.as_str()) == Some("checking updates");
if wait_for_check && checking && std::time::Instant::now() < deadline {
std::thread::sleep(std::time::Duration::from_millis(100));
continue;
}
let details = owner.as_ref().and_then(|owner| Some(format!(" Operation: {}; Manager process: {}; started: {}.", owner.get("operation")?.as_str()?, owner.get("pid")?.as_u64()?, owner.get("started")?.as_str()?))).unwrap_or_default();
return Err(Error::Invalid(format!("Another update, repair or recovery is in progress.{details} Wait for that operation to finish, then retry.")));
}
let record = serde_json::json!({"operation": operation, "pid": std::process::id(), "started": chrono::Utc::now().to_rfc3339()});
fsx::atomic_write_json(&meta_dir.join("update-lock-owner.json"), &record)?;
Ok(lock)
}
@@ -1358,6 +1376,25 @@ mod tests {
w
}
#[test]
fn startup_waits_for_an_update_check_but_not_for_active_maintenance() {
let temp = tempfile::tempdir().unwrap();
let checker = operation_lock_for(temp.path(), "checking updates", false).unwrap();
let root = temp.path().to_path_buf();
let release = std::thread::spawn(move || {
std::thread::sleep(std::time::Duration::from_millis(150));
drop(checker);
});
let start = operation_lock_for(&root, "starting server", true).unwrap();
release.join().unwrap();
let error = operation_lock(&root).unwrap_err().to_string();
assert!(error.contains("starting server"));
assert!(error.contains(&std::process::id().to_string()));
drop(start);
// Stale owner metadata is harmless once the OS lock is released.
operation_lock(&root).unwrap();
}
#[test]
fn legacy_manager_realm_launcher_is_replaced_during_update() {
let w = legacy_launcher_world(false);