2806 lines
118 KiB
Rust
2806 lines
118 KiB
Rust
use rand::Rng;
|
||
use std::collections::{HashMap, HashSet};
|
||
use std::sync::{Arc, Mutex};
|
||
|
||
// ===================== 日志模块 =====================
|
||
/// 日志文件（Mutex 确保线程安全写入）
|
||
static LOG_FILE: std::sync::Mutex<Option<std::fs::File>> = std::sync::Mutex::new(None);
|
||
|
||
/// 初始化日志文件（启动时清除当天日志，然后以追加方式打开）
|
||
/// 日志目录：exe所在目录/Log/
|
||
fn init_log_file() {
|
||
let mut guard = LOG_FILE.lock().unwrap();
|
||
if guard.is_some() {
|
||
return;
|
||
}
|
||
|
||
let exe_path = match std::env::current_exe() {
|
||
Ok(p) => p,
|
||
Err(_) => return,
|
||
};
|
||
let log_dir = match exe_path.parent() {
|
||
Some(d) => d.join("Updater").join("Log"),
|
||
None => return,
|
||
};
|
||
|
||
// 创建 Log 目录
|
||
let _ = std::fs::create_dir_all(&log_dir);
|
||
|
||
let log_name = format!("Updater_{}.log", chrono::Local::now().format("%Y%m%d"));
|
||
let log_path = log_dir.join(&log_name);
|
||
|
||
// 启动时清除当天的日志文件
|
||
let _ = std::fs::remove_file(&log_path);
|
||
|
||
match std::fs::OpenOptions::new()
|
||
.create(true)
|
||
.append(true)
|
||
.open(&log_path)
|
||
{
|
||
Ok(file) => {
|
||
eprintln!("[日志] 日志文件: {:?}", log_path);
|
||
*guard = Some(file);
|
||
}
|
||
Err(e) => {
|
||
eprintln!("[日志] 无法打开日志文件: {}", e);
|
||
}
|
||
}
|
||
}
|
||
|
||
/// 日志宏：同时输出到控制台和文件
|
||
macro_rules! log_print {
|
||
($($arg:tt)*) => {{
|
||
let msg = format!($($arg)*);
|
||
print!("{}\n", msg);
|
||
std::io::stdout().flush().ok();
|
||
if LOG_FILE.lock().unwrap().is_none() {
|
||
init_log_file();
|
||
}
|
||
if let Some(ref mut file) = *LOG_FILE.lock().unwrap() {
|
||
use std::io::Write;
|
||
let _ = writeln!(file, "{}", msg);
|
||
let _ = file.flush();
|
||
}
|
||
}};
|
||
}
|
||
|
||
/// 错误日志宏：同时输出到控制台stderr和文件（始终记录）
|
||
macro_rules! log_eprintln {
|
||
($($arg:tt)*) => {{
|
||
let msg = format!($($arg)*);
|
||
eprintln!("{}", msg);
|
||
if LOG_FILE.lock().unwrap().is_none() {
|
||
init_log_file();
|
||
}
|
||
if let Some(ref mut file) = *LOG_FILE.lock().unwrap() {
|
||
use std::io::Write;
|
||
let _ = writeln!(file, "{}", msg);
|
||
let _ = file.flush();
|
||
}
|
||
}};
|
||
}
|
||
|
||
// ===================== 更新阶段枚举 =====================
|
||
/// 更新流程的三个阶段
|
||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||
enum UpdatePhase {
|
||
BootLoader, // 阶段1：检查 BootLoader.exe
|
||
Updater, // 阶段2：检查 Updater.exe
|
||
Apps, // 阶段3：检查其他应用版本
|
||
AppsWaitAllFile, // 阶段3.5：等待 GetAllFile 响应
|
||
Complete, // 所有阶段完成
|
||
}
|
||
|
||
// ===================== 更新上下文（局部状态 + Arc 共享）=====================
|
||
/// 更新流程的状态上下文
|
||
/// 使用 Mutex 实现 Sync（即使单线程也需要满足 Rust 的线程安全约束）
|
||
struct UpdateContext {
|
||
/// 当前正在下载的文件状态
|
||
download_state: Mutex<Option<DownloadState>>,
|
||
/// 其他应用下载状态：key = "app_name/relative_path"
|
||
app_download_map: Mutex<HashMap<String, DownloadState>>,
|
||
/// 其他应用更新完成标记：set of "app_name/relative_path"
|
||
app_completed_set: Mutex<HashSet<String>>,
|
||
/// Updater.exe 的服务端版本号
|
||
server_updater_version: Mutex<Option<String>>,
|
||
/// 当前更新阶段
|
||
current_phase: Mutex<UpdatePhase>,
|
||
/// 候选应用列表 (app_name, local_version, exe_path)，阶段3使用
|
||
candidates: Mutex<Vec<(String, String, String)>>,
|
||
/// 等待 GetAllFile 响应的应用列表（阶段3.5使用）
|
||
pending_allfile_apps: Mutex<Vec<String>>,
|
||
/// 待下载队列 (app_name, filename, offset, expected_md5)，顺序下载
|
||
download_queue: Mutex<std::collections::VecDeque<(String, String, u64, String)>>,
|
||
/// 是否正在下载中（队列中有待处理项）
|
||
is_downloading: Mutex<bool>,
|
||
/// 当前正在下载的文件的期望 MD5（DownloadComplete 校验用）
|
||
current_download_md5: Mutex<Option<String>>,
|
||
/// 已升级的应用列表 (app_name, current_ver, latest_ver, exe_path)，下载完成后通知用
|
||
upgraded_apps: Mutex<Vec<(String, String, String, String)>>,
|
||
}
|
||
|
||
impl Default for UpdateContext {
|
||
fn default() -> Self {
|
||
Self {
|
||
download_state: Mutex::new(None),
|
||
app_download_map: Mutex::new(HashMap::new()),
|
||
app_completed_set: Mutex::new(HashSet::new()),
|
||
server_updater_version: Mutex::new(None),
|
||
current_phase: Mutex::new(UpdatePhase::BootLoader),
|
||
candidates: Mutex::new(Vec::<(String, String, String)>::new()),
|
||
pending_allfile_apps: Mutex::new(Vec::new()),
|
||
download_queue: Mutex::new(std::collections::VecDeque::new()),
|
||
is_downloading: Mutex::new(false),
|
||
current_download_md5: Mutex::new(None),
|
||
upgraded_apps: Mutex::new(Vec::new()),
|
||
}
|
||
}
|
||
}
|
||
use serde::{Deserialize, Serialize};
|
||
use std::fs::{self, File};
|
||
use std::io::Read;
|
||
use std::path::PathBuf;
|
||
use std::pin::Pin;
|
||
use std::process::Command;
|
||
use std::io::Write as StdWrite;
|
||
use std::io::Seek;
|
||
|
||
use base64::{Engine as _, engine::general_purpose::STANDARD as BASE64};
|
||
use cube_lib::websocket::{WebSocketClient, WebSocketConfig};
|
||
|
||
// ===================== 文件下载状态 =====================
|
||
struct DownloadState {
|
||
filename: String,
|
||
offset: u64,
|
||
temp_path: Option<PathBuf>,
|
||
file: Option<File>,
|
||
}
|
||
|
||
// ===================== 命名管道服务端 =====================
|
||
/// 固定管道名称（单实例运行，直接用此名称）
|
||
const PIPE_NAME: &str = r"\\.\pipe\Updater";
|
||
|
||
/// 从命名管道读取一行消息（阻塞，需在 spawn_blocking 中调用）
|
||
fn read_pipe_message(pipe: windows::Win32::Foundation::HANDLE, debug: bool) -> Option<String> {
|
||
use windows::Win32::Storage::FileSystem::ReadFile;
|
||
|
||
let mut buf = [0u8; 4096];
|
||
let mut bytes_read: u32 = 0;
|
||
|
||
let result = unsafe {
|
||
ReadFile(
|
||
pipe,
|
||
Some(&mut buf),
|
||
Some(&mut bytes_read),
|
||
None,
|
||
)
|
||
};
|
||
|
||
if result.is_err() {
|
||
if debug {
|
||
eprintln!("[Pipe] 读取失败");
|
||
}
|
||
return None;
|
||
}
|
||
|
||
if bytes_read == 0 {
|
||
return None;
|
||
}
|
||
|
||
let msg = String::from_utf8_lossy(&buf[..bytes_read as usize])
|
||
.trim_end()
|
||
.to_string();
|
||
|
||
if debug {
|
||
println!("[Pipe] 收到消息：{}", msg);
|
||
}
|
||
|
||
Some(msg)
|
||
}
|
||
|
||
/// 写入 ACK 响应到命名管道
|
||
fn write_pipe_ack(pipe: windows::Win32::Foundation::HANDLE, debug: bool) {
|
||
use windows::Win32::Storage::FileSystem::WriteFile;
|
||
|
||
let ack = b"ACK\r\n";
|
||
let mut written: u32 = 0;
|
||
let result = unsafe {
|
||
WriteFile(
|
||
pipe,
|
||
Some(ack),
|
||
Some(&mut written),
|
||
None,
|
||
)
|
||
};
|
||
|
||
if result.is_err() && debug {
|
||
eprintln!("[Pipe] 写入 ACK 失败");
|
||
}
|
||
}
|
||
|
||
/// 启动命名管道异步服务端（长生命周期 async task）。
|
||
/// 通过 spawn_blocking 在独立 OS 线程中调用同步的 ConnectNamedPipe / ReadFile，
|
||
/// 收到消息后通过 tokio channel 传回主循环。
|
||
/// 连接断开后自动重新监听下一条连接。
|
||
fn start_named_pipe_server(
|
||
tx: tokio::sync::mpsc::Sender<String>,
|
||
debug: bool,
|
||
) -> tokio::task::JoinHandle<()> {
|
||
tokio::task::spawn(async move {
|
||
let pipe_name = PIPE_NAME;
|
||
if debug {
|
||
println!("[Pipe] 命名管道服务端启动：{}", pipe_name);
|
||
}
|
||
|
||
loop {
|
||
// 在 blocking 线程中创建并等待客户端连接
|
||
let msg = tokio::task::spawn_blocking(move || {
|
||
use windows::Win32::Storage::FileSystem::PIPE_ACCESS_DUPLEX;
|
||
use windows::Win32::System::Pipes::{
|
||
ConnectNamedPipe, CreateNamedPipeW, DisconnectNamedPipe,
|
||
PIPE_READMODE_BYTE, PIPE_TYPE_BYTE, PIPE_WAIT,
|
||
};
|
||
use windows::core::PCWSTR;
|
||
|
||
let name: Vec<u16> = pipe_name.encode_utf16().chain(std::iter::once(0)).collect();
|
||
let pipe = unsafe {
|
||
CreateNamedPipeW(
|
||
PCWSTR::from_raw(name.as_ptr()),
|
||
PIPE_ACCESS_DUPLEX,
|
||
PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT,
|
||
1, // nMaxInstances
|
||
65536, // nOutBufferSize
|
||
65536, // nInBufferSize
|
||
0, // nDefaultTimeout（毫秒，0=默认 50ms）
|
||
None, // lpSecurityAttributes
|
||
)
|
||
};
|
||
|
||
if pipe == windows::Win32::Foundation::INVALID_HANDLE_VALUE {
|
||
eprintln!("[Pipe] CreateNamedPipeW 失败");
|
||
return None;
|
||
}
|
||
|
||
if debug {
|
||
println!("[Pipe] 等待客户端连接...");
|
||
}
|
||
|
||
// 阻塞等待客户端连接
|
||
let connected = unsafe { ConnectNamedPipe(pipe, None) };
|
||
if connected.is_err() {
|
||
eprintln!("[Pipe] ConnectNamedPipe 失败");
|
||
return None;
|
||
}
|
||
|
||
if debug {
|
||
println!("[Pipe] 客户端已连接");
|
||
}
|
||
|
||
// 读取消息
|
||
let msg = read_pipe_message(pipe, debug);
|
||
|
||
// 回复 ACK
|
||
if msg.is_some() {
|
||
write_pipe_ack(pipe, debug);
|
||
}
|
||
|
||
// 断开连接
|
||
unsafe { DisconnectNamedPipe(pipe).ok() };
|
||
|
||
msg
|
||
})
|
||
.await;
|
||
|
||
// 将消息发送到 tokio channel
|
||
match msg {
|
||
Ok(Some(m)) => {
|
||
// quit 命令：发送到 channel 后退出循环
|
||
if m == "quit" {
|
||
if tx.send(m).await.is_err() {
|
||
break;
|
||
}
|
||
if debug {
|
||
println!("[Pipe] quit 已转发，退出监听循环");
|
||
}
|
||
break;
|
||
}
|
||
|
||
// 正常消息
|
||
if tx.send(m).await.is_err() {
|
||
break;
|
||
}
|
||
}
|
||
Ok(None) => {
|
||
// 连接读取失败，继续等待下一条
|
||
}
|
||
Err(_) => {
|
||
// spawn_blocking 失败
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
if debug {
|
||
println!("[Pipe] 命名管道服务端已停止");
|
||
}
|
||
})
|
||
}
|
||
|
||
// ===================== 版本比较与下载 =====================
|
||
/// 获取 Updater 数据目录（X:\AppData\，存放 BootLoader.exe 等）
|
||
fn get_updater_data_dir() -> PathBuf {
|
||
let exe_path = std::env::current_exe().expect("Failed to get executable path");
|
||
let drive = exe_path
|
||
.parent()
|
||
.and_then(|p| p.as_os_str().to_str())
|
||
.and_then(|s| s.split('\\').next())
|
||
.unwrap_or("C:");
|
||
let appdata = PathBuf::from(format!("{}/AppData", drive));
|
||
let _ = fs::create_dir_all(&appdata);
|
||
appdata
|
||
}
|
||
|
||
/// 获取本地文件版本号（使用 PowerShell 获取 PE 文件版本信息）
|
||
fn get_local_file_version(filename: &str) -> String {
|
||
let file_path = get_updater_data_dir().join(filename);
|
||
|
||
if !file_path.exists() {
|
||
return "0.0.0".to_string();
|
||
}
|
||
|
||
#[cfg(windows)]
|
||
{
|
||
let path_str = file_path.to_string_lossy().to_string();
|
||
let ps_script = format!(
|
||
"(Get-Item -LiteralPath '{}' -ErrorAction SilentlyContinue).VersionInfo.FileVersion",
|
||
path_str.replace("'", "''")
|
||
);
|
||
|
||
let output = Command::new("powershell")
|
||
.args(["-NoProfile", "-NonInteractive", "-Command", &ps_script])
|
||
.output();
|
||
|
||
if let Ok(output) = output {
|
||
let stdout = String::from_utf8_lossy(&output.stdout);
|
||
let version = stdout.trim();
|
||
if !version.is_empty() && version != "0" && !version.contains("没有版本") {
|
||
return version.to_string();
|
||
}
|
||
}
|
||
|
||
// 备用：使用文件修改时间作为"版本"
|
||
if let Ok(metadata) = fs::metadata(&file_path) {
|
||
use std::time::UNIX_EPOCH;
|
||
if let Ok(modified) = metadata.modified() {
|
||
let duration = modified.duration_since(UNIX_EPOCH).unwrap_or_default();
|
||
return format!("{}.{}", duration.as_secs(), duration.subsec_nanos() / 1_000_000);
|
||
}
|
||
}
|
||
|
||
"0.0.0".to_string()
|
||
}
|
||
|
||
#[cfg(not(windows))]
|
||
{
|
||
"0.0.0".to_string()
|
||
}
|
||
}
|
||
|
||
/// 比较两个版本号（a < b 返回 true）
|
||
/// 使用 CubeLib 库的版本比较函数
|
||
fn version_less_than(a: &str, b: &str) -> bool {
|
||
cube_lib::version_less_than(a, b)
|
||
}
|
||
|
||
/// 计算本地文件前 N 字节的 MD5 hash（字节数为 0 表示全部）
|
||
#[allow(dead_code)]
|
||
fn compute_file_hash_in_dir(app_name: &str, filename: &str, bytes: u64, _debug: bool) -> Option<String> {
|
||
let file_path = get_updater_data_dir()
|
||
.join("Updater")
|
||
.join("UpGrade")
|
||
.join(app_name)
|
||
.join(filename);
|
||
|
||
if !file_path.exists() {
|
||
return None;
|
||
}
|
||
|
||
let mut file = File::open(&file_path).ok()?;
|
||
let file_size = file.metadata().ok()?.len();
|
||
|
||
let read_bytes = if bytes == 0 || bytes > file_size {
|
||
file_size
|
||
} else {
|
||
bytes
|
||
};
|
||
|
||
let mut buffer = vec![0u8; read_bytes as usize];
|
||
file.read_exact(&mut buffer).ok()?;
|
||
|
||
let hash = md5::compute(&buffer);
|
||
Some(format!("{:x}", hash))
|
||
}
|
||
|
||
/// 计算本地文件前 N 字节的 MD5 hash（字节数为 0 表示全部）
|
||
fn compute_file_hash(filename: &str, bytes: u64, _debug: bool) -> Option<String> {
|
||
|
||
let file_path = get_updater_data_dir().join(filename);
|
||
if !file_path.exists() {
|
||
return None;
|
||
}
|
||
|
||
let mut file = File::open(&file_path).ok()?;
|
||
let file_size = file.metadata().ok()?.len();
|
||
|
||
// 如果 bytes=0 或超过文件大小，则计算整个文件
|
||
let read_bytes = if bytes == 0 || bytes > file_size {
|
||
file_size
|
||
} else {
|
||
bytes
|
||
};
|
||
|
||
// 读取前 read_bytes 字节
|
||
let mut buffer = vec![0u8; read_bytes as usize];
|
||
file.read_exact(&mut buffer).ok()?;
|
||
|
||
let hash = md5::compute(&buffer);
|
||
Some(format!("{:x}", hash))
|
||
}
|
||
|
||
/// 计算文件的完整 MD5 hash
|
||
fn compute_file_md5(file_path: &PathBuf) -> Option<String> {
|
||
if !file_path.exists() {
|
||
log_print!("[MD5] 文件不存在: {:?}", file_path);
|
||
return None;
|
||
}
|
||
|
||
let file_data = match fs::read(file_path) {
|
||
Ok(data) => data,
|
||
Err(e) => {
|
||
log_print!("[MD5] 读取文件失败: {:?}, error: {}", file_path, e);
|
||
return None;
|
||
}
|
||
};
|
||
let hash = md5::compute(&file_data);
|
||
Some(format!("{:x}", hash))
|
||
}
|
||
|
||
/// 获取临时文件的当前大小（字节数）
|
||
/// 注意：Updater.exe 的临时文件是 Updater.new.exe.tmp
|
||
fn get_tmp_file_size(filename: &str) -> u64 {
|
||
let tmp_filename = if filename == "Updater.exe" { "Updater.new.exe.tmp" } else { filename };
|
||
let tmp_path = get_updater_data_dir().join(format!("{}.tmp", tmp_filename));
|
||
tmp_path.metadata().map(|m| m.len()).unwrap_or(0)
|
||
}
|
||
|
||
/// 检查是否存在 Updater.new.exe 文件
|
||
fn has_updater_new_exe() -> bool {
|
||
let updater_new_path = get_updater_data_dir().join("Updater.new.exe");
|
||
updater_new_path.exists()
|
||
}
|
||
|
||
/// 安排启动 BootLoader.exe（延迟执行，等待所有下载完成）
|
||
/// 通过 shutdown_tx 发送断连信号，通知主循环优雅退出
|
||
fn schedule_bootloader_launch(
|
||
debug: bool,
|
||
shutdown_tx_arc: std::sync::Arc<std::sync::Mutex<Option<tokio::sync::oneshot::Sender<()>>>>,
|
||
) {
|
||
// 延迟 1 秒后启动，确保文件句柄已关闭
|
||
std::thread::spawn(move || {
|
||
std::thread::sleep(std::time::Duration::from_secs(1));
|
||
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
|
||
let bootloader_path = get_updater_data_dir().join("BootLoader.exe");
|
||
|
||
if !bootloader_path.exists() {
|
||
if debug {
|
||
println!("{} [错误] BootLoader.exe 不存在，无法启动", ts);
|
||
}
|
||
return;
|
||
}
|
||
|
||
// 启动 BootLoader.exe
|
||
if debug {
|
||
println!("{} [启动] 正在启动 BootLoader.exe...", ts);
|
||
}
|
||
|
||
#[cfg(windows)]
|
||
{
|
||
use std::os::windows::process::CommandExt;
|
||
const DETACHED_PROCESS: u32 = 0x00000008;
|
||
const CREATE_NO_WINDOW: u32 = 0x08000000;
|
||
|
||
match Command::new(&bootloader_path)
|
||
.args(["--from-updater"])
|
||
.creation_flags(DETACHED_PROCESS | CREATE_NO_WINDOW)
|
||
.spawn()
|
||
{
|
||
Ok(_) => {
|
||
if debug {
|
||
println!("{} [启动] BootLoader.exe 已启动，Updater 即将退出", ts);
|
||
}
|
||
// 发送断连信号，通知主循环优雅退出
|
||
if let Some(tx) = shutdown_tx_arc.lock().unwrap().take() {
|
||
let _ = tx.send(());
|
||
}
|
||
}
|
||
Err(e) => {
|
||
log_eprintln!("{} [错误] 启动 BootLoader.exe 失败: {}", ts, e);
|
||
// 启动失败也发送断连信号
|
||
if let Some(tx) = shutdown_tx_arc.lock().unwrap().take() {
|
||
let _ = tx.send(());
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
#[cfg(not(windows))]
|
||
{
|
||
match Command::new(&bootloader_path)
|
||
.arg("--from-updater")
|
||
.spawn()
|
||
{
|
||
Ok(_) => {
|
||
if debug {
|
||
println!("{} [启动] BootLoader.exe 已启动，Updater 即将退出", ts);
|
||
}
|
||
if let Some(tx) = shutdown_tx_arc.lock().unwrap().take() {
|
||
let _ = tx.send(());
|
||
}
|
||
}
|
||
Err(e) => {
|
||
log_eprintln!("{} [错误] 启动 BootLoader.exe 失败: {}", ts, e);
|
||
if let Some(tx) = shutdown_tx_arc.lock().unwrap().take() {
|
||
let _ = tx.send(());
|
||
}
|
||
}
|
||
}
|
||
}
|
||
});
|
||
}
|
||
|
||
/// 发送 GetFileMd5 请求
|
||
fn request_file_md5(sender: &cube_lib::websocket::MessageSender, filename: &str, bytes: u64) {
|
||
let msg_str = format!(
|
||
r#"{{"Type":"GetFileMd5","Data":{{"filename":"{}","bytes":{}}}}}"#,
|
||
filename, bytes
|
||
);
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
log_print!("{} 发送消息：{}", ts, msg_str);
|
||
sender.send(msg_str);
|
||
}
|
||
|
||
/// 发送文件下载请求（断点续传）
|
||
fn request_download(sender: &cube_lib::websocket::MessageSender, filename: &str, offset: u64) {
|
||
let msg_str = format!(
|
||
r#"{{"Type":"DownloadFile","Data":{{"filename":"{}","offset":{}}}}}"#,
|
||
filename, offset
|
||
);
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
log_print!("{} 发送消息：{}", ts, msg_str);
|
||
sender.send(msg_str);
|
||
}
|
||
|
||
/// 处理收到的文件块
|
||
fn handle_file_chunk(
|
||
ctx: &Arc<UpdateContext>,
|
||
data: &serde_json::Map<std::string::String, serde_json::Value>,
|
||
debug: bool,
|
||
) -> Option<String> {
|
||
let filename = data.get("filename").and_then(|v| v.as_str()).unwrap_or("");
|
||
let offset = data.get("offset").and_then(|v| v.as_u64()).unwrap_or(0);
|
||
let chunk_data = data.get("data").and_then(|v| v.as_str()).unwrap_or("");
|
||
let is_last = data.get("is_last").and_then(|v| v.as_bool()).unwrap_or(false);
|
||
|
||
// Updater.exe 保存为 Updater.new.exe
|
||
let final_filename = if filename == "Updater.exe" { "Updater.new.exe".to_string() } else { filename.to_string() };
|
||
|
||
let mut ctx = ctx.download_state.lock().unwrap();
|
||
|
||
// 只有文件名变化才重置（开始下载新文件）
|
||
// 注意：不要用 offset==0 判断是否重置！
|
||
// offset>0 表示续传（server 从该偏移继续发块），不应重置 tmp 文件
|
||
let need_reset = match ctx.as_ref() {
|
||
Some(s) => &s.filename != &final_filename,
|
||
None => true,
|
||
};
|
||
if need_reset {
|
||
// 关闭旧文件
|
||
if let Some(ref mut s) = *ctx {
|
||
if let Some(f) = s.file.take() {
|
||
drop(f);
|
||
}
|
||
if let Some(ref tp) = s.temp_path {
|
||
let _ = fs::remove_file(tp);
|
||
}
|
||
}
|
||
*ctx = None;
|
||
|
||
// 使用 AppData/Updater/ 作为数据目录
|
||
let data_dir = get_updater_data_dir();
|
||
let temp_path = data_dir.join(format!("{}.tmp", final_filename));
|
||
|
||
// 续传：tmp 文件已存在，以追加方式打开（保留已有数据）
|
||
// 新下载：tmp 文件不存在，用 File::create 创建（截断模式）
|
||
let (file, resume_offset) = if temp_path.exists() {
|
||
use std::fs::OpenOptions;
|
||
match OpenOptions::new().write(true).append(true).open(&temp_path) {
|
||
Ok(f) => {
|
||
let current_size = f.metadata().map(|m| m.len()).unwrap_or(0);
|
||
if debug {
|
||
eprintln!("[下载] 续传：追加打开 {:?}, 当前大小={}", temp_path, current_size);
|
||
}
|
||
let mut file = f;
|
||
file.seek(std::io::SeekFrom::Start(current_size)).ok();
|
||
(file, current_size)
|
||
}
|
||
Err(e) => {
|
||
if debug {
|
||
eprintln!("[下载] 无法追加打开临时文件 {}: {}", filename, e);
|
||
}
|
||
return None;
|
||
}
|
||
}
|
||
} else {
|
||
// 新下载，截断创建
|
||
match File::create(&temp_path) {
|
||
Ok(file) => (file, 0u64),
|
||
Err(e) => {
|
||
if debug {
|
||
eprintln!("[下载] 无法创建临时文件 {}: {}", filename, e);
|
||
}
|
||
return None;
|
||
}
|
||
}
|
||
};
|
||
|
||
*ctx = Some(DownloadState {
|
||
filename: final_filename.clone(),
|
||
offset: resume_offset,
|
||
temp_path: Some(temp_path),
|
||
file: Some(file),
|
||
});
|
||
}
|
||
|
||
// 解码并追加数据
|
||
if let Some(ref mut state) = *ctx {
|
||
let current_offset = state.offset;
|
||
if offset == current_offset {
|
||
if let Some(ref mut file) = state.file {
|
||
match BASE64.decode(chunk_data) {
|
||
Ok(decoded) => {
|
||
match file.write_all(&decoded) {
|
||
Ok(_) => {
|
||
let _ = file.flush();
|
||
state.offset += decoded.len() as u64;
|
||
}
|
||
Err(e) => {
|
||
if debug {
|
||
eprintln!("[下载] 写入失败: {}", e);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
Err(e) => {
|
||
if debug {
|
||
eprintln!("[下载] Base64 解码失败: {}", e);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
} else {
|
||
if debug {
|
||
eprintln!("[下载] 偏移不匹配: 期望 {}, 收到 {}", current_offset, offset);
|
||
}
|
||
}
|
||
}
|
||
|
||
// 最后一块：重命名临时文件为正式文件
|
||
if is_last {
|
||
let state = ctx.take().unwrap();
|
||
let temp_path = state.temp_path;
|
||
let final_offset = state.offset;
|
||
|
||
// 关闭文件句柄
|
||
if let Some(f) = state.file {
|
||
drop(f);
|
||
}
|
||
|
||
if let Some(ref temp) = temp_path {
|
||
let data_dir = get_updater_data_dir();
|
||
let final_path = data_dir.join(&final_filename);
|
||
|
||
// 原子重命名
|
||
if let Err(e) = fs::rename(temp, &final_path) {
|
||
if debug {
|
||
eprintln!("[下载] 重命名失败: {}", e);
|
||
}
|
||
// 尝试直接覆盖写入
|
||
let _ = fs::copy(temp, &final_path);
|
||
let _ = fs::remove_file(temp);
|
||
}
|
||
|
||
if debug {
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
println!("{} [下载] {} 下载完成，共 {} 字节", ts, final_filename, final_offset);
|
||
}
|
||
}
|
||
|
||
// 返回下载完成的文件名，用于后续流程判断
|
||
Some(final_filename)
|
||
} else {
|
||
None
|
||
}
|
||
}
|
||
|
||
/// 处理下载完成消息
|
||
fn handle_download_complete(
|
||
ctx: &Arc<UpdateContext>,
|
||
data: &serde_json::Map<std::string::String, serde_json::Value>,
|
||
debug: bool,
|
||
) -> Option<String> {
|
||
let filename = data.get("filename").and_then(|v| v.as_str()).unwrap_or("");
|
||
let size = data.get("size").and_then(|v| v.as_u64()).unwrap_or(0);
|
||
|
||
// Updater.exe 保存为 Updater.new.exe
|
||
let final_filename = if filename == "Updater.exe" { "Updater.new.exe".to_string() } else { filename.to_string() };
|
||
|
||
if debug {
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
println!("{} [下载] {} 下载完成，最终大小: {} 字节", ts, final_filename, size);
|
||
}
|
||
|
||
let mut ctx = ctx.download_state.lock().unwrap();
|
||
|
||
// 如果有临时文件，执行重命名（防止 DownloadComplete 先于最后一个 FileChunk 到达）
|
||
let temp_to_rename = ctx.as_ref().and_then(|s| s.temp_path.clone());
|
||
let has_temp = temp_to_rename.is_some();
|
||
|
||
if has_temp {
|
||
let data_dir = get_updater_data_dir();
|
||
let final_path = data_dir.join(&final_filename);
|
||
|
||
// 先关闭文件句柄并获取 temp_path
|
||
let temp_path_owned = ctx.as_mut().and_then(|s| s.temp_path.take()).unwrap();
|
||
// 重置状态
|
||
*ctx = None;
|
||
|
||
// 原子重命名
|
||
if let Err(e) = fs::rename(&temp_path_owned, &final_path) {
|
||
if debug {
|
||
eprintln!("[下载] 重命名失败: {}", e);
|
||
}
|
||
// 尝试直接覆盖写入
|
||
let _ = fs::copy(&temp_path_owned, &final_path);
|
||
let _ = fs::remove_file(&temp_path_owned);
|
||
}
|
||
|
||
if debug {
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
println!("{} [下载] {} 临时文件已重命名", ts, final_filename);
|
||
}
|
||
} else {
|
||
// 没有临时文件，只重置状态
|
||
*ctx = None;
|
||
}
|
||
|
||
Some(final_filename)
|
||
}
|
||
|
||
// ===================== 其他应用程序更新 =====================
|
||
|
||
/// 获取其他应用文件的临时文件大小
|
||
#[allow(dead_code)]
|
||
fn get_app_tmp_file_size(app_name: &str, relative_path: &str) -> u64 {
|
||
let tmp_path = get_updater_data_dir()
|
||
.join("Updater")
|
||
.join("UpGrade")
|
||
.join(app_name)
|
||
.join(format!("{}.tmp", relative_path));
|
||
tmp_path.metadata().map(|m| m.len()).unwrap_or(0)
|
||
}
|
||
|
||
|
||
|
||
/// 向服务器查询指定文件的 md5（用于断点续传校验）
|
||
#[allow(dead_code)]
|
||
fn request_file_md5_for_app(
|
||
sender: &cube_lib::websocket::MessageSender,
|
||
app_name: &str,
|
||
relative_path: &str,
|
||
offset: u64,
|
||
) {
|
||
let msg_str = format!(
|
||
r#"{{"Type":"GetFileMd5","Data":{{"filename":"{}","bytes":{}}}}}"#,
|
||
relative_path, offset
|
||
);
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
log_print!("{} [应用] {} 请求 md5 (offset {}): {}", ts, app_name, offset, relative_path);
|
||
log_print!("{} 发送消息：{}", ts, msg_str);
|
||
sender.send(msg_str);
|
||
}
|
||
|
||
|
||
/// 向服务器请求下载指定应用的文件
|
||
fn request_download_for_app(
|
||
sender: &cube_lib::websocket::MessageSender,
|
||
app_name: &str,
|
||
relative_path: &str,
|
||
offset: u64,
|
||
) {
|
||
// 文件名前加上应用名称目录
|
||
let full_path = format!("{}/{}", app_name, relative_path);
|
||
let msg_str = format!(
|
||
r#"{{"Type":"DownloadFile","Data":{{"filename":"{}","offset":{}}}}}"#,
|
||
full_path, offset
|
||
);
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
log_print!("{} 发送消息：{}", ts, msg_str);
|
||
sender.send(msg_str);
|
||
}
|
||
|
||
|
||
/// 从待下载队列取出一个文件发送（顺序下载）
|
||
/// shutdown_tx: 进入 Complete 阶段后发送此信号断开连接
|
||
fn send_next_download(
|
||
ctx: &Arc<UpdateContext>,
|
||
sender: &cube_lib::websocket::MessageSender,
|
||
shutdown_tx: &std::sync::Arc<std::sync::Mutex<Option<tokio::sync::oneshot::Sender<()>>>>
|
||
) {
|
||
let mut queue = ctx.download_queue.lock().unwrap();
|
||
if let Some((app_name, filename, offset, expected_md5)) = queue.pop_front() {
|
||
// 记录当前下载的期望 MD5，供 DownloadComplete 校验
|
||
*ctx.current_download_md5.lock().unwrap() = Some(expected_md5);
|
||
request_download_for_app(sender, &app_name, &filename, offset);
|
||
} else {
|
||
*ctx.is_downloading.lock().unwrap() = false;
|
||
|
||
// 队列为空，检查是否所有应用都处理完了
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
let pending_apps = ctx.pending_allfile_apps.lock().unwrap();
|
||
if pending_apps.is_empty() {
|
||
*ctx.current_phase.lock().unwrap() = UpdatePhase::Complete;
|
||
|
||
// 打印下载完成摘要
|
||
let completed = ctx.app_completed_set.lock().unwrap();
|
||
let mut app_summary: std::collections::HashMap<String, Vec<String>> = std::collections::HashMap::new();
|
||
for key in completed.iter() {
|
||
if let Some((app_name, filename)) = key.split_once('/') {
|
||
app_summary.entry(app_name.to_string()).or_default().push(filename.to_string());
|
||
}
|
||
}
|
||
|
||
log_print!("{} [下载] === 所有应用文件下载完成 ===", ts);
|
||
for (app_name, files) in &app_summary {
|
||
log_print!("{} [下载] {}: {} 个文件 ({})", ts, app_name, files.len(), files.join(", "));
|
||
}
|
||
log_print!("{} [下载] 文件保存在: {:?}", ts, get_updater_data_dir().join("Updater").join("UpGrade"));
|
||
log_print!("{} [下载] ======================================", ts);
|
||
|
||
// 发送 shutdown 信号，断开连接返回主循环
|
||
if let Some(tx) = shutdown_tx.lock().unwrap().take() {
|
||
let _ = tx.send(());
|
||
}
|
||
} else {
|
||
log_print!("{} [下载] 队列为空，等待 {} 个应用完成 AllFile 响应", ts, pending_apps.len());
|
||
}
|
||
}
|
||
}
|
||
|
||
/// 处理其他应用的文件块（写入 AppData/{app_name}/{relative_path}）
|
||
fn handle_app_file_chunk(
|
||
ctx: &Arc<UpdateContext>,
|
||
app_name: &str,
|
||
data: &serde_json::Map<std::string::String, serde_json::Value>,
|
||
debug: bool,
|
||
) -> Option<(String, String)> {
|
||
// 注意：其他应用的文件块，filename 字段就是 relative_path（服务端可能含 app/ 前缀）
|
||
let filename = data.get("filename").and_then(|v| v.as_str()).unwrap_or("");
|
||
if filename.is_empty() {
|
||
return None;
|
||
}
|
||
|
||
let offset = data.get("offset").and_then(|v| v.as_u64()).unwrap_or(0);
|
||
let chunk_data = data.get("data").and_then(|v| v.as_str()).unwrap_or("");
|
||
let is_last = data.get("is_last").and_then(|v| v.as_bool()).unwrap_or(false);
|
||
|
||
// 服务端 filename 可能含 app/ 前缀（如 "EasyTest/xxx.dll"），统一去掉前缀
|
||
// app_map 中的 key 用 app_name/relative_path 格式存储
|
||
let expected_prefix = format!("{}/", app_name);
|
||
let relative_path = if filename.starts_with(&expected_prefix) {
|
||
&filename[expected_prefix.len()..]
|
||
} else {
|
||
filename
|
||
};
|
||
let key = format!("{}/{}", app_name, relative_path);
|
||
// 记录原始 relative_path，供 is_last=false 时请求下一块使用
|
||
let relative_path = relative_path.to_string();
|
||
let mut app_map = ctx.app_download_map.lock().unwrap();
|
||
|
||
// 获取当前正在下载的文件名（用于判断是否是新文件）
|
||
// 注意：app_map 中存储的 filename 是不含前缀的 relative_path
|
||
let current_filename = app_map.values().next().map(|s| s.filename.clone());
|
||
|
||
// 新文件（非续传）：清空旧 entry，等待 DownloadComplete 处理旧文件
|
||
// 续传（同一文件 + 非零 offset）：追加数据，不清 entry
|
||
// 注意：current_filename 来自 app_map（不含前缀），filename 来自服务端（含前缀）
|
||
// 所以应该比较 relative_path 而不是 filename
|
||
if current_filename.as_ref() != Some(&relative_path) && (!app_map.contains_key(&key) || offset == 0) {
|
||
if let Some(f) = app_map.get_mut(&key) {
|
||
if let Some(file) = f.file.take() {
|
||
drop(file);
|
||
}
|
||
if let Some(ref tp) = f.temp_path {
|
||
let _ = fs::remove_file(tp);
|
||
}
|
||
}
|
||
app_map.remove(&key);
|
||
|
||
// relative_path 已经是去掉 app_name/ 前缀的相对路径（如 "x64/SQLite.Interop.dll"）
|
||
// 直接用它构建路径，保留子目录信息
|
||
// 注意：不能用 with_extension("tmp") 直接替换，因为会丢失原有扩展名！
|
||
// 需要手动添加 .tmp 后缀
|
||
let base_path = get_updater_data_dir()
|
||
.join("Updater")
|
||
.join("UpGrade")
|
||
.join(app_name)
|
||
.join(&relative_path);
|
||
let temp_path = PathBuf::from(format!("{}.tmp", base_path.to_string_lossy()));
|
||
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
log_print!("{} [应用] 新文件: filename={}, tmp_path={:?}, parent_exists={}",
|
||
ts, filename, temp_path, temp_path.parent().map(|p| p.exists()).unwrap_or(false));
|
||
|
||
match File::create(&temp_path) {
|
||
Ok(file) => {
|
||
app_map.insert(key.clone(), DownloadState {
|
||
filename: relative_path.clone(), // 不带 app_name/ 前缀，与 current_filename 检查一致
|
||
offset: 0,
|
||
temp_path: Some(temp_path),
|
||
file: Some(file),
|
||
});
|
||
}
|
||
Err(e) => {
|
||
if debug {
|
||
eprintln!("[应用] 无法创建临时文件 {}: {}", filename, e);
|
||
}
|
||
return None;
|
||
}
|
||
}
|
||
}
|
||
|
||
let current_offset = app_map.get(&key).map(|s| s.offset).unwrap_or(0);
|
||
if offset == current_offset {
|
||
if let Some(dl_state) = app_map.get_mut(&key) {
|
||
if let Some(ref mut file) = dl_state.file {
|
||
match BASE64.decode(chunk_data) {
|
||
Ok(decoded) => {
|
||
match file.write_all(&decoded) {
|
||
Ok(_) => {
|
||
let _ = file.flush();
|
||
dl_state.offset += decoded.len() as u64;
|
||
}
|
||
Err(e) => {
|
||
if debug {
|
||
eprintln!("[应用] 写入失败 {}: {}", filename, e);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
Err(e) => {
|
||
if debug {
|
||
eprintln!("[应用] Base64 解码失败 {}: {}", filename, e);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
} else {
|
||
if debug {
|
||
eprintln!("[应用] 偏移不匹配 {}: 期望 {}, 收到 {}", filename, current_offset, offset);
|
||
}
|
||
}
|
||
|
||
// 最后一块：原子重命名
|
||
if is_last {
|
||
let temp_path = app_map.get(&key).and_then(|s| s.temp_path.clone());
|
||
let final_offset = app_map.get(&key).map(|s| s.offset).unwrap_or(0);
|
||
|
||
if let Some(ref temp) = temp_path {
|
||
// final_path 是 temp_path 去掉 ".tmp" 后缀，直接在同一目录
|
||
// 注意：不能用 with_extension("")，因为它会替换原有扩展名！
|
||
// 对于 "x86/SQLite.Interop.dll.tmp"，with_extension("") 会得到 "x86/SQLite.Interop"（.dll 丢失！）
|
||
let temp_str = temp.to_string_lossy();
|
||
let final_path = if temp_str.ends_with(".tmp") {
|
||
PathBuf::from(&temp_str[..temp_str.len() - 4])
|
||
} else {
|
||
temp.clone()
|
||
};
|
||
let _ = fs::create_dir_all(final_path.parent().unwrap());
|
||
|
||
// 重命名（同步操作，Windows 上不会异步）
|
||
let rename_ok = fs::rename(temp, &final_path).is_ok();
|
||
if !rename_ok {
|
||
let _ = fs::copy(temp, &final_path);
|
||
let _ = fs::remove_file(temp);
|
||
}
|
||
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
log_print!("{} [应用] 文件下载完成: filename={}, final_path={:?}, rename_ok={}, final_exists={}",
|
||
ts, filename, final_path, rename_ok, final_path.exists());
|
||
if debug {
|
||
println!("{} [应用] {} 下载完成，共 {} 字节", ts, filename, final_offset);
|
||
}
|
||
}
|
||
|
||
app_map.remove(&key);
|
||
drop(app_map); // 释放锁
|
||
Some((app_name.to_string(), relative_path)) // 返回 relative_path
|
||
} else {
|
||
drop(app_map); // 释放锁
|
||
Some((app_name.to_string(), relative_path)) // 非最后一块也返回 relative_path，供请求下一块使用
|
||
}
|
||
}
|
||
|
||
/// 处理其他应用的文件下载完成（与 FileChunk 互斥，这里主要用于补充处理）
|
||
fn handle_app_download_complete(
|
||
ctx: &Arc<UpdateContext>,
|
||
app_name: &str,
|
||
filename: &str,
|
||
size: u64,
|
||
debug: bool,
|
||
) -> Option<(String, String)> {
|
||
// 服务端 filename 可能含 app/ 前缀，提取纯相对路径
|
||
let expected_prefix = format!("{}/", app_name);
|
||
let relative_path = if filename.starts_with(&expected_prefix) {
|
||
&filename[expected_prefix.len()..]
|
||
} else {
|
||
filename
|
||
};
|
||
let key = format!("{}/{}", app_name, relative_path);
|
||
let mut app_map = ctx.app_download_map.lock().unwrap();
|
||
|
||
let temp_path = app_map.get(&key).and_then(|s| s.temp_path.clone());
|
||
|
||
if let Some(ref temp) = temp_path {
|
||
// final_path 是 temp_path 去掉 ".tmp" 后缀，直接在同一目录
|
||
let final_path = temp.with_extension(""); // 去掉 .tmp 后缀
|
||
let _ = fs::create_dir_all(final_path.parent().unwrap());
|
||
|
||
if let Err(e) = fs::rename(temp, &final_path) {
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
log_print!("{} [应用] 重命名失败 {} -> {:?}: {}，改用 copy", ts, filename, final_path, e);
|
||
let _ = fs::copy(temp, &final_path);
|
||
let _ = fs::remove_file(temp);
|
||
} else {
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
log_print!("{} [应用] 重命名成功 {} -> {:?}", ts, filename, final_path);
|
||
}
|
||
|
||
if debug {
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
println!("{} [应用] {} 下载完成（DownloadComplete），大小: {} 字节", ts, filename, size);
|
||
}
|
||
}
|
||
|
||
app_map.remove(&key);
|
||
Some((app_name.to_string(), filename.to_string()))
|
||
}
|
||
|
||
/// 只负责 Updater 自己的行为参数，连接地址从公共 config.json 加载
|
||
#[derive(Debug, Serialize, Deserialize)]
|
||
struct Config {
|
||
/// 调试模式：true 时保留控制台窗口并输出日志
|
||
debug_mode: bool,
|
||
}
|
||
|
||
impl Default for Config {
|
||
fn default() -> Self {
|
||
Self { debug_mode: false }
|
||
}
|
||
}
|
||
|
||
/// 获取 Updater 自身配置路径 AppData/Updater/config.json
|
||
fn get_updater_config_path() -> PathBuf {
|
||
get_updater_data_dir().join("Updater").join("config.json")
|
||
}
|
||
|
||
/// 获取公共配置路径 AppData/config.json（与 BootLoader 同级）
|
||
fn get_public_config_path() -> PathBuf {
|
||
let exe_path = std::env::current_exe().expect("Failed to get executable path");
|
||
let drive = exe_path
|
||
.parent()
|
||
.and_then(|p| p.as_os_str().to_str())
|
||
.and_then(|s| s.split('\\').next())
|
||
.unwrap_or("C:");
|
||
PathBuf::from(format!("{}/AppData/config.json", drive))
|
||
}
|
||
|
||
/// 加载 Updater 自身配置；若文件不存在则写入默认值
|
||
fn load_updater_config() -> Config {
|
||
let config_path = get_updater_config_path();
|
||
if config_path.exists() {
|
||
if let Ok(content) = fs::read_to_string(&config_path) {
|
||
if let Ok(config) = serde_json::from_str::<Config>(&content) {
|
||
return config;
|
||
}
|
||
}
|
||
}
|
||
// 文件不存在或解析失败 → 写入默认值
|
||
let default_config = Config::default();
|
||
if let Ok(content) = serde_json::to_string_pretty(&default_config) {
|
||
let _ = fs::write(&config_path, content);
|
||
}
|
||
default_config
|
||
}
|
||
|
||
/// 从公共 config.json 读取 ServerUrl 字段
|
||
fn resolve_ws_url() -> String {
|
||
let config_path = get_public_config_path();
|
||
if let Ok(content) = fs::read_to_string(&config_path) {
|
||
if let Ok(json) = serde_json::from_str::<serde_json::Value>(&content) {
|
||
if let Some(url) = json.get("ServerUrl").and_then(|v| v.as_str()) {
|
||
return url.to_string();
|
||
}
|
||
}
|
||
}
|
||
// 读取失败 → 降级到默认值
|
||
"ws://127.0.0.1:8087/ws".to_string()
|
||
}
|
||
|
||
/// 从公共 config.json 读取 DeviceNumber 字段
|
||
fn resolve_device_number() -> String {
|
||
let config_path = get_public_config_path();
|
||
if let Ok(content) = fs::read_to_string(&config_path) {
|
||
if let Ok(json) = serde_json::from_str::<serde_json::Value>(&content) {
|
||
// 尝试多个可能的字段名
|
||
if let Some(id) = json.get("DeviceNumber").and_then(|v| v.as_str()) {
|
||
if !id.is_empty() {
|
||
return id.to_string();
|
||
}
|
||
}
|
||
if let Some(id) = json.get("StationId").and_then(|v| v.as_str()) {
|
||
if !id.is_empty() {
|
||
return id.to_string();
|
||
}
|
||
}
|
||
if let Some(id) = json.get("Station").and_then(|v| v.as_str()) {
|
||
if !id.is_empty() {
|
||
return id.to_string();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
// 读取失败 → 降级到默认值
|
||
"UNKNOWN".to_string()
|
||
}
|
||
|
||
fn is_process_running(process_name: &str) -> bool {
|
||
is_process_running_ex(process_name, None)
|
||
}
|
||
|
||
/// 检查进程是否在运行（可指定要排除的 PID）
|
||
fn is_process_running_ex(process_name: &str, exclude_pid: Option<u32>) -> bool {
|
||
use std::process::id;
|
||
|
||
let current_pid = id();
|
||
let exclude = exclude_pid.unwrap_or(current_pid);
|
||
let output = Command::new("tasklist")
|
||
.args(["/FI", &format!("IMAGENAME eq {}", process_name), "/FO", "CSV"])
|
||
.output()
|
||
.expect("Failed to execute tasklist");
|
||
|
||
let output_str = String::from_utf8_lossy(&output.stdout);
|
||
let lines: Vec<&str> = output_str.lines().collect();
|
||
let mut count = 0;
|
||
|
||
for line in lines {
|
||
if line.contains(&format!("\"{}\"", process_name)) {
|
||
// 解析 PID
|
||
if let Some(pid_part) = line.split(",").nth(1) {
|
||
if let Ok(pid) = pid_part.trim_matches('"').parse::<u32>() {
|
||
if pid != exclude {
|
||
count += 1;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
count > 0
|
||
}
|
||
|
||
/// 获取 AppData 目录下所有候选应用（排除 Updater）
|
||
/// 返回 (app_name, local_version, exe_path) 列表
|
||
/// 版本号和路径在进程运行期间直接从进程路径读取，保证与进程实际加载的一致
|
||
fn get_app_candidates(debug: bool) -> Vec<(String, String, String)> {
|
||
let appdata = get_updater_data_dir(); // X:\AppData\
|
||
if !appdata.exists() {
|
||
return Vec::new();
|
||
}
|
||
|
||
let mut candidates = Vec::new();
|
||
|
||
if let Ok(entries) = fs::read_dir(&appdata) {
|
||
for entry in entries.flatten() {
|
||
let path = entry.path();
|
||
if path.is_dir() {
|
||
if let Some(name) = path.file_name().and_then(|n| n.to_str()) {
|
||
if name != "Updater" && !name.starts_with('.') {
|
||
let exe_name = format!("{}.exe", name);
|
||
if is_process_running(&exe_name) {
|
||
let (local_version, exe_path) = get_version_and_path_from_process(name);
|
||
if debug {
|
||
println!("[应用] 候选应用: {} v{} ({})", name, local_version, exe_path);
|
||
}
|
||
candidates.push((name.to_string(), local_version, exe_path));
|
||
} else if debug {
|
||
println!("[应用] 跳过 {} (进程未运行)", name);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
candidates
|
||
}
|
||
|
||
/// 从运行中进程获取版本号和可执行文件路径
|
||
#[cfg(windows)]
|
||
fn get_version_and_path_from_process(app_name: &str) -> (String, String) {
|
||
let ps_script = format!(
|
||
"$p = Get-Process -Name '{}' -ErrorAction SilentlyContinue | Select-Object -First 1; \
|
||
if ($p -and $p.Path) {{ \
|
||
$v = (Get-Item $p.Path -ErrorAction SilentlyContinue).VersionInfo.FileVersion; \
|
||
\"$v|$($p.Path)\" \
|
||
}} elseif ($p -and $p.Id) {{ \
|
||
$wmi = Get-CimInstance Win32_Process -Filter \"ProcessId=$($p.Id)\" -ErrorAction SilentlyContinue; \
|
||
if ($wmi.ExecutablePath) {{ \
|
||
$v = (Get-Item $wmi.ExecutablePath -ErrorAction SilentlyContinue).VersionInfo.FileVersion; \
|
||
\"$v|$($wmi.ExecutablePath)\" \
|
||
}} \
|
||
}}",
|
||
app_name.replace("'", "''")
|
||
);
|
||
|
||
let output = Command::new("powershell")
|
||
.args(["-NoProfile", "-NonInteractive", "-Command", &ps_script])
|
||
.output();
|
||
|
||
if let Ok(output) = output {
|
||
let stdout = String::from_utf8_lossy(&output.stdout);
|
||
let line = stdout.trim();
|
||
if !line.is_empty() && !line.contains("没有文件") {
|
||
if let Some(sep) = line.find('|') {
|
||
let version = line[..sep].trim().to_string();
|
||
let path = line[sep + 1..].trim().to_string();
|
||
if !version.is_empty() && version != "0" {
|
||
return (version, path);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
("0.0.0".to_string(), String::new())
|
||
}
|
||
|
||
/// 执行应用文件升级：把升级目录中的文件复制到目标目录
|
||
/// 升级目录：X:\AppData\Updater\UpGrade\{app_name}\*
|
||
/// 目标目录：exe_path 的父目录（如 C:\AppData\EasyTest\）
|
||
fn upgrade_app_files(app_name: &str, exe_path: &str) {
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f").to_string();
|
||
|
||
let upgrade_base = get_updater_data_dir()
|
||
.join("Updater")
|
||
.join("UpGrade")
|
||
.join(app_name);
|
||
|
||
if !upgrade_base.exists() {
|
||
log_print!("{} [升级替换] {} 升级目录不存在: {:?}", ts, app_name, upgrade_base);
|
||
return;
|
||
}
|
||
|
||
// 目标目录 = exe_path 的父目录
|
||
let target_dir = std::path::Path::new(exe_path)
|
||
.parent()
|
||
.map(|p| p.to_path_buf())
|
||
.unwrap_or_else(|| std::path::PathBuf::from("."));
|
||
|
||
log_print!("{} [升级替换] {} -> {:?}", ts, app_name, target_dir);
|
||
|
||
let mut success_count = 0;
|
||
let mut fail_count = 0;
|
||
|
||
// 递归扫描升级目录
|
||
fn copy_dir_recursive(src: &std::path::Path, dst: &std::path::Path, ts: &str) -> (i32, i32) {
|
||
let mut ok = 0;
|
||
let mut fail = 0;
|
||
|
||
let _ = fs::create_dir_all(dst);
|
||
|
||
if let Ok(entries) = fs::read_dir(src) {
|
||
for entry in entries.flatten() {
|
||
let src_path = entry.path();
|
||
let file_name = entry.file_name();
|
||
let dst_path = dst.join(&file_name);
|
||
|
||
if src_path.is_dir() {
|
||
let (o, f) = copy_dir_recursive(&src_path, &dst_path, ts);
|
||
ok += o;
|
||
fail += f;
|
||
} else {
|
||
// 跳过 .tmp 文件
|
||
if let Some(name) = file_name.to_str() {
|
||
if name.ends_with(".tmp") {
|
||
continue;
|
||
}
|
||
}
|
||
|
||
// 先删除目标文件（可能只读）
|
||
let _ = fs::remove_file(&dst_path);
|
||
|
||
match fs::copy(&src_path, &dst_path) {
|
||
Ok(_) => {
|
||
log_print!("{} [升级替换] {} -> {}",
|
||
ts, file_name.to_string_lossy(), dst_path.display());
|
||
ok += 1;
|
||
}
|
||
Err(e) => {
|
||
log_print!("{} [升级替换] 复制失败 {}: {}", ts, file_name.to_string_lossy(), e);
|
||
fail += 1;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
(ok, fail)
|
||
}
|
||
|
||
let (ok, fail) = copy_dir_recursive(&upgrade_base, &target_dir, ts.as_str());
|
||
success_count += ok;
|
||
fail_count += fail;
|
||
|
||
log_print!("{} [升级替换] {} 升级完成：成功 {} 个，失败 {} 个",
|
||
ts, app_name, success_count, fail_count);
|
||
}
|
||
|
||
/// 重启指定应用（工作目录 = exe 所在目录）
|
||
fn restart_app(app_name: &str, exe_path: &str) {
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
|
||
// 工作目录 = exe 所在目录
|
||
let work_dir = std::path::Path::new(exe_path)
|
||
.parent()
|
||
.map(|p| p.to_path_buf())
|
||
.unwrap_or_else(|| std::path::PathBuf::from("."));
|
||
|
||
use std::process::Command;
|
||
|
||
match Command::new(exe_path)
|
||
.current_dir(&work_dir)
|
||
.spawn()
|
||
{
|
||
Ok(child) => {
|
||
log_print!("{} [重启] 已启动 {} (PID={})，工作目录: {}",
|
||
ts, app_name, child.id(), work_dir.display());
|
||
}
|
||
Err(e) => {
|
||
log_print!("{} [重启] 启动失败 {}: {}", ts, exe_path, e);
|
||
}
|
||
}
|
||
}
|
||
|
||
/// 递归扫描升级目录，返回 (relative_path, full_path) 列表
|
||
/// 跳过 .tmp 文件（如果存在同名非 tmp 文件的话）
|
||
#[allow(dead_code)]
|
||
fn scan_upgrade_dir(app_name: &str) -> Vec<(String, PathBuf)> {
|
||
let upgrade_base = get_updater_data_dir()
|
||
.join("Updater")
|
||
.join("UpGrade")
|
||
.join(app_name);
|
||
|
||
if !upgrade_base.exists() {
|
||
log_print!("[应用] {} 升级目录不存在: {:?}", app_name, upgrade_base);
|
||
return Vec::new();
|
||
}
|
||
|
||
let mut files = Vec::new();
|
||
let mut visited_dirs = std::collections::VecDeque::new();
|
||
visited_dirs.push_back(upgrade_base.clone());
|
||
|
||
while let Some(dir) = visited_dirs.pop_front() {
|
||
if let Ok(entries) = fs::read_dir(&dir) {
|
||
for entry in entries.flatten() {
|
||
let path = entry.path();
|
||
if path.is_dir() {
|
||
visited_dirs.push_back(path);
|
||
} else if path.is_file() {
|
||
// 计算相对路径
|
||
if let Ok(rel) = path.strip_prefix(&upgrade_base) {
|
||
let rel_str = rel.to_string_lossy().replace('\\', "/");
|
||
let rel_str = rel_str.trim_start_matches('/').to_string();
|
||
|
||
// 如果是 .tmp 文件，检查是否存在对应的非 tmp 文件
|
||
// 如果存在同名非 tmp 文件，则跳过此 tmp 文件
|
||
if rel_str.ends_with(".tmp") {
|
||
let non_tmp = rel_str.trim_end_matches(".tmp");
|
||
let non_tmp_path = upgrade_base.join(non_tmp);
|
||
if non_tmp_path.exists() {
|
||
log_print!("[应用] 跳过 tmp（同名文件已存在）: {} -> {}", rel_str, non_tmp);
|
||
continue;
|
||
}
|
||
}
|
||
|
||
files.push((rel_str, path));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
log_print!("[应用] {} 升级文件列表 ({} 个):", app_name, files.len());
|
||
for (rel, _) in &files {
|
||
log_print!("[应用] - {}", rel);
|
||
}
|
||
|
||
files
|
||
}
|
||
|
||
/// 扫描本地升级目录，返回 .tmp 文件列表（正式文件名 + 大小）
|
||
fn scan_local_tmp_files(app_name: &str) -> Vec<(String, u64)> {
|
||
let upgrade_base = get_updater_data_dir()
|
||
.join("Updater")
|
||
.join("UpGrade")
|
||
.join(app_name);
|
||
|
||
if !upgrade_base.exists() {
|
||
return Vec::new();
|
||
}
|
||
|
||
let mut tmp_files = Vec::new();
|
||
let mut visited_dirs = std::collections::VecDeque::new();
|
||
visited_dirs.push_back(upgrade_base.clone());
|
||
|
||
while let Some(dir) = visited_dirs.pop_front() {
|
||
if let Ok(entries) = fs::read_dir(&dir) {
|
||
for entry in entries.flatten() {
|
||
let path = entry.path();
|
||
if path.is_dir() {
|
||
visited_dirs.push_back(path);
|
||
} else if path.is_file() {
|
||
if let Some(filename) = path.file_name().and_then(|n| n.to_str()) {
|
||
if filename.ends_with(".tmp") {
|
||
// 计算相对路径，并去掉 .tmp 后缀（发送正式文件名）
|
||
if let Ok(rel) = path.strip_prefix(&upgrade_base) {
|
||
let rel_str = rel.to_string_lossy().replace('\\', "/");
|
||
let rel_str = rel_str.trim_start_matches('/').to_string();
|
||
// 去掉 .tmp 后缀，发送正式文件名
|
||
let official_name = rel_str.strip_suffix(".tmp")
|
||
.unwrap_or(&rel_str);
|
||
// 获取文件大小
|
||
if let Ok(metadata) = fs::metadata(&path) {
|
||
// 跳过 0 字节的临时文件（MD5 无意义，视为从头续传）
|
||
if metadata.len() > 0 {
|
||
tmp_files.push((official_name.to_string(), metadata.len()));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
tmp_files
|
||
}
|
||
|
||
/// 发送 GetAllFile 请求
|
||
fn send_get_all_file(
|
||
sender: &cube_lib::websocket::MessageSender,
|
||
app_name: &str,
|
||
tmp_files: &[(String, u64)],
|
||
) {
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
// 构造成 {filename, size} 格式的数组
|
||
let tmp_files_json: Vec<serde_json::Value> = tmp_files.iter()
|
||
.map(|(name, size)| serde_json::json!({
|
||
"filename": name,
|
||
"size": size
|
||
}))
|
||
.collect();
|
||
let tmp_files_str = serde_json::to_string(&tmp_files_json).unwrap_or_else(|_| "[]".to_string());
|
||
let msg_str = format!(
|
||
r#"{{"Type":"GetAllFile","Data":{{"app_name":"{}","tmp_files":{}}}}}"#,
|
||
app_name, tmp_files_str
|
||
);
|
||
log_print!("{} 发送消息：{}", ts, msg_str);
|
||
sender.send(msg_str);
|
||
}
|
||
|
||
// ===================== 向应用发送升级确认 =====================
|
||
|
||
/// 向指定应用发送升级确认消息（修复版：直接用 Win32 API 连接管道，不再用 PowerShell）
|
||
/// 消息格式：{"Type":"UpgradeConfirm","Data":{"AppName":"xxx","CurrentVer":"1.0.0","LatestVer":"1.1.0"}}
|
||
/// 返回 true = 用户批准，false = 用户拒绝/通信失败
|
||
fn notify_app_upgrade(app_name: &str, current_ver: &str, latest_ver: &str, _debug: bool) -> bool {
|
||
#[cfg(windows)]
|
||
{
|
||
use std::process::Command;
|
||
|
||
// 1. 获取所有运行中的进程 PID
|
||
let ps_script = format!(
|
||
"(Get-Process -Name '{}' -ErrorAction SilentlyContinue).Id",
|
||
app_name
|
||
);
|
||
let output = Command::new("powershell")
|
||
.args(["-NoProfile", "-NonInteractive", "-Command", &ps_script])
|
||
.output();
|
||
|
||
let pids: Vec<u32> = match output {
|
||
Ok(o) => {
|
||
let s = String::from_utf8_lossy(&o.stdout);
|
||
s.lines().filter_map(|l| l.trim().parse().ok()).collect()
|
||
}
|
||
Err(_) => return false,
|
||
};
|
||
|
||
if pids.is_empty() {
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
log_print!("{} [升级确认] {} 未运行，跳过通知", ts, app_name);
|
||
return false;
|
||
}
|
||
|
||
// 2. 构造消息
|
||
let msg = format!(
|
||
r#"{{"Type":"UpgradeConfirm","Data":{{"AppName":"{}","CurrentVer":"{}","LatestVer":"{}"}}}}"#,
|
||
app_name, current_ver, latest_ver
|
||
);
|
||
|
||
// 3. 对每个 PID 发送升级确认并等待用户响应（双向握手）
|
||
for pid in pids {
|
||
let pipe_name = format!("\\\\.\\pipe\\EasyTest_{}", pid);
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
log_print!("{} [升级确认] 连接到 {} (PID={})，等待响应...", ts, pipe_name, pid);
|
||
|
||
// 发送 UpgradeConfirm 并等待 UpgradeResponse（超时 10 秒）
|
||
let response = connect_and_wait_response(&pipe_name, &msg, 10000);
|
||
|
||
match response {
|
||
Ok(true) => {
|
||
log_print!("{} [升级确认] 用户批准升级 {} (PID={})，应用将退出",
|
||
ts, app_name, pid);
|
||
return true;
|
||
}
|
||
Ok(false) => {
|
||
log_print!("{} [升级确认] 用户拒绝升级 {} (PID={})",
|
||
ts, app_name, pid);
|
||
return false;
|
||
}
|
||
Err(e) => {
|
||
log_print!("{} [升级确认] 通信失败 {} (PID={}): {}",
|
||
ts, app_name, pid, e);
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
#[cfg(not(windows))]
|
||
{
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
log_print!("{} [升级确认] 非 Windows 平台，跳过通知", ts);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/// 用 Win32 API 连接命名管道，发送消息后等待响应（双向握手）
|
||
/// 返回 Ok(true) = 用户批准，Ok(false) = 用户拒绝，Err = 通信失败/超时
|
||
fn connect_and_wait_response(
|
||
pipe_name: &str,
|
||
msg: &str,
|
||
timeout_ms: u32,
|
||
) -> Result<bool, String> {
|
||
use windows::Win32::Foundation::{CloseHandle, INVALID_HANDLE_VALUE, HANDLE};
|
||
use windows::Win32::Storage::FileSystem::{CreateFileW, WriteFile, ReadFile, FILE_ATTRIBUTE_NORMAL};
|
||
use windows::Win32::System::Threading::CreateEventW;
|
||
use windows::core::PCWSTR;
|
||
|
||
// Windows API 常量
|
||
use windows::Win32::Storage::FileSystem::{FILE_SHARE_MODE, FILE_CREATION_DISPOSITION};
|
||
const GENERIC_READ: u32 = 0x80000000u32;
|
||
const GENERIC_WRITE: u32 = 0x40000000u32;
|
||
const FILE_SHARE_NONE: u32 = 0u32;
|
||
const OPEN_EXISTING: u32 = 3u32;
|
||
|
||
// 将管道名转换为宽字符串
|
||
let wide_name: Vec<u16> = pipe_name.encode_utf16().chain(std::iter::once(0)).collect();
|
||
|
||
// 打开命名管道（同时读写模式）
|
||
let pipe = unsafe {
|
||
CreateFileW(
|
||
PCWSTR::from_raw(wide_name.as_ptr()),
|
||
GENERIC_READ | GENERIC_WRITE,
|
||
FILE_SHARE_MODE(FILE_SHARE_NONE),
|
||
None,
|
||
FILE_CREATION_DISPOSITION(OPEN_EXISTING),
|
||
FILE_ATTRIBUTE_NORMAL,
|
||
None,
|
||
)
|
||
};
|
||
|
||
let pipe = match pipe {
|
||
Ok(h) => h,
|
||
Err(e) => return Err(format!("连接管道失败: {:?}", e)),
|
||
};
|
||
|
||
if pipe == INVALID_HANDLE_VALUE {
|
||
return Err("管道句柄无效".to_string());
|
||
}
|
||
|
||
// 写入消息 + 换行（C# 端用 StreamReader.ReadLine 读取）
|
||
let mut msg_with_newline = msg.to_string();
|
||
msg_with_newline.push_str("\r\n");
|
||
let data = msg_with_newline.as_bytes();
|
||
|
||
let mut written: u32 = 0;
|
||
let write_ok = unsafe {
|
||
WriteFile(
|
||
pipe,
|
||
Some(data),
|
||
Some(&mut written),
|
||
None,
|
||
)
|
||
};
|
||
|
||
if write_ok.is_err() || written == 0 {
|
||
unsafe { let _ = CloseHandle(pipe); };
|
||
return Err("写入消息失败".to_string());
|
||
}
|
||
|
||
// 创建事件用于等待响应（失败则用 INVALID_HANDLE_VALUE）
|
||
let event = unsafe { CreateEventW(None, true, false, None) }
|
||
.unwrap_or(HANDLE(0));
|
||
|
||
let mut buf = [0u8; 4096];
|
||
let mut bytes_read: u32 = 0;
|
||
let mut resp_buf = Vec::new();
|
||
|
||
// 循环读取直到收到完整响应（读到 \n）或超时
|
||
let start_time = std::time::Instant::now();
|
||
let deadline = timeout_ms as u64;
|
||
|
||
loop {
|
||
// 检查是否超时
|
||
if start_time.elapsed().as_millis() as u64 > deadline {
|
||
if event != INVALID_HANDLE_VALUE {
|
||
unsafe { let _ = CloseHandle(event); };
|
||
}
|
||
unsafe { let _ = CloseHandle(pipe); };
|
||
return Err("等待响应超时".to_string());
|
||
}
|
||
|
||
// 尝试读取数据（非阻塞轮询）
|
||
let result = unsafe {
|
||
ReadFile(
|
||
pipe,
|
||
Some(&mut buf),
|
||
Some(&mut bytes_read),
|
||
None,
|
||
)
|
||
};
|
||
|
||
if result.is_ok() && bytes_read > 0 {
|
||
resp_buf.extend_from_slice(&buf[..bytes_read as usize]);
|
||
|
||
// 检查是否包含换行符（完整消息）
|
||
if resp_buf.contains(&b'\n') {
|
||
break;
|
||
}
|
||
}
|
||
|
||
// 短暂等待后重试
|
||
std::thread::sleep(std::time::Duration::from_millis(50));
|
||
}
|
||
|
||
if event != INVALID_HANDLE_VALUE {
|
||
unsafe { let _ = CloseHandle(event); };
|
||
}
|
||
unsafe { let _ = CloseHandle(pipe); };
|
||
|
||
// 解析响应 JSON
|
||
let response = String::from_utf8_lossy(&resp_buf)
|
||
.trim_end_matches(|c| c == '\r' || c == '\n')
|
||
.to_string();
|
||
|
||
// 调试：打印原始响应
|
||
{
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
log_print!("{} [升级确认] 收到原始响应: {:?}", ts, response);
|
||
}
|
||
|
||
// 解析 {"Type":"UpgradeResponse","Approved":true/false}
|
||
if let Some(start) = response.find("\"Approved\":") {
|
||
// "Approved": 共11个字符，true/false 从 start+11 开始
|
||
let rest = &response[start + 11..];
|
||
let approved = rest.starts_with("true");
|
||
return Ok(approved);
|
||
}
|
||
|
||
Err(format!("无法解析响应: {}", response))
|
||
}
|
||
|
||
/// 通知所有升级了的应用（EasyTest 等）
|
||
/// app_upgrades: Vec<(app_name, current_ver, latest_ver, exe_path)>
|
||
fn notify_all_app_upgrades(app_upgrades: &[(String, String, String, String)], _debug: bool) {
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
|
||
if app_upgrades.is_empty() {
|
||
log_print!("{} [升级确认] 没有应用需要升级通知（upgraded_apps 为空）", ts);
|
||
return;
|
||
}
|
||
|
||
log_print!("{} [升级确认] 准备通知 {} 个应用: {:?}", ts, app_upgrades.len(), app_upgrades);
|
||
|
||
for (app_name, current_ver, latest_ver, exe_path) in app_upgrades {
|
||
// 发送升级确认消息，等待用户响应
|
||
let approved = notify_app_upgrade(app_name, current_ver, latest_ver, true);
|
||
|
||
// 用户批准升级后，等待应用退出，然后复制文件并重启
|
||
if approved {
|
||
// 等待应用退出（最多 15 秒）
|
||
log_print!("{} [升级确认] 等待 {} 退出...", ts, app_name);
|
||
let start = std::time::Instant::now();
|
||
let mut exited = false;
|
||
|
||
loop {
|
||
let check = Command::new("powershell")
|
||
.args(["-NoProfile", "-NonInteractive", "-Command",
|
||
&format!("if ((Get-Process -Name '{}' -ErrorAction SilentlyContinue) -eq $null) {{ 'exit' }} else {{ 'running' }}", app_name)])
|
||
.output();
|
||
|
||
if let Ok(out) = check {
|
||
if String::from_utf8_lossy(&out.stdout).contains("exit") {
|
||
exited = true;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if start.elapsed().as_secs() > 15 {
|
||
log_print!("{} [升级确认] 等待退出超时，跳过", ts);
|
||
break;
|
||
}
|
||
|
||
std::thread::sleep(std::time::Duration::from_millis(500));
|
||
}
|
||
|
||
// 应用退出后，复制文件并重启
|
||
if exited {
|
||
upgrade_app_files(app_name, exe_path);
|
||
restart_app(app_name, exe_path);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/// 主动断连信号（用于在消息回调中请求优雅退出）
|
||
/// - shutdown_tx: 从同步回调中发送，通知主循环主动断开
|
||
/// - disconnect_rx: 在主循环中等待
|
||
fn make_shutdown_channel() -> (
|
||
std::sync::Arc<std::sync::Mutex<Option<tokio::sync::oneshot::Sender<()>>>>,
|
||
tokio::sync::oneshot::Receiver<()>,
|
||
) {
|
||
let (tx, rx) = tokio::sync::oneshot::channel();
|
||
(std::sync::Arc::new(std::sync::Mutex::new(Some(tx))), rx)
|
||
}
|
||
|
||
|
||
|
||
/// 运行 Updater（使用 CubeLib 内置的自动重连）
|
||
/// 返回本次运行是否更新了 Updater 自身（只有 Updater 更新了才需要退出重启）
|
||
async fn run_updater(debug_mode: bool) -> bool {
|
||
// 创建本次运行的上下文
|
||
let ctx = Arc::new(UpdateContext::default());
|
||
|
||
// 标记本次运行是否执行了更新（下载了文件）
|
||
let update_performed = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));
|
||
let update_performed_clone = update_performed.clone();
|
||
|
||
// 标记 BootLoader 是否已下载（或无需下载）
|
||
let bootloader_downloaded = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));
|
||
let bootloader_downloaded_clone = bootloader_downloaded.clone();
|
||
|
||
// 标记 Updater 是否已下载
|
||
let updater_downloaded = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));
|
||
let updater_downloaded_clone = updater_downloaded.clone();
|
||
|
||
// 标记一次更新检查是否已完成
|
||
let update_check_done = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));
|
||
let update_check_done_clone = update_check_done.clone();
|
||
|
||
// 主动断连通道
|
||
let (shutdown_tx_arc, mut disconnect_rx) = make_shutdown_channel();
|
||
// 加载初始 URL
|
||
let server_url = resolve_ws_url();
|
||
|
||
// 扫描候选应用（阶段3使用）
|
||
let app_candidates = get_app_candidates(debug_mode);
|
||
|
||
// 将候选应用保存到 ctx
|
||
*ctx.candidates.lock().unwrap() = app_candidates.clone();
|
||
|
||
// 初始化阶段为 BootLoader
|
||
*ctx.current_phase.lock().unwrap() = UpdatePhase::BootLoader;
|
||
|
||
if debug_mode {
|
||
println!("========================================");
|
||
println!("Updater 启动 (调试模式)");
|
||
println!("服务器地址: {}", server_url);
|
||
println!("自动重连: 启用 (指数退避: 1s - 30s)");
|
||
println!("更新阶段: BootLoader -> Updater -> Apps -> Complete");
|
||
if !app_candidates.is_empty() {
|
||
println!("候选应用: {:?}", app_candidates);
|
||
}
|
||
println!("========================================");
|
||
}
|
||
|
||
// 创建 WebSocket 配置（启用自动重连和心跳）
|
||
let config = WebSocketConfig::new(&server_url)
|
||
.with_client_type("Updater")
|
||
.with_debug(debug_mode)
|
||
.with_reconnect(true) // 启用自动重连
|
||
.with_reconnect_delay(1000) // 初始延迟 1s
|
||
.with_max_reconnect_delay(30000) // 最大延迟 30s
|
||
.with_heartbeat(30000); // 30秒心跳间隔
|
||
|
||
// 创建 WebSocket 客户端
|
||
let mut client = WebSocketClient::new(config);
|
||
|
||
// 设置连接成功回调
|
||
let debug_connected = debug_mode;
|
||
client.on_connected(move |url| {
|
||
if debug_connected {
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
println!("{} 收到消息：{}", ts, url);
|
||
}
|
||
});
|
||
|
||
// 设置消息接收回调
|
||
let debug_msg = debug_mode;
|
||
let device_number = resolve_device_number();
|
||
let shutdown_tx_arc_clone = shutdown_tx_arc.clone();
|
||
let ctx_clone = ctx.clone();
|
||
let update_performed_clone2 = update_performed_clone.clone();
|
||
let bootloader_downloaded_clone2 = bootloader_downloaded_clone.clone();
|
||
let updater_downloaded_clone2 = updater_downloaded_clone.clone();
|
||
let update_check_done_clone2 = update_check_done_clone.clone();
|
||
client.on_message(move |msg_type, data, sender| {
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
|
||
// 收到消息日志（始终记录）
|
||
// FileChunk 跳过完整 Data 序列化（Data 中含约40KB base64，同步阻塞tokio runtime导致30秒延迟）
|
||
if msg_type == "FileChunk" {
|
||
let filename = data.get("Data")
|
||
.and_then(|v| v.get("filename"))
|
||
.and_then(|v| v.as_str())
|
||
.unwrap_or("?");
|
||
let offset = data.get("Data")
|
||
.and_then(|v| v.get("offset"))
|
||
.and_then(|v| v.as_u64())
|
||
.unwrap_or(0);
|
||
let is_last = data.get("Data")
|
||
.and_then(|v| v.get("is_last"))
|
||
.and_then(|v| v.as_bool())
|
||
.unwrap_or(false);
|
||
log_print!("{} 收到消息：{{\"Type\":\"FileChunk\",\"filename\":\"{}\",\"offset\":{},\"is_last\":{}}}",
|
||
ts, filename, offset, is_last);
|
||
} else {
|
||
let actual_data = data.get("Data").unwrap_or(&serde_json::Value::Null);
|
||
let data_str = serde_json::to_string(actual_data).unwrap_or_else(|_| "{}".to_string());
|
||
log_print!("{} 收到消息：{{\"Type\":{},\"Data\":{}}}",
|
||
ts,
|
||
serde_json::to_string(&msg_type).unwrap_or_default(),
|
||
data_str
|
||
);
|
||
}
|
||
|
||
// 收到 welcome 后，重置状态并从头开始执行流程
|
||
if msg_type == "welcome" {
|
||
// 重连后强制从头开始
|
||
*ctx_clone.current_phase.lock().unwrap() = UpdatePhase::BootLoader;
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
log_print!("{} [重连] 重置状态，从头开始执行流程", ts);
|
||
|
||
// 等待 device_number 生效（无次数限制，每10秒重试一次）
|
||
let wait_seconds = 10;
|
||
let mut current_device = device_number.clone();
|
||
let mut attempt = 0;
|
||
|
||
log_print!("{} [调试] 初始 DeviceNumber: '{}'", ts, current_device);
|
||
|
||
loop {
|
||
if !current_device.is_empty() && current_device != "UNKNOWN" {
|
||
// 阶段1：只请求 BootLoader.exe
|
||
log_print!("{} [阶段1] 检查 BootLoader (DeviceNumber: '{}')...", ts, current_device);
|
||
let msg_str = format!(
|
||
r#"{{"Type":"GetFileVer","Data":{{"DeviceNumber":"{}","file_list":["BootLoader.exe"]}}}}"#,
|
||
current_device
|
||
);
|
||
log_print!("{} 发送消息：{}", ts, msg_str);
|
||
sender.send(msg_str);
|
||
log_print!("{} [调试] GetFileVer 消息已发送", ts);
|
||
break;
|
||
}
|
||
|
||
attempt += 1;
|
||
log_print!("{} [警告] DeviceNumber 为空或 UNKNOWN (尝试 {})，等待 {} 秒后重试...",
|
||
ts, attempt, wait_seconds);
|
||
std::thread::sleep(std::time::Duration::from_secs(wait_seconds));
|
||
// 重新读取配置文件（可能刚被写入）
|
||
current_device = resolve_device_number();
|
||
log_print!("{} [调试] 重新读取 DeviceNumber: '{}'", ts, current_device);
|
||
}
|
||
}
|
||
|
||
// 处理 FileVer 响应（根据当前阶段分发）
|
||
if msg_type == "FileVer" {
|
||
if let Some(file_versions) = data.get("Data").and_then(|d| d.get("file_versions")).and_then(|v| v.as_object()) {
|
||
let current_phase = *ctx_clone.current_phase.lock().unwrap();
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
|
||
match current_phase {
|
||
UpdatePhase::AppsWaitAllFile => {
|
||
// 等待 AllFile 响应，忽略 FileVer
|
||
}
|
||
UpdatePhase::BootLoader => {
|
||
// ========== 阶段1：处理 BootLoader ==========
|
||
if let Some(server_ver) = file_versions.get("BootLoader.exe") {
|
||
let server_version = server_ver.as_str().unwrap_or("0.0.0");
|
||
let local_version = get_local_file_version("BootLoader.exe");
|
||
let tmp_size = get_tmp_file_size("BootLoader.exe");
|
||
|
||
log_print!("{} [版本] BootLoader.exe: 服务端={}, 本地={}", ts, server_version, local_version);
|
||
|
||
let need_update = local_version == "0.0.0" || version_less_than(&local_version, server_version);
|
||
if need_update {
|
||
if tmp_size > 0 {
|
||
log_print!("{} [续传] BootLoader.exe 发现未完成下载，请求 hash 校验...", ts);
|
||
request_file_md5(&sender, "BootLoader.exe", tmp_size);
|
||
} else {
|
||
log_print!("{} [升级] BootLoader.exe 需要更新，开始下载...", ts);
|
||
request_download(&sender, "BootLoader.exe", 0);
|
||
}
|
||
update_performed_clone2.store(true, std::sync::atomic::Ordering::SeqCst);
|
||
} else {
|
||
log_print!("{} [版本] BootLoader.exe 版本已是最新", ts);
|
||
// 推进到阶段2
|
||
let next_phase = UpdatePhase::Updater;
|
||
*ctx_clone.current_phase.lock().unwrap() = next_phase;
|
||
log_print!("{} [阶段2] 检查 Updater...", ts);
|
||
|
||
let msg_str = format!(
|
||
r#"{{"Type":"GetFileVer","Data":{{"DeviceNumber":"{}","file_list":["Updater.exe"]}}}}"#,
|
||
device_number
|
||
);
|
||
log_print!("{} 发送消息：{}", ts, msg_str);
|
||
sender.send(msg_str);
|
||
}
|
||
} else {
|
||
// BootLoader 不在响应中，推进到阶段2
|
||
*ctx_clone.current_phase.lock().unwrap() = UpdatePhase::Updater;
|
||
log_print!("{} [阶段2] 检查 Updater...", ts);
|
||
|
||
let msg_str = format!(
|
||
r#"{{"Type":"GetFileVer","Data":{{"DeviceNumber":"{}","file_list":["Updater.exe"]}}}}"#,
|
||
device_number
|
||
);
|
||
log_print!("{} 发送消息：{}", ts, msg_str);
|
||
sender.send(msg_str);
|
||
}
|
||
}
|
||
|
||
UpdatePhase::Updater => {
|
||
// ========== 阶段2：处理 Updater ==========
|
||
if let Some(server_ver) = file_versions.get("Updater.exe") {
|
||
let server_version = server_ver.as_str().unwrap_or("0.0.0");
|
||
let local_version = get_local_file_version("Updater.exe");
|
||
let tmp_size = get_tmp_file_size("Updater.exe");
|
||
|
||
// 保存 Updater.exe 的服务端版本号
|
||
*ctx_clone.server_updater_version.lock().unwrap() = Some(server_version.to_string());
|
||
|
||
log_print!("{} [版本] Updater.exe: 服务端={}, 本地={}", ts, server_version, local_version);
|
||
|
||
let need_update = local_version == "0.0.0" || version_less_than(&local_version, server_version);
|
||
if need_update {
|
||
if tmp_size > 0 {
|
||
log_print!("{} [续传] Updater.exe 发现未完成下载，请求 hash 校验...", ts);
|
||
request_file_md5(&sender, "Updater.exe", tmp_size);
|
||
} else {
|
||
log_print!("{} [升级] Updater.exe 需要更新，开始下载...", ts);
|
||
request_download(&sender, "Updater.exe", 0);
|
||
}
|
||
update_performed_clone2.store(true, std::sync::atomic::Ordering::SeqCst);
|
||
} else {
|
||
log_print!("{} [版本] Updater.exe 版本已是最新", ts);
|
||
// 检查是否有旧的 Updater.new.exe
|
||
if has_updater_new_exe() {
|
||
let updater_new_path = get_updater_data_dir().join("Updater.new.exe");
|
||
let _ = fs::remove_file(&updater_new_path);
|
||
log_print!("{} [清理] 删除旧的 Updater.new.exe", ts);
|
||
}
|
||
|
||
// 推进到阶段3
|
||
let candidates = ctx_clone.candidates.lock().unwrap().clone();
|
||
if candidates.is_empty() {
|
||
// 没有候选应用，所有阶段完成
|
||
*ctx_clone.current_phase.lock().unwrap() = UpdatePhase::Complete;
|
||
log_print!("{} [阶段3] 没有候选应用，所有阶段完成", ts);
|
||
update_check_done_clone2.store(true, std::sync::atomic::Ordering::SeqCst);
|
||
// 发送断连信号
|
||
if let Some(tx) = shutdown_tx_arc_clone.lock().unwrap().take() {
|
||
let _ = tx.send(());
|
||
}
|
||
} else {
|
||
*ctx_clone.current_phase.lock().unwrap() = UpdatePhase::Apps;
|
||
// 打印候选应用及其预存版本
|
||
let app_names: Vec<String> = candidates.iter().map(|(n, v, _)| format!("{}(v{})", n, v)).collect();
|
||
log_print!("{} [阶段3] 检查应用: {:?}", ts, app_names);
|
||
|
||
// 构建应用版本查询
|
||
let mut file_list = Vec::new();
|
||
for (app_name, _, _) in &candidates {
|
||
file_list.push(format!("{}\\{}.exe", app_name, app_name));
|
||
}
|
||
let file_list_json = serde_json::to_string(&file_list).unwrap_or_else(|_| "[]".to_string());
|
||
let msg_str = format!(
|
||
r#"{{"Type":"GetFileVer","Data":{{"DeviceNumber":"{}","file_list":{}}}}}"#,
|
||
device_number, file_list_json
|
||
);
|
||
log_print!("{} 发送消息：{}", ts, msg_str);
|
||
sender.send(msg_str);
|
||
}
|
||
}
|
||
} else {
|
||
// Updater 不在响应中，推进到阶段3
|
||
let candidates = ctx_clone.candidates.lock().unwrap().clone();
|
||
if candidates.is_empty() {
|
||
*ctx_clone.current_phase.lock().unwrap() = UpdatePhase::Complete;
|
||
println!("{} [阶段3] 没有候选应用，所有阶段完成", ts);
|
||
update_check_done_clone2.store(true, std::sync::atomic::Ordering::SeqCst);
|
||
if let Some(tx) = shutdown_tx_arc_clone.lock().unwrap().take() {
|
||
let _ = tx.send(());
|
||
}
|
||
} else {
|
||
*ctx_clone.current_phase.lock().unwrap() = UpdatePhase::Apps;
|
||
// 打印候选应用及其预存版本
|
||
let app_names: Vec<String> = candidates.iter().map(|(n, v, _)| format!("{}(v{})", n, v)).collect();
|
||
println!("{} [阶段3] 检查应用: {:?}", ts, app_names);
|
||
|
||
let mut file_list = Vec::new();
|
||
for (app_name, _, _) in &candidates {
|
||
file_list.push(format!("{}\\{}.exe", app_name, app_name));
|
||
}
|
||
let file_list_json = serde_json::to_string(&file_list).unwrap_or_else(|_| "[]".to_string());
|
||
let msg_str = format!(
|
||
r#"{{"Type":"GetFileVer","Data":{{"DeviceNumber":"{}","file_list":{}}}}}"#,
|
||
device_number, file_list_json
|
||
);
|
||
log_print!("{} 发送消息：{}", ts, msg_str);
|
||
sender.send(msg_str);
|
||
}
|
||
}
|
||
}
|
||
|
||
UpdatePhase::Apps => {
|
||
// ========== 阶段3：处理应用版本，决定是否需要升级 ==========
|
||
// 使用预存的版本（在候选发现阶段已从运行中进程读取）
|
||
let candidates = ctx_clone.candidates.lock().unwrap().clone();
|
||
let mut apps_to_update = Vec::new();
|
||
let mut upgraded_apps = Vec::new(); // (app_name, current_ver, latest_ver, exe_path)
|
||
|
||
for (app_name, local_version, exe_path) in candidates {
|
||
let exe_name = format!("{}\\{}.exe", app_name, app_name);
|
||
if let Some(server_ver) = file_versions.get(&exe_name) {
|
||
let server_version = server_ver.as_str().unwrap_or("");
|
||
// 服务端版本为空，说明没有该应用，跳过
|
||
if server_version.is_empty() {
|
||
log_print!("{} [应用] {} 服务端版本为空，跳过升级", ts, app_name);
|
||
continue;
|
||
}
|
||
|
||
log_print!("{} [应用] {}: 服务端={}, 本地={}", ts, app_name, server_version, local_version);
|
||
|
||
if local_version == "0.0.0" || version_less_than(&local_version, server_version) {
|
||
apps_to_update.push(app_name.clone());
|
||
// 记录需要升级的应用信息（用于后续发送通知）
|
||
upgraded_apps.push((app_name.clone(), local_version.clone(), server_version.to_string(), exe_path.clone()));
|
||
}
|
||
}
|
||
}
|
||
|
||
// 保存升级应用列表
|
||
*ctx_clone.upgraded_apps.lock().unwrap() = upgraded_apps;
|
||
|
||
if apps_to_update.is_empty() {
|
||
// 没有需要更新的应用，所有阶段完成
|
||
log_print!("{} [阶段完成] 所有应用已是最新版本，等待下次检查...", ts);
|
||
*ctx_clone.current_phase.lock().unwrap() = UpdatePhase::Complete;
|
||
update_check_done_clone2.store(true, std::sync::atomic::Ordering::SeqCst);
|
||
if let Some(tx) = shutdown_tx_arc_clone.lock().unwrap().take() {
|
||
let _ = tx.send(());
|
||
}
|
||
} else {
|
||
// 存储待处理的应用列表，发送 GetAllFile 请求
|
||
*ctx_clone.pending_allfile_apps.lock().unwrap() = apps_to_update.clone();
|
||
*ctx_clone.current_phase.lock().unwrap() = UpdatePhase::AppsWaitAllFile;
|
||
log_print!("{} [阶段3.5] 等待 GetAllFile 响应 ({} 个应用)", ts, apps_to_update.len());
|
||
|
||
for app_name in &apps_to_update {
|
||
let tmp_files = scan_local_tmp_files(app_name);
|
||
send_get_all_file(&sender, app_name, &tmp_files);
|
||
}
|
||
}
|
||
}
|
||
|
||
UpdatePhase::Complete => {
|
||
// 已在 Complete 阶段，不再处理
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 处理 Md5 响应
|
||
if msg_type == "Md5" {
|
||
if let Some(md5_data) = data.get("Data").and_then(|v| v.as_object()) {
|
||
let filename = md5_data.get("filename").and_then(|v| v.as_str()).unwrap_or("");
|
||
if filename.is_empty() {
|
||
return;
|
||
}
|
||
|
||
// ========== BootLoader/Updater 的 Md5 处理 ==========
|
||
let server_md5 = md5_data.get("md5").and_then(|v| v.as_str()).unwrap_or("");
|
||
let bytes = md5_data.get("bytes").and_then(|v| v.as_u64()).unwrap_or(0);
|
||
// Updater.exe 的临时文件名是 Updater.new.exe.tmp
|
||
let tmp_filename = if filename == "Updater.exe" {
|
||
"Updater.new.exe.tmp".to_string()
|
||
} else {
|
||
format!("{}.tmp", filename)
|
||
};
|
||
|
||
// 计算本地 tmp 文件前 bytes 字节的 md5
|
||
let local_md5 = compute_file_hash(&tmp_filename, bytes, debug_msg);
|
||
|
||
if debug_msg {
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
if let Some(ref lm) = local_md5 {
|
||
println!("{} [续传] {} md5对比: 本地={}, 服务端={}", ts, filename, lm, server_md5);
|
||
} else {
|
||
println!("{} [续传] {} 无法计算本地md5，重新下载", ts, filename);
|
||
}
|
||
}
|
||
|
||
// 比较 md5
|
||
if local_md5.as_deref() == Some(server_md5) {
|
||
// md5 相同，从 offset bytes 处续传
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
log_print!("{} [续传] {} md5匹配，从 {} 字节处续传", ts, filename, bytes);
|
||
request_download(&sender, filename, bytes);
|
||
} else {
|
||
// md5 不同，删除临时文件，重新下载
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
log_print!("{} [续传] {} md5不匹配，重新下载", ts, filename);
|
||
let tmp_path = get_updater_data_dir().join(&tmp_filename);
|
||
let _ = fs::remove_file(&tmp_path);
|
||
request_download(&sender, filename, 0);
|
||
}
|
||
}
|
||
}
|
||
|
||
// 处理 AllFile 响应
|
||
if msg_type == "AllFile" {
|
||
if let Some(allfile_data) = data.get("Data").and_then(|v| v.as_object()) {
|
||
let app_name = allfile_data.get("app_name").and_then(|v| v.as_str()).unwrap_or("");
|
||
if app_name.is_empty() {
|
||
return;
|
||
}
|
||
|
||
// 检查是否在等待此应用的响应
|
||
let mut pending_apps = ctx_clone.pending_allfile_apps.lock().unwrap();
|
||
if !pending_apps.contains(&app_name.to_string()) {
|
||
return;
|
||
}
|
||
pending_apps.retain(|a| a != app_name);
|
||
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
log_print!("{} [AllFile] 处理 {} 的文件列表", ts, app_name);
|
||
|
||
// 获取服务端文件列表
|
||
let server_files: Vec<(String, u64, String)> = allfile_data
|
||
.get("files")
|
||
.and_then(|v| v.as_array())
|
||
.map(|arr| {
|
||
arr.iter().filter_map(|f| {
|
||
let filename = f.get("filename").and_then(|v| v.as_str())?;
|
||
let size = f.get("size").and_then(|v| v.as_u64()).unwrap_or(0);
|
||
let md5 = f.get("md5").and_then(|v| v.as_str()).unwrap_or("");
|
||
Some((filename.to_string(), size, md5.to_string()))
|
||
}).collect()
|
||
})
|
||
.unwrap_or_default();
|
||
|
||
// 获取服务端临时文件列表
|
||
let _server_tmp_files: Vec<(String, Option<u64>, Option<String>)> = allfile_data
|
||
.get("tmp_files")
|
||
.and_then(|v| v.as_array())
|
||
.map(|arr| {
|
||
arr.iter().filter_map(|f| {
|
||
let filename = f.get("filename").and_then(|v| v.as_str())?;
|
||
let size = f.get("size").and_then(|v| v.as_u64());
|
||
let md5 = f.get("md5").and_then(|v| v.as_str());
|
||
Some((
|
||
filename.to_string(),
|
||
size,
|
||
md5.map(|s| s.to_string()),
|
||
))
|
||
}).collect()
|
||
})
|
||
.unwrap_or_default();
|
||
|
||
// 升级目录
|
||
let upgrade_base = get_updater_data_dir()
|
||
.join("Updater")
|
||
.join("UpGrade")
|
||
.join(app_name);
|
||
|
||
// 1. 扫描本地文件（分别记录正式文件和 tmp 文件）
|
||
let mut local_files: std::collections::HashSet<String> = std::collections::HashSet::new();
|
||
#[allow(dead_code)]
|
||
let mut local_tmp_files: std::collections::HashSet<String> = std::collections::HashSet::new();
|
||
if upgrade_base.exists() {
|
||
if let Ok(entries) = fs::read_dir(&upgrade_base) {
|
||
for entry in entries.flatten() {
|
||
let path = entry.path();
|
||
if path.is_file() {
|
||
if let Some(name) = path.file_name().and_then(|n| n.to_str()) {
|
||
if name.ends_with(".tmp") {
|
||
// tmp 文件：去掉 .tmp 后缀存储
|
||
let official_name = name.trim_end_matches(".tmp");
|
||
local_tmp_files.insert(official_name.to_string());
|
||
} else {
|
||
local_files.insert(name.to_string());
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 2. 以服务端为准，删除本地多余的正式文件和临时文件
|
||
let server_official_names: std::collections::HashSet<String> = server_files
|
||
.iter()
|
||
.map(|(name, _, _)| name.clone())
|
||
.collect();
|
||
|
||
for local_file in &local_files {
|
||
if !server_official_names.contains(local_file) {
|
||
// 删除本地正式文件
|
||
let file_path = upgrade_base.join(local_file);
|
||
if file_path.exists() {
|
||
log_print!("{} [AllFile] 删除多余正式文件: {}", ts, local_file);
|
||
let _ = fs::remove_file(&file_path);
|
||
}
|
||
// 同时删除对应的临时文件（如有）
|
||
let tmp_file_with_ext = format!("{}.tmp", local_file);
|
||
let tmp_path = upgrade_base.join(&tmp_file_with_ext);
|
||
if tmp_path.exists() {
|
||
log_print!("{} [AllFile] 删除多余临时文件: {}", ts, tmp_file_with_ext);
|
||
let _ = fs::remove_file(&tmp_path);
|
||
}
|
||
}
|
||
}
|
||
|
||
// 3. 处理服务端文件列表：比较 MD5，将需要下载的文件加入队列
|
||
let mut downloads_to_queue: Vec<(String, String, u64, String)> = Vec::new();
|
||
for (filename, _, server_md5) in &server_files {
|
||
let file_path = upgrade_base.join(filename);
|
||
let tmp_filename = format!("{}.tmp", filename);
|
||
let tmp_path = upgrade_base.join(&tmp_filename);
|
||
let has_tmp = tmp_path.exists();
|
||
let has_official = file_path.exists();
|
||
let tmp_is_zero = has_tmp && tmp_path.metadata().map(|m| m.len() == 0).unwrap_or(false);
|
||
|
||
if has_tmp {
|
||
if tmp_is_zero {
|
||
// 情况0：本地有 0 字节临时文件，直接从头下载
|
||
downloads_to_queue.push((app_name.to_string(), filename.to_string(), 0, server_md5.clone()));
|
||
update_performed_clone2.store(true, std::sync::atomic::Ordering::SeqCst);
|
||
} else {
|
||
// 情况A：本地有临时文件（>0字节）→ 比较临时文件
|
||
let local_md5 = compute_file_md5(&tmp_path);
|
||
if let Some(lm) = local_md5 {
|
||
if &lm != server_md5 {
|
||
log_print!("{} [AllFile] tmp {} MD5不一致 (本地={}, 服务端={})，清空", ts, tmp_filename, lm, server_md5);
|
||
if let Ok(file) = fs::File::create(&tmp_path) {
|
||
let _ = file.set_len(0);
|
||
}
|
||
downloads_to_queue.push((app_name.to_string(), filename.to_string(), 0, server_md5.clone()));
|
||
update_performed_clone2.store(true, std::sync::atomic::Ordering::SeqCst);
|
||
} else {
|
||
log_print!("{} [AllFile] tmp {} MD5一致，续传", ts, tmp_filename);
|
||
let file_size = fs::metadata(&tmp_path).map(|m| m.len()).unwrap_or(0);
|
||
downloads_to_queue.push((app_name.to_string(), filename.to_string(), file_size, server_md5.clone()));
|
||
}
|
||
}
|
||
}
|
||
} else if has_official {
|
||
// 情况B：本地没有临时文件但有正式文件 → 比较正式文件
|
||
let local_md5 = compute_file_md5(&file_path);
|
||
if let Some(lm) = local_md5 {
|
||
if &lm != server_md5 {
|
||
log_print!("{} [AllFile] {} MD5不一致 (本地={}, 服务端={})，创建 tmp", ts, filename, lm, server_md5);
|
||
if let Some(parent) = tmp_path.parent() {
|
||
let _ = fs::create_dir_all(parent);
|
||
}
|
||
if let Ok(_) = File::create(&tmp_path) {
|
||
log_print!("{} [AllFile] 创建空 tmp 文件: {}", ts, tmp_filename);
|
||
downloads_to_queue.push((app_name.to_string(), filename.to_string(), 0, server_md5.clone()));
|
||
update_performed_clone2.store(true, std::sync::atomic::Ordering::SeqCst);
|
||
}
|
||
} else {
|
||
log_print!("{} [AllFile] {} MD5一致，无需更新", ts, filename);
|
||
}
|
||
}
|
||
} else {
|
||
// 情况C：本地连正式文件都没有 → 直接创建空的临时文件
|
||
log_print!("{} [AllFile] {} 不存在，创建 tmp", ts, filename);
|
||
if let Some(parent) = tmp_path.parent() {
|
||
let _ = fs::create_dir_all(parent);
|
||
}
|
||
if let Ok(_) = File::create(&tmp_path) {
|
||
log_print!("{} [AllFile] 创建空 tmp 文件: {}", ts, tmp_filename);
|
||
downloads_to_queue.push((app_name.to_string(), filename.to_string(), 0, server_md5.clone()));
|
||
update_performed_clone2.store(true, std::sync::atomic::Ordering::SeqCst);
|
||
}
|
||
}
|
||
}
|
||
|
||
// 4. 将所有待下载文件加入队列，按顺序发送第一个
|
||
if !downloads_to_queue.is_empty() {
|
||
let mut queue = ctx_clone.download_queue.lock().unwrap();
|
||
for item in downloads_to_queue {
|
||
queue.push_back(item);
|
||
}
|
||
drop(queue);
|
||
|
||
// 如果当前没有在下载，发第一个
|
||
let should_start = {
|
||
let downloading = ctx_clone.is_downloading.lock().unwrap();
|
||
!*downloading
|
||
};
|
||
if should_start {
|
||
*ctx_clone.is_downloading.lock().unwrap() = true;
|
||
send_next_download(&ctx_clone, &sender, &shutdown_tx_arc_clone);
|
||
}
|
||
}
|
||
|
||
// 6. 检查是否所有应用都处理完成（AllFile 收完 且 队列清空）
|
||
if pending_apps.is_empty() && ctx_clone.download_queue.lock().unwrap().is_empty() {
|
||
log_print!("{} [AllFile] 所有应用文件同步完成，进入 Complete 阶段", ts);
|
||
*ctx_clone.current_phase.lock().unwrap() = UpdatePhase::Complete;
|
||
update_check_done_clone2.store(true, std::sync::atomic::Ordering::SeqCst);
|
||
if let Some(tx) = shutdown_tx_arc_clone.lock().unwrap().take() {
|
||
let _ = tx.send(());
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 处理文件块
|
||
if msg_type == "FileChunk" {
|
||
if let Some(data_obj) = data.get("Data").and_then(|v| v.as_object()) {
|
||
let filename = data_obj.get("filename").and_then(|v| v.as_str()).unwrap_or("");
|
||
|
||
let current_phase = *ctx_clone.current_phase.lock().unwrap();
|
||
|
||
// ========== 阶段3.5：处理应用 FileChunk ==========
|
||
if current_phase == UpdatePhase::AppsWaitAllFile && !filename.is_empty() {
|
||
let is_last = data_obj.get("is_last").and_then(|v| v.as_bool()).unwrap_or(false);
|
||
let chunk_offset = data_obj.get("offset").and_then(|v| v.as_u64()).unwrap_or(0);
|
||
let file_size = data_obj.get("file_size").and_then(|v| v.as_u64()).unwrap_or(0);
|
||
let chunk_size = 4096u64;
|
||
|
||
// 调试：打印队列状态
|
||
let queue_len = ctx_clone.download_queue.lock().unwrap().len();
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
log_print!("{} [FileChunk] is_last={}, queue_len={}", ts, is_last, queue_len);
|
||
|
||
let candidates = ctx_clone.candidates.lock().unwrap().clone();
|
||
for (app_name, _, _) in &candidates {
|
||
let result = handle_app_file_chunk(&ctx_clone, app_name, data_obj, debug_msg);
|
||
if let Some((_, relative_path)) = result {
|
||
if is_last {
|
||
// 文件下完，标记并请求下一个文件
|
||
if debug_msg {
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
println!("{} [应用] {} / {} 下载完成", ts, app_name, filename);
|
||
}
|
||
ctx_clone.app_completed_set.lock().unwrap().insert(format!("{}/{}", app_name, filename));
|
||
log_print!("{} [FileChunk] 调用 send_next_download, queue_len={}", ts, queue_len);
|
||
send_next_download(&ctx_clone, &sender, &shutdown_tx_arc_clone);
|
||
} else {
|
||
// 非最后一块，立即请求下一块（用 relative_path，不带 app_name/ 前缀）
|
||
let next_offset = chunk_offset + chunk_size;
|
||
if next_offset < file_size {
|
||
request_download_for_app(&sender, app_name, &relative_path, next_offset);
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
} else {
|
||
// ========== BootLoader/Updater 的 FileChunk 处理 ==========
|
||
let completed = handle_file_chunk(&ctx_clone, data_obj, debug_msg);
|
||
if let Some(ref completed_file) = completed {
|
||
// BootLoader 下载完成：推进到阶段2
|
||
if completed_file == "BootLoader.exe" {
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
*ctx_clone.current_phase.lock().unwrap() = UpdatePhase::Updater;
|
||
log_print!("{} [阶段2] 检查 Updater...", ts);
|
||
let msg_str = format!(
|
||
r#"{{"Type":"GetFileVer","Data":{{"DeviceNumber":"{}","file_list":["Updater.exe"]}}}}"#,
|
||
device_number
|
||
);
|
||
log_print!("{} 发送消息：{}", ts, msg_str);
|
||
sender.send(msg_str);
|
||
}
|
||
// Updater 下载完成：启动 BootLoader
|
||
if completed_file == "Updater.new.exe" {
|
||
if !updater_downloaded_clone2.load(std::sync::atomic::Ordering::SeqCst) {
|
||
updater_downloaded_clone2.store(true, std::sync::atomic::Ordering::SeqCst);
|
||
if debug_msg {
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
println!("{} [升级] Updater.new.exe 下载完成（FileChunk），准备启动 BootLoader...", ts);
|
||
}
|
||
schedule_bootloader_launch(debug_msg, shutdown_tx_arc_clone.clone());
|
||
}
|
||
}
|
||
} else {
|
||
// 非最后一块：主动请求下一块（BootLoader/Updater 流式下载需客户端驱动）
|
||
let is_last = data_obj.get("is_last").and_then(|v| v.as_bool()).unwrap_or(false);
|
||
let chunk_offset = data_obj.get("offset").and_then(|v| v.as_u64()).unwrap_or(0);
|
||
let file_size = data_obj.get("file_size").and_then(|v| v.as_u64()).unwrap_or(0);
|
||
let chunk_size = 4096u64;
|
||
if !is_last {
|
||
let next_offset = chunk_offset + chunk_size;
|
||
if next_offset < file_size {
|
||
request_download(&sender, filename, next_offset);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 处理下载完成（统一处理，避免 FileChunk 和 DownloadComplete 重复处理）
|
||
if msg_type == "DownloadComplete" {
|
||
if let Some(data_obj) = data.get("Data").and_then(|v| v.as_object()) {
|
||
let filename = data_obj.get("filename").and_then(|v| v.as_str()).unwrap_or("");
|
||
if filename.is_empty() {
|
||
return;
|
||
}
|
||
|
||
let current_phase = *ctx_clone.current_phase.lock().unwrap();
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
|
||
// 调试：所有 DownloadComplete 都打印阶段信息
|
||
let phase_name = match current_phase {
|
||
UpdatePhase::BootLoader => "BootLoader",
|
||
UpdatePhase::Updater => "Updater",
|
||
UpdatePhase::Apps => "Apps",
|
||
UpdatePhase::AppsWaitAllFile => "AppsWaitAllFile",
|
||
UpdatePhase::Complete => "Complete",
|
||
};
|
||
log_print!("{} [DownloadComplete] 收到文件: {}, 当前阶段: {}", ts, filename, phase_name);
|
||
|
||
// ========== 阶段3.5：处理应用 DownloadComplete ==========
|
||
if current_phase == UpdatePhase::AppsWaitAllFile {
|
||
let candidates = ctx_clone.candidates.lock().unwrap().clone();
|
||
let candidate_names: Vec<&str> = candidates.iter().map(|(n, _, _)| n.as_str()).collect();
|
||
log_print!("{} [DownloadComplete] 文件: {}, 候选应用: {:?}", ts, filename, candidate_names);
|
||
for (app_name, _, _) in &candidates {
|
||
// filename 可能含路径分隔符（如 "EasyTest/Audio.wav"），只取纯文件名部分
|
||
let tmp_filename = std::path::Path::new(filename)
|
||
.file_name()
|
||
.and_then(|n| n.to_str())
|
||
.unwrap_or(filename);
|
||
let upgrade_dir = get_updater_data_dir()
|
||
.join("Updater")
|
||
.join("UpGrade")
|
||
.join(app_name);
|
||
let tmp_path = upgrade_dir.join(format!("{}.tmp", tmp_filename));
|
||
// rename 后的最终路径（与 handle_app_file_chunk 的 is_last 块保持一致）
|
||
let final_path = upgrade_dir.join(tmp_filename);
|
||
// tmp 或 final 文件存在才处理
|
||
log_print!("{} [DownloadComplete] 检查路径: tmp={:?}, final={:?}, tmp_exists={}, final_exists={}",
|
||
ts, tmp_path, final_path, tmp_path.exists(), final_path.exists());
|
||
if !tmp_path.exists() && !final_path.exists() {
|
||
continue;
|
||
}
|
||
|
||
let size = data_obj.get("size").and_then(|v| v.as_u64()).unwrap_or(0);
|
||
handle_app_download_complete(&ctx_clone, app_name, filename, size, debug_msg);
|
||
ctx_clone.app_completed_set.lock().unwrap().insert(format!("{}/{}", app_name, filename));
|
||
|
||
// 校验下载文件的 MD5
|
||
let expected_md5 = ctx_clone.current_download_md5.lock().unwrap().clone();
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
if let Some(expected) = expected_md5 {
|
||
let local_md5 = compute_file_md5(&final_path);
|
||
if let Some(lm) = local_md5 {
|
||
if &lm == &expected {
|
||
log_print!("{} [应用] {} MD5校验通过 ({}), 继续下一个文件", ts, filename, expected);
|
||
*ctx_clone.current_download_md5.lock().unwrap() = None;
|
||
send_next_download(&ctx_clone, &sender, &shutdown_tx_arc_clone);
|
||
} else {
|
||
log_print!("{} [应用] {} MD5校验失败 (本地={}, 期望={})，重新下载", ts, filename, lm, expected);
|
||
// 删除损坏文件，加入队列末尾重新下载
|
||
let _ = fs::remove_file(&final_path);
|
||
let mut queue = ctx_clone.download_queue.lock().unwrap();
|
||
queue.push_back((app_name.to_string(), filename.to_string(), 0, expected));
|
||
*ctx_clone.current_download_md5.lock().unwrap() = None;
|
||
drop(queue);
|
||
send_next_download(&ctx_clone, &sender, &shutdown_tx_arc_clone);
|
||
}
|
||
} else {
|
||
log_print!("{} [应用] {} 无法计算MD5，继续下一个文件", ts, filename);
|
||
*ctx_clone.current_download_md5.lock().unwrap() = None;
|
||
send_next_download(&ctx_clone, &sender, &shutdown_tx_arc_clone);
|
||
}
|
||
} else {
|
||
// 没有期望MD5（理论上不应发生），直接继续
|
||
send_next_download(&ctx_clone, &sender, &shutdown_tx_arc_clone);
|
||
}
|
||
break;
|
||
}
|
||
} else {
|
||
// ========== BootLoader/Updater 的 DownloadComplete 处理 ==========
|
||
let completed = handle_download_complete(&ctx_clone, data_obj, debug_msg);
|
||
if let Some(ref completed_file) = completed {
|
||
// BootLoader.exe 下载完成，推进到阶段2检查 Updater 版本
|
||
if completed_file == "BootLoader.exe" {
|
||
if !bootloader_downloaded_clone2.load(std::sync::atomic::Ordering::SeqCst) {
|
||
bootloader_downloaded_clone2.store(true, std::sync::atomic::Ordering::SeqCst);
|
||
if debug_msg {
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
log_print!("{} [升级] BootLoader.exe 下载完成，推进到阶段2检查 Updater...", ts);
|
||
}
|
||
// 推进到阶段2，由阶段2决定是否需要下载 Updater
|
||
*ctx_clone.current_phase.lock().unwrap() = UpdatePhase::Updater;
|
||
let msg = format!(
|
||
r#"{{"Type":"GetFileVer","Data":{{"DeviceNumber":"{}","file_list":["Updater.exe"]}}}}"#,
|
||
device_number
|
||
);
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
log_print!("{} 发送消息：{}", ts, msg);
|
||
sender.send(msg);
|
||
}
|
||
}
|
||
// Updater.new.exe 下载完成
|
||
else if completed_file == "Updater.new.exe" {
|
||
if !updater_downloaded_clone2.load(std::sync::atomic::Ordering::SeqCst) {
|
||
updater_downloaded_clone2.store(true, std::sync::atomic::Ordering::SeqCst);
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
log_print!("{} [升级] Updater.new.exe 下载完成（DownloadComplete），准备启动 BootLoader...", ts);
|
||
schedule_bootloader_launch(debug_msg, shutdown_tx_arc.clone());
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
});
|
||
|
||
// 设置断开连接回调
|
||
let debug_disconnect = debug_mode;
|
||
client.on_disconnected(move || {
|
||
if debug_disconnect {
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
println!("{} [断开] 连接已断开", ts);
|
||
}
|
||
});
|
||
|
||
// 设置错误回调
|
||
client.on_error(|error| {
|
||
log_eprintln!("[错误] WebSocket: {}", error);
|
||
});
|
||
|
||
// 设置首次连接回调
|
||
let debug_first = debug_mode;
|
||
let device_number_first = resolve_device_number();
|
||
client.on_first_connect(move |_url, _sender| {
|
||
let device_number = device_number_first.clone();
|
||
Box::pin(async move {
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
if device_number.is_empty() || device_number == "UNKNOWN" {
|
||
if debug_first {
|
||
println!("{} [连接] 已连接，未配置设备号，仅维持心跳", ts);
|
||
}
|
||
} else {
|
||
if debug_first {
|
||
println!("{} [连接] 已连接，等待服务器欢迎消息...", ts);
|
||
}
|
||
}
|
||
}) as Pin<Box<dyn std::future::Future<Output = ()> + Send + Sync>>
|
||
});
|
||
|
||
// 设置重连回调
|
||
let debug_reconnect = debug_mode;
|
||
client.on_reconnecting(move |attempt, url_arc| {
|
||
Box::pin(async move {
|
||
if debug_reconnect {
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
println!("{} [重连] 第 {} 次重连中...", ts, attempt);
|
||
}
|
||
let new_url = resolve_ws_url();
|
||
*url_arc.lock().await = new_url.clone();
|
||
if debug_reconnect {
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
println!("{} [重连] 配置已更新，服务器: {}", ts, new_url);
|
||
}
|
||
}) as Pin<Box<dyn std::future::Future<Output = ()> + Send + Sync>>
|
||
});
|
||
|
||
// 设置重连成功回调
|
||
let debug_reconnected = debug_mode;
|
||
let device_number_reconn = resolve_device_number();
|
||
client.on_reconnected(move |_url, _sender| {
|
||
let device_number = device_number_reconn.clone();
|
||
Box::pin(async move {
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
if device_number.is_empty() || device_number == "UNKNOWN" {
|
||
if debug_reconnected {
|
||
println!("{} [重连] 已重连，未配置设备号", ts);
|
||
}
|
||
} else {
|
||
if debug_reconnected {
|
||
println!("{} [重连] 已重连，等待服务器欢迎消息...", ts);
|
||
}
|
||
}
|
||
}) as Pin<Box<dyn std::future::Future<Output = ()> + Send + Sync>>
|
||
});
|
||
|
||
// 设置心跳确认回调
|
||
let debug_heartbeat = debug_mode;
|
||
client.on_heartbeat_ack(move |latency_ms, server_timestamp| {
|
||
if debug_heartbeat {
|
||
let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
|
||
println!("{} [心跳] pong响应延迟: {}ms, 服务端时间: {}", ts, latency_ms, server_timestamp);
|
||
}
|
||
});
|
||
|
||
// 连接（CubeLib 会自动处理重连）
|
||
if debug_mode {
|
||
println!("[启动] 开始连接...");
|
||
}
|
||
|
||
// 等待断连信号或连接正常结束
|
||
tokio::select! {
|
||
_ = &mut disconnect_rx => {
|
||
// 收到断连信号，主动断开
|
||
if debug_mode {
|
||
println!("[启动] 收到断连信号，主动断开...");
|
||
}
|
||
client.disconnect().await;
|
||
}
|
||
_ = client.connect() => {
|
||
// 连接正常结束（CubeLib 自动重连后的最终退出）
|
||
if debug_mode {
|
||
println!("[启动] 连接已结束");
|
||
}
|
||
}
|
||
}
|
||
|
||
if debug_mode {
|
||
println!("Updater 本次运行结束");
|
||
}
|
||
|
||
// 在退出前，通知所有升级的应用（发送升级确认消息）
|
||
let upgraded_apps = ctx.upgraded_apps.lock().unwrap().clone();
|
||
drop(ctx); // 释放 ctx 引用
|
||
if !upgraded_apps.is_empty() {
|
||
notify_all_app_upgrades(&upgraded_apps, debug_mode);
|
||
}
|
||
|
||
// 返回本次运行是否更新了 Updater.exe 自身（只有 Updater 自身更新了才需要退出重启）
|
||
updater_downloaded.load(std::sync::atomic::Ordering::SeqCst)
|
||
}
|
||
|
||
#[tokio::main]
|
||
async fn main() {
|
||
// 检查是否已有 Updater 进程在运行
|
||
if is_process_running("Updater.exe") {
|
||
return;
|
||
}
|
||
|
||
// 加载 Updater 自身配置（debug_mode）
|
||
let config = load_updater_config();
|
||
|
||
// 非 debug 模式下释放控制台，后台静默运行
|
||
if !config.debug_mode {
|
||
#[cfg(windows)]
|
||
{
|
||
use windows::Win32::System::Console;
|
||
use windows::Win32::Foundation::HWND;
|
||
unsafe {
|
||
let console = Console::GetConsoleWindow();
|
||
if console != HWND::default() {
|
||
let _ = Console::FreeConsole();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 启动命名管道服务端（长生命周期 async task）
|
||
let (pipe_tx, mut pipe_rx) = tokio::sync::mpsc::channel::<String>(64);
|
||
let _pipe_server_handle = start_named_pipe_server(pipe_tx, config.debug_mode);
|
||
|
||
// 主循环：常驻运行，定期检查更新
|
||
loop {
|
||
// 运行一次 Updater（连接、检查、下载）
|
||
let updater_updated = run_updater(config.debug_mode).await;
|
||
|
||
if updater_updated {
|
||
if config.debug_mode {
|
||
println!("Updater 自身已更新，即将退出（等待 BootLoader 重启）");
|
||
}
|
||
std::process::exit(0);
|
||
}
|
||
|
||
// 无更新 → 随机等待 5-10 分钟后再次检查
|
||
let wait_seconds = {
|
||
let mut rng = rand::thread_rng();
|
||
let minutes: f64 = rng.gen_range(5.0..=10.0);
|
||
(minutes * 60.0) as u64
|
||
};
|
||
|
||
// 打印等待信息（log_print! 会同时写入控制台和日志文件）
|
||
let wait_mins = wait_seconds as f64 / 60.0;
|
||
log_print!("Updater 本次检查完成，无更新，等待 {:.1} 分钟后再次检查...", wait_mins);
|
||
|
||
// 分段等待（每 30 秒为一个周期），期间可响应管道消息
|
||
let mut remaining = wait_seconds;
|
||
let interval_secs = 30;
|
||
while remaining > 0 {
|
||
let chunk = std::cmp::min(remaining, interval_secs);
|
||
let sleep = tokio::time::sleep(std::time::Duration::from_secs(chunk));
|
||
tokio::pin!(sleep);
|
||
|
||
tokio::select! {
|
||
_ = &mut sleep => {
|
||
remaining -= chunk;
|
||
}
|
||
// 收到管道消息（由 EasyTest 等客户端发送）
|
||
msg = pipe_rx.recv() => {
|
||
if let Some(m) = msg {
|
||
if config.debug_mode {
|
||
println!("[Pipe] 主循环收到消息：{}", m);
|
||
}
|
||
// quit 命令 → 退出
|
||
if m == "quit" {
|
||
if config.debug_mode {
|
||
println!("[Pipe] 收到 quit 命令，Updater 退出");
|
||
}
|
||
std::process::exit(0);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|