Merge Manager 0.9.14 (master) into the Modules Preview

Brings the rest of Manager 0.9.14: multi-realm playerbots, Companions on
Wildcard/Reborn, and the reviewed 0.9.14 notes. Preview 0.9.14 keeps its own
name, identifier and updater; installing the current stable server needs
Manager 0.9.13 or newer, which 0.9.11/0.9.12 could not meet.

modules.rs: Companions follow master's per-build Wildcard/Reborn rule; the
version shown still comes from the plugin registry first.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
ДмитрийandClaude Opus 5.5 committed 2026-11-17 07:42:32 +05:00
commit d087d65444
24 files changed
+3313 -568

No files matched your search

+213 -88
View File
@@ -631,25 +631,53 @@ async fn start_server(
let out = blocking(move || driver::run(&root, Verb::StartAll)).await?;
if out.ok {
if let Ok(root) = path_of(&state, &id) {
// Companions requested while the server was stopped are created now (once; a failure is only logged).
// Companions requested while the server was stopped are reconciled and created now per realm.
let r = root.clone();
let instance_id = id.clone();
let _ = tauri::async_runtime::spawn_blocking(move || -> Result<()> {
if coa_core::realms::guard_module(&r, "companions").is_err() {
return Ok(());
}
let pending = meta_dir(&r)?.join("companions.pending.json");
if let Ok(v) = coa_core::fsx::read_json::<serde_json::Value>(&pending) {
let _ = std::fs::remove_file(&pending);
let n = v["count"].as_u64().unwrap_or(0) as u32;
if n > 0 {
let made = coa_core::db::Db::from_repack(&r, coa_core::db::Account::Admin)
.and_then(|db| coa_core::companions::ensure_templates(&db));
if let Err(e) = made
.and_then(|_| Ra::connect(&r))
.and_then(|mut ra| ra.spawn_bots(n))
{
tracing::warn!("pending companions were not created: {e}");
let meta = meta_dir(&r)?;
if let Err(e) = coa_core::companions::migrate_legacy_pending_job(&meta, &instance_id) {
tracing::warn!("failed to migrate legacy pending companions job: {e}");
}
for mode in [
coa_core::realms::Mode::Coa,
coa_core::realms::Mode::Wildcard,
coa_core::realms::Mode::Reborn,
] {
let target = match coa_core::multiworld::resolve_bot_operation_target(&r, mode) {
Ok(t) => t,
Err(e) => {
tracing::warn!("cannot resolve target for realm {}: {e}", mode.name());
continue;
}
};
let r_snap = r.clone();
let chars_db = target.chars_db;
let r_ra = r.clone();
let res = coa_core::companions::process_pending_job_with(
&meta,
mode,
&instance_id,
target.running,
|since_guid| {
let admin_db = coa_core::db::Db::from_repack(&r_snap, coa_core::db::Account::Admin)?;
let _ = coa_core::companions::ensure_templates_for_schema(&admin_db, chars_db);
coa_core::companions::query_bot_db_snapshot(&r_snap, &admin_db, chars_db, since_guid)
},
|delta, job| {
let mut ra = Ra::connect_target(&r_ra, Some(mode))?;
if let Some(lvl) = job.level {
ra.spawn_custom(delta, lvl, job.class_id, job.spec_id, job.build_id.as_deref())
} else {
ra.spawn_bots(delta)
}
},
);
if let Err(e) = res {
tracing::warn!("pending companions for realm {} failed during reconciliation: {e}", mode.name());
}
}
Ok(())
@@ -2040,6 +2068,7 @@ async fn retry_update_validation(
async fn get_population(
state: State<'_, AppState>,
id: String,
realm: Option<coa_core::realms::Mode>,
) -> std::result::Result<Option<coa_core::population::Population>, UiError> {
let root = path_of(&state, &id)?;
Ok(tauri::async_runtime::spawn_blocking(move || {
@@ -2047,12 +2076,48 @@ async fn get_population(
if o.mysql.state != coa_core::process::ServiceState::Running {
return None;
}
coa_core::population::query(&root).ok()
if let Some(mode) = realm {
coa_core::population::query_for_realm(&root, mode).ok()
} else {
coa_core::population::query(&root).ok()
}
})
.await
.unwrap_or(None))
}
#[tauri::command]
async fn companions_login_all(
state: State<'_, AppState>,
id: String,
realm: Option<coa_core::realms::Mode>,
) -> std::result::Result<String, UiError> {
let root = path_of(&state, &id)?;
let _guard = BusyGuard::acquire(&state, &id)?;
blocking(move || {
let mut ra = Ra::connect_target(&root, realm)?;
ra.login_all()
})
.await
}
#[tauri::command]
async fn companions_spawn_fleet(
state: State<'_, AppState>,
id: String,
race: u8,
level: u8,
realm: Option<coa_core::realms::Mode>,
) -> std::result::Result<String, UiError> {
let root = path_of(&state, &id)?;
let _guard = BusyGuard::acquire(&state, &id)?;
blocking(move || {
let mut ra = Ra::connect_target(&root, realm)?;
ra.spawn_fleet(race, level)
})
.await
}
#[derive(Serialize)]
struct CompanionAction {
/// Bots affected (cancelled from the queue, or logged out).
@@ -2063,12 +2128,31 @@ struct CompanionAction {
async fn companions_stop_spawning(
state: State<'_, AppState>,
id: String,
realm: Option<coa_core::realms::Mode>,
) -> std::result::Result<CompanionAction, UiError> {
let root = path_of(&state, &id)?;
blocking(move || {
Ok(CompanionAction {
count: Ra::connect(&root)?.cancel_spawning()?,
})
let mode = realm.unwrap_or_else(|| {
coa_core::realms::view(&root).map(|v| v.active).unwrap_or_default()
});
let meta = meta_dir(&root)?;
let cancelled_pending = coa_core::companions::cancel_pending_job(&meta, mode.name())
.ok()
.flatten();
match Ra::connect_target(&root, Some(mode)).and_then(|mut ra| ra.cancel_spawning()) {
Ok(ra_cancelled) => Ok(CompanionAction {
count: ra_cancelled + cancelled_pending.map(|j| j.remaining_count()).unwrap_or(0),
}),
Err(e) => {
if let Some(job) = cancelled_pending {
Ok(CompanionAction {
count: job.remaining_count(),
})
} else {
Err(e)
}
}
}
})
.await
}
@@ -2077,12 +2161,12 @@ async fn companions_stop_spawning(
async fn companions_take_offline(
state: State<'_, AppState>,
id: String,
realm: Option<coa_core::realms::Mode>,
) -> std::result::Result<CompanionAction, UiError> {
let root = path_of(&state, &id)?;
let _guard = BusyGuard::acquire(&state, &id)?;
blocking(move || {
let mut ra = Ra::connect(&root)?;
// Anything still waiting to be created must not come back right after.
let mut ra = Ra::connect_target(&root, realm)?;
let _ = ra.cancel_spawning();
Ok(CompanionAction {
count: ra.despawn_all()?,
@@ -2091,13 +2175,12 @@ async fn companions_take_offline(
.await
}
/// Log `count` randomly chosen online companions out to lower the load. Uses the per-bot command that every server
/// build has, so it works on older builds too.
#[tauri::command]
async fn companions_despawn_some(
state: State<'_, AppState>,
id: String,
count: u32,
realm: Option<coa_core::realms::Mode>,
) -> std::result::Result<CompanionAction, UiError> {
let root = path_of(&state, &id)?;
let _guard = BusyGuard::acquire(&state, &id)?;
@@ -2105,13 +2188,18 @@ async fn companions_despawn_some(
if !(1..=5000).contains(&count) {
return Err(Error::Invalid("Choose a number between 1 and 5000.".into()));
}
let mode = realm.unwrap_or_else(|| {
coa_core::realms::view(&root).map(|v| v.active).unwrap_or_default()
});
let target = coa_core::multiworld::resolve_bot_operation_target(&root, mode)?;
let prefix = coa_core::population::bot_account_prefix(&root).to_uppercase();
let db = coa_core::db::Db::from_repack(&root, coa_core::db::Account::App)?;
let rows = db.query(&format!(
"SELECT c.guid FROM acore_characters.characters c JOIN acore_auth.account a ON a.id=c.account WHERE c.online=1 AND UPPER(a.username) LIKE '{prefix}%' ORDER BY RAND() LIMIT {count};"
"SELECT c.guid FROM {}.characters c JOIN acore_auth.account a ON a.id=c.account WHERE c.online=1 AND UPPER(a.username) LIKE '{prefix}%' ORDER BY RAND() LIMIT {count};",
target.chars_db
))?;
let guids: Vec<u64> = rows.lines().filter_map(|l| l.trim().parse().ok()).collect();
let mut ra = Ra::connect(&root)?;
let mut ra = Ra::connect_target(&root, Some(mode))?;
let mut done = 0;
for g in guids {
if ra.despawn_bot(g).unwrap_or(false) {
@@ -2123,31 +2211,36 @@ async fn companions_despawn_some(
.await
}
/// Delete every companion for good. A recovery point of the characters and accounts is saved first.
#[tauri::command]
async fn companions_delete_all(
app: AppHandle,
state: State<'_, AppState>,
id: String,
realm: Option<coa_core::realms::Mode>,
) -> std::result::Result<CompanionAction, UiError> {
let root = path_of(&state, &id)?;
let _guard = BusyGuard::acquire(&state, &id)?;
blocking(move || {
let mode = realm.unwrap_or_else(|| {
coa_core::realms::view(&root).map(|v| v.active).unwrap_or_default()
});
let target = coa_core::multiworld::resolve_bot_operation_target(&root, mode)?;
let meta = meta_dir(&root)?;
backup::create(
&root,
&meta,
Kind::Quick,
Trigger::BeforeDangerousChange,
Some("before deleting all companions".into()),
Some(format!("before deleting all {} companions", target.realm.label())),
&|step| {
let _ = app.emit("backup-progress", step);
},
)?;
let before = coa_core::population::query(&root)
let before = coa_core::population::query_for_realm(&root, mode)
.map(|p| p.bots_total)
.unwrap_or(0);
let mut ra = Ra::connect(&root)?;
let _ = coa_core::companions::cancel_pending_job(&meta, mode.name());
let mut ra = Ra::connect_target(&root, Some(mode))?;
let _ = ra.cancel_spawning();
ra.purge_all()?;
Ok(CompanionAction { count: before })
@@ -2203,6 +2296,11 @@ async fn add_companions(
state: State<'_, AppState>,
id: String,
count: u32,
realm: Option<coa_core::realms::Mode>,
level: Option<u8>,
class_id: Option<u8>,
spec_id: Option<u32>,
archetype: Option<String>,
) -> std::result::Result<CompanionsResult, UiError> {
let root = path_of(&state, &id)?;
let _guard = BusyGuard::acquire(&state, &id)?;
@@ -2212,81 +2310,84 @@ async fn add_companions(
"Choose between 1 and 2000 companions.".into(),
));
}
let mode = realm.unwrap_or_else(|| {
coa_core::realms::view(&root).map(|v| v.active).unwrap_or_default()
});
coa_core::companions::validate_spawn_request(
mode,
count,
level,
class_id,
spec_id,
archetype.as_deref(),
)?;
let target = coa_core::multiworld::resolve_bot_operation_target(&root, mode)?;
if mode == coa_core::realms::Mode::Wildcard {
if let Some(ref arch_id) = archetype {
if !arch_id.trim().is_empty() {
let db = coa_core::db::Db::from_repack(&root, coa_core::db::Account::Admin)?;
let archetypes = coa_core::companions::list_wildcard_archetypes(&db, target.chars_db)?;
if !archetypes.iter().any(|a| a.id.eq_ignore_ascii_case(arch_id.trim())) {
return Err(Error::Invalid(format!(
"Unknown Wildcard build UUID '{}' in {}.coa_build_creator.",
arch_id.trim(),
target.chars_db
)));
}
}
}
}
let meta = meta_dir(&root)?;
let mut changes = BTreeMap::new();
changes.insert("CoaBots.AutoLoginOnStartup".to_string(), Value::Bool(true));
// Every companion, old and new, should come back at the next start, so the start-up limit only ever grows here.
let existing_max = config::load(&root, Scope::Bots)
.ok()
.and_then(|v| {
v.settings
.iter()
.find(|s| s.meta.key == "CoaBots.AutoLogin.MaxCount")
.and_then(|s| s.value.as_u64())
})
let existing_cfg = config::load(&target.world_root, Scope::Bots)?;
let existing_max = existing_cfg
.settings
.iter()
.find(|s| s.meta.key == "CoaBots.AutoLogin.MaxCount")
.and_then(|s| s.value.as_u64())
.unwrap_or(0) as u32;
let already = coa_core::population::query(&root)
let already = coa_core::population::query_for_realm(&root, mode)
.map(|p| p.bots_total)
.unwrap_or(0);
changes.insert(
"CoaBots.AutoLogin.MaxCount".to_string(),
Value::from(existing_max.max(already + count).min(5000)),
);
config::save(&root, &meta, Scope::Bots, &changes)?;
let o = coa_core::process::observe(&root, &layout::read_ports(&root));
// Large batches while the server is stopped: create them in the database right now, fully equipped.
if o.world.state == coa_core::process::ServiceState::Stopped
&& o.auth.state == coa_core::process::ServiceState::Stopped
&& count >= coa_core::companions::OFFLINE_MIN
&& coa_core::companions::offline_factory(&root).is_some()
{
let started_db = o.mysql.state != coa_core::process::ServiceState::Running;
if started_db {
let out = driver::run(&root, Verb::StartMysql)?;
if !out.ok {
return Err(Error::Invalid("The database could not be started.".into()));
}
}
let made = (|| -> Result<()> {
coa_core::companions::ensure_templates(&coa_core::db::Db::from_repack(
&root,
coa_core::db::Account::Admin,
)?)?;
coa_core::companions::offline_create(
&root,
&meta.join("logs").join("companions-offline.log"),
count,
)?;
Ok(())
})();
if started_db {
let _ = driver::run(&root, Verb::StopAll);
}
made?;
tracing::info!(count, "companions created offline");
return Ok(CompanionsResult {
spawned: None,
created: Some(count),
baseline: None,
});
}
config::save(&target.world_root, &meta, Scope::Bots, &changes)?;
let mut baseline = None;
let spawned = if o.world.state == coa_core::process::ServiceState::Running {
// Older servers have no template characters to copy bots from: add them first.
coa_core::companions::ensure_templates(&coa_core::db::Db::from_repack(
&root,
coa_core::db::Account::Admin,
)?)?;
baseline = coa_core::population::query(&root)
let spawned = if target.running {
if let Ok(admin_db) = coa_core::db::Db::from_repack(&root, coa_core::db::Account::Admin) {
let _ = coa_core::companions::ensure_templates_for_schema(&admin_db, target.chars_db);
}
baseline = coa_core::population::query_for_realm(&root, mode)
.ok()
.map(|p| p.bots_total);
Some(Ra::connect(&root)?.spawn_bots(count)?)
let mut ra = Ra::connect_target(&root, Some(mode))?;
if let Some(lvl) = level {
Some(ra.spawn_custom(count, lvl, class_id, spec_id, archetype.as_deref())?)
} else {
Some(ra.spawn_bots(count)?)
}
} else {
// The server is stopped: creating bots needs it running, so remember the request and do it after the next start.
coa_core::fsx::atomic_write_json(
&meta.join("companions.pending.json"),
&serde_json::json!({ "count": count }),
)?;
let _ = coa_core::companions::migrate_legacy_pending_job(&meta, &id);
let mut job = coa_core::companions::CompanionsPendingJob::new(
&id,
mode.name(),
count,
level,
class_id,
spec_id,
archetype.clone(),
);
if let Ok(admin_db) = coa_core::db::Db::from_repack(&root, coa_core::db::Account::Admin) {
if let Ok(snap) = coa_core::companions::query_bot_db_snapshot(&root, &admin_db, target.chars_db, None) {
job.baseline_bot_count = Some(snap.bot_count);
job.baseline_max_guid = Some(snap.max_guid);
}
}
coa_core::companions::save_pending_job(&meta, mode.name(), &job)?;
None
};
tracing::info!(count, spawned = spawned.is_some(), "companions requested");
@@ -2299,6 +2400,27 @@ async fn add_companions(
.await
}
#[tauri::command]
async fn get_wildcard_archetypes(
state: State<'_, AppState>,
id: String,
) -> std::result::Result<Vec<coa_core::companions::WildcardArchetypeDto>, UiError> {
let root = path_of(&state, &id)?;
blocking(move || {
let db = coa_core::db::Db::from_repack(&root, coa_core::db::Account::Admin)?;
let target = coa_core::multiworld::resolve_bot_operation_target(&root, coa_core::realms::Mode::Wildcard)
.unwrap_or_else(|_| coa_core::multiworld::BotOperationTarget {
world_root: root.clone(),
chars_db: "acore_characters_wildcard",
ra_port: 3444,
running: false,
realm: coa_core::realms::Mode::Wildcard,
});
Ok(coa_core::companions::list_wildcard_archetypes(&db, target.chars_db)?)
})
.await
}
const REMOTE_CLIENT_ID: &str = "@remote-client";
fn remote_dir() -> PathBuf {
@@ -3823,10 +3945,13 @@ pub fn run() {
companions_take_offline,
companions_delete_all,
companions_despawn_some,
companions_login_all,
companions_spawn_fleet,
open_link,
report_targets,
companion_sizes,
add_companions,
get_wildcard_archetypes,
remote_connection,
remote_connect,
client_info,