AskaEth
50b321ec64
P2-1（本轮新引入的回归）：`pending` 只在 LaunchStarted 清除，但 `launch::start`
的两条早失败出口（build_request 失败 / spawn 失败——没装 Java、版本 JSON 坏就是
这两条）只发 LaunchEnd → pending 永久残留 → `in_flight` 恒真 → 该实例本会话再也
启动不了，磁贴锁在「启动中」。修：LaunchEnd 分支先 `pending.remove`，早失败与
正常收尾都释放。
P2-2（failed 零 insert）：上一轮只在 note 里声称「失败原因进 failed 表」，代码没
落地（唯一 insert 缺失，refresh 的 Failed 分支是死代码，test 6 还靠手动塞表绕过）。
修：LaunchEnd 非 Ok 时 `failed.insert(id, summary)`、Ok 时 remove；refresh_instances
的 Failed 分支从此由真实路径喂数据。
测试（123 → 124，全部走真实入口）：
- 新增 `launch_end_before_launch_started_still_releases_the_instance`：mark_pending
→ handle(LaunchEnd Crashed) → pending 空、in_flight 假、refresh 后磁贴是
Failed{reason}（同时钉住 P2-1 与 P2-2）。
- test 6 重写：Busy 断言改走 `mark_pending`（start_launch 用的同一入口），Failed
断言改走 `handle(LaunchEnd Crashed)`，不再手动塞 failed 表。
- 所有测试的数据根加 `TempRoot` Drop 守卫，跑完不留临时目录。
342 lines
12 KiB
Rust
342 lines
12 KiB
Rust
//! 真实后端：把 core（game/launch/install/auth/java/diagnose/setting）装配成 GUI 的 host。
|
||
//!
|
||
//! 边界：本模块是整个 app 里**唯一**允许 `use unlucky_core::…` 的地方（连同 `settings_bridge`）；
|
||
//! 出口只有 [`crate::dto`] 的快照/事件。线程模型：
|
||
//!
|
||
//! ```text
|
||
//! dispatch(AppCommand) ──► 立即动作（读盘/写设置）或 spawn 后台线程
|
||
//! 后台线程 ──HostTask──► rx ──tick()──► CoreEvent ──► state.apply()
|
||
//! tick() 另外每 ~600ms 尾随一次运行中会话的 JSONL（实时日志滚动）
|
||
//! ```
|
||
//!
|
||
//! AI 对话暂时仍由 [`MockBackend`] 提供脚本回复（agent 的 GUI host 是后续 mission）；
|
||
//! 其余页面全部走真实 core。
|
||
|
||
mod accounts;
|
||
mod dispatch;
|
||
mod engine;
|
||
pub mod env;
|
||
mod game;
|
||
mod handle;
|
||
mod identity;
|
||
mod install;
|
||
mod java;
|
||
mod job;
|
||
mod launch;
|
||
mod logs;
|
||
mod meter;
|
||
mod settings;
|
||
mod versions;
|
||
|
||
use std::collections::{BTreeMap, BTreeSet, VecDeque};
|
||
use std::time::Duration;
|
||
|
||
use crate::dto::{
|
||
AccountView, AppCommand, AppEvent, Backend, CoreEvent, DiagnosisReport, InstallProgressView,
|
||
InstanceRuntime, JavaChainStep, NoticeView,
|
||
};
|
||
use crate::mock::MockBackend;
|
||
use crate::toast::{Toast, ToastKind};
|
||
|
||
use accounts::LoginJob;
|
||
pub use env::HostEnv;
|
||
use job::{HostTask, JobReceiver, JobSender};
|
||
|
||
/// 每拍最多处理的后台消息数（防止一次 tick 吃掉整帧预算）。
|
||
const MAX_TASKS_PER_TICK: usize = 64;
|
||
|
||
/// 实时日志尾随间隔（拍数，33ms/拍 → 约 600ms 一次）。
|
||
const TAIL_POLL_TICKS: u64 = 18;
|
||
|
||
/// 一次在跑的启动（并发启动时按实例 id 区分，停止/尾随都不会串到别的实例）。
|
||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||
struct LiveLaunch {
|
||
instance: String,
|
||
session: String,
|
||
pid: u32,
|
||
}
|
||
|
||
/// 真实 host。
|
||
pub struct CoreHost {
|
||
env: HostEnv,
|
||
events: VecDeque<AppEvent>,
|
||
tx: JobSender,
|
||
rx: JobReceiver,
|
||
ticks: u64,
|
||
/// 当前启动账户 id（内存态；跨会话持久化要 core schema 增键，见 handoff）
|
||
active_account: Option<String>,
|
||
accounts: Vec<AccountView>,
|
||
login: Option<LoginJob>,
|
||
java_chain: Vec<JavaChainStep>,
|
||
java_busy: bool,
|
||
java_message: String,
|
||
install: Option<InstallProgressView>,
|
||
notices: Vec<NoticeView>,
|
||
/// 在跑的启动（实例 → 会话 → pid；支持多个实例同时启动，停止按 id 找正确的 pid）
|
||
launches: Vec<LiveLaunch>,
|
||
/// 已受理但后台线程还没回报 `LaunchStarted` 的实例（防「启动中重复点启动」起第二个进程）
|
||
pending: BTreeSet<String>,
|
||
/// 上次启动失败的实例与原因（刷新快照时保住磁贴的「失败/重试」外观）
|
||
failed: BTreeMap<String, String>,
|
||
/// 实时日志尾随器
|
||
tail: logs::Tail,
|
||
/// AI 对话的临时后端（agent GUI host 落地前的占位）
|
||
chat: MockBackend,
|
||
/// 当前安装任务的取消标记（阶段边界检查）
|
||
install_cancel: Option<std::sync::Arc<std::sync::atomic::AtomicBool>>,
|
||
}
|
||
|
||
impl CoreHost {
|
||
/// 按便携数据根装配；解析不出数据根返回 `None`（调用方退回 mock）。
|
||
pub fn open() -> Option<Self> {
|
||
HostEnv::resolve().map(Self::new)
|
||
}
|
||
|
||
/// 用给定环境装配（截图/单测通道）。
|
||
pub fn new(env: HostEnv) -> Self {
|
||
Self::build(env, true)
|
||
}
|
||
|
||
/// 单测用：不跑 `refresh_all`（不起版本清单网络线程），其余装配一致。
|
||
#[cfg(test)]
|
||
pub(crate) fn headless(env: HostEnv) -> Self {
|
||
Self::build(env, false)
|
||
}
|
||
|
||
fn build(env: HostEnv, refresh: bool) -> Self {
|
||
let (tx, rx) = job::channel();
|
||
game::ensure_root(&env);
|
||
let mut host = Self {
|
||
env,
|
||
events: VecDeque::new(),
|
||
tx,
|
||
rx,
|
||
ticks: 0,
|
||
active_account: None,
|
||
accounts: Vec::new(),
|
||
login: None,
|
||
java_chain: Vec::new(),
|
||
java_busy: false,
|
||
java_message: String::new(),
|
||
install: None,
|
||
notices: Vec::new(),
|
||
launches: Vec::new(),
|
||
pending: BTreeSet::new(),
|
||
failed: BTreeMap::new(),
|
||
tail: logs::Tail::default(),
|
||
chat: MockBackend::default(),
|
||
install_cancel: None,
|
||
};
|
||
if refresh {
|
||
host.refresh_all();
|
||
}
|
||
host
|
||
}
|
||
|
||
/// 数据根（截图/诊断展示用）。
|
||
pub fn env(&self) -> &HostEnv {
|
||
&self.env
|
||
}
|
||
|
||
fn send(&mut self, event: CoreEvent) {
|
||
self.events.push_back(AppEvent::Core(event));
|
||
}
|
||
|
||
fn toast(&mut self, kind: ToastKind, text: impl Into<String>) {
|
||
self.events.push_back(AppEvent::Toast(Toast {
|
||
id: 0,
|
||
kind,
|
||
text: text.into(),
|
||
remaining_ms: 0,
|
||
}));
|
||
}
|
||
|
||
/// 全量刷新：实例 / 会话 / 账户 / 设置 / Java，并触发一次版本清单拉取。
|
||
pub fn refresh_all(&mut self) {
|
||
self.refresh_instances();
|
||
self.send(CoreEvent::LogSessionsChanged(logs::sessions(&self.env)));
|
||
self.refresh_accounts();
|
||
self.send(CoreEvent::SettingsChanged(settings::groups(&self.env)));
|
||
self.refresh_java();
|
||
versions::spawn_list(self.env.clone(), self.tx.clone());
|
||
}
|
||
|
||
/// 重建实例快照，并把**真实运行时**盖回去。
|
||
///
|
||
/// `game::instances` 只读盘（每条都是 `Idle`），所以在跑的实例必须在重建后按
|
||
/// host 自己的启动表覆写 `Running{pid}`/`Busy`，否则任意一次刷新（装版本成功、
|
||
/// 加删账户、另一实例收尾）都会把磁贴打回 Idle：停止键与「运行中」条消失，
|
||
/// 进程还在跑却再也停不下来。
|
||
fn refresh_instances(&mut self) {
|
||
let mut instances = game::instances(&self.env);
|
||
for instance in &mut instances {
|
||
if let Some(live) = self
|
||
.launches
|
||
.iter()
|
||
.find(|live| live.instance == instance.id)
|
||
{
|
||
instance.runtime = InstanceRuntime::Running { pid: live.pid };
|
||
} else if self.pending.contains(&instance.id) {
|
||
instance.runtime = InstanceRuntime::Busy {
|
||
stage: crate::dto::LaunchStage::Launch,
|
||
progress: crate::dto::Progress { done: 0, total: 1 },
|
||
};
|
||
} else if let Some(reason) = self.failed.get(&instance.id) {
|
||
instance.runtime = InstanceRuntime::Failed {
|
||
reason: reason.clone(),
|
||
};
|
||
}
|
||
}
|
||
self.send(CoreEvent::InstancesChanged(instances));
|
||
}
|
||
|
||
fn refresh_accounts(&mut self) {
|
||
self.accounts = accounts::accounts(&self.env, self.active_account.as_deref());
|
||
if self.active_account.is_none() {
|
||
// 默认选中第一个账户（没有账户时保持 None = 离线占位）
|
||
self.active_account = self.accounts.first().map(|account| account.id.clone());
|
||
self.accounts = accounts::accounts(&self.env, self.active_account.as_deref());
|
||
}
|
||
self.send(CoreEvent::AccountsChanged(self.accounts.clone()));
|
||
}
|
||
|
||
fn refresh_java(&mut self) {
|
||
let page = java::page(
|
||
&self.env,
|
||
self.java_chain.clone(),
|
||
self.java_busy,
|
||
&self.java_message,
|
||
);
|
||
self.send(CoreEvent::JavaChanged(page));
|
||
}
|
||
|
||
fn push_notice(&mut self, notice: NoticeView) {
|
||
self.notices.retain(|existing| existing.id != notice.id);
|
||
self.notices.push(notice);
|
||
self.send(CoreEvent::NoticesChanged(self.notices.clone()));
|
||
}
|
||
|
||
/// 打开一个会话（日志行 + 诊断）。
|
||
fn open_session(&mut self, id: &str) {
|
||
let (lines, diagnosis) = logs::open(&self.env, id);
|
||
self.send(CoreEvent::LogLinesChanged(lines));
|
||
self.send(CoreEvent::DiagnosisReady(diagnosis.unwrap_or(
|
||
DiagnosisReport {
|
||
session: id.to_string(),
|
||
diagnosis: crate::dto::Diagnosis {
|
||
rule: String::new(),
|
||
title: "该会话没有命中已知规则".to_string(),
|
||
confidence: 0,
|
||
hint: "可点「让 AI 详解」把日志交给模型进一步分析".to_string(),
|
||
fix: None,
|
||
},
|
||
},
|
||
)));
|
||
}
|
||
|
||
/// 由实例名/版本 id 找启动目标。
|
||
fn launch_target(&self, id: &str) -> Option<launch::LaunchTarget> {
|
||
let instance = game::instances(&self.env)
|
||
.into_iter()
|
||
.find(|instance| instance.id == id || instance.name == id)?;
|
||
Some(launch::LaunchTarget {
|
||
id: instance.id,
|
||
name: instance.name,
|
||
version_id: instance.version_id,
|
||
account: self.active_account.clone(),
|
||
})
|
||
}
|
||
|
||
/// 某实例是否已在启动/运行（`pending` 与 `launches` 的并集）。
|
||
///
|
||
/// 只查 `launches` 不够：`launch::start` 到后台线程回报 `LaunchStarted` 之间有窗口，
|
||
/// 这期间重复点启动会起第二个进程、并把旧 pid 在启动表里顶掉（旧进程变孤儿）。
|
||
fn in_flight(&self, key: &str) -> bool {
|
||
self.pending.contains(key) || self.launches.iter().any(|live| live.instance == key)
|
||
}
|
||
|
||
/// 标记「已受理、等后台线程回报」（`launch::start` 之后的窗口）。
|
||
///
|
||
/// 单测也走这个入口而不是直接改 `pending`，保证测的是真实状态流转。
|
||
fn mark_pending(&mut self, id: &str) {
|
||
self.pending.insert(id.to_string());
|
||
self.failed.remove(id);
|
||
}
|
||
|
||
fn start_launch(&mut self, id: &str) {
|
||
if self.in_flight(id) {
|
||
self.toast(ToastKind::Warn, "这个实例已经在启动/运行中");
|
||
return;
|
||
}
|
||
let Some(target) = self.launch_target(id) else {
|
||
self.toast(ToastKind::Error, format!("找不到实例 {id}"));
|
||
return;
|
||
};
|
||
let instance_id = target.id.clone();
|
||
if self.in_flight(&instance_id) {
|
||
self.toast(ToastKind::Warn, "这个实例已经在启动/运行中");
|
||
return;
|
||
}
|
||
self.mark_pending(&instance_id);
|
||
if let Some(notice) = game::mode_change_notice(&self.env, &instance_id) {
|
||
self.push_notice(notice);
|
||
}
|
||
self.send(CoreEvent::InstanceRuntimeChanged {
|
||
id: instance_id.clone(),
|
||
runtime: InstanceRuntime::Busy {
|
||
stage: crate::dto::LaunchStage::Launch,
|
||
progress: crate::dto::Progress { done: 0, total: 1 },
|
||
},
|
||
});
|
||
launch::start(self.env.clone(), self.tx.clone(), target);
|
||
}
|
||
|
||
/// 某实例在跑的 pid（按实例 id 查启动表；不再有「最近一次启动」这种单槽）。
|
||
///
|
||
/// 兜底分支读实例快照的 `Running { pid }`：host 自己发的运行时事件会写回快照，
|
||
/// 但快照是重建的（`game::instances` 每次 Idle），所以这层只是给将来留的口。
|
||
fn running_pid(&self, id: &str) -> Option<u32> {
|
||
if let Some(live) = self.launches.iter().find(|live| live.instance == id) {
|
||
return Some(live.pid);
|
||
}
|
||
game::instances(&self.env)
|
||
.into_iter()
|
||
.find(|instance| instance.id == id)
|
||
.and_then(|instance| match instance.runtime {
|
||
InstanceRuntime::Running { pid } => Some(pid),
|
||
_ => None,
|
||
})
|
||
}
|
||
}
|
||
|
||
impl Backend for CoreHost {
|
||
fn drain_events(&mut self) -> Vec<AppEvent> {
|
||
self.events.drain(..).collect()
|
||
}
|
||
|
||
fn dispatch(&mut self, command: AppCommand) {
|
||
self.dispatch_command(command);
|
||
}
|
||
|
||
fn tick(&mut self, elapsed: Duration) {
|
||
self.chat.tick(elapsed);
|
||
for event in self.chat.drain_events() {
|
||
self.events.push_back(event);
|
||
}
|
||
for _ in 0..MAX_TASKS_PER_TICK {
|
||
let Ok(task) = self.rx.try_recv() else {
|
||
break;
|
||
};
|
||
self.handle(task);
|
||
}
|
||
self.ticks += 1;
|
||
if self.ticks.is_multiple_of(TAIL_POLL_TICKS) {
|
||
self.poll_tail();
|
||
}
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
#[path = "launch_state_tests.rs"]
|
||
mod launch_state_tests;
|