Stabilize daemon lifecycle and edge build versioning

Author: fjh1997

.github/workflows/build-release.yml

@@ -56,6 +56,8 @@ jobs:
           else
             python ./scripts/ci-sync-version.py
           fi
+          echo "RELEASE_VERSION=${{ github.event.inputs.release_tag || github.ref_name }}" | sed 's/^RELEASE_VERSION=v/RELEASE_VERSION=/' >> "${GITHUB_ENV}"
+          echo "LINUXDO_BUILD_VERSION=${{ github.event.inputs.release_tag || github.ref_name }}" | sed 's/^LINUXDO_BUILD_VERSION=v/LINUXDO_BUILD_VERSION=/' >> "${GITHUB_ENV}"
 
       - uses: dtolnay/rust-toolchain@stable
 
@@ -144,6 +146,8 @@ jobs:
           else
             python ./scripts/ci-sync-version.py
           fi
+          echo "RELEASE_VERSION=${{ github.event.inputs.release_tag || github.ref_name }}" | sed 's/^RELEASE_VERSION=v/RELEASE_VERSION=/' >> "${GITHUB_ENV}"
+          echo "LINUXDO_BUILD_VERSION=${{ github.event.inputs.release_tag || github.ref_name }}" | sed 's/^LINUXDO_BUILD_VERSION=v/LINUXDO_BUILD_VERSION=/' >> "${GITHUB_ENV}"
 
       - uses: actions/setup-java@v4
         with:

.github/workflows/publish-edge-pre-release.yml

@@ -70,6 +70,8 @@ jobs:
           RELEASE_VERSION="${base_version}-edge.${GITHUB_RUN_NUMBER}" \
           ANDROID_VERSION_SERIAL="${build_serial}" \
           "$PYTHON_BIN" ./scripts/ci-sync-version.py
+          echo "RELEASE_VERSION=${base_version}-edge.${GITHUB_RUN_NUMBER}" >> "${GITHUB_ENV}"
+          echo "LINUXDO_BUILD_VERSION=${base_version}-edge.${GITHUB_RUN_NUMBER}" >> "${GITHUB_ENV}"
 
       - uses: dtolnay/rust-toolchain@stable
 
@@ -170,6 +172,8 @@ jobs:
           RELEASE_VERSION="${base_version}-edge.${GITHUB_RUN_NUMBER}" \
           ANDROID_VERSION_SERIAL="${build_serial}" \
           "$PYTHON_BIN" ./scripts/ci-sync-version.py
+          echo "RELEASE_VERSION=${base_version}-edge.${GITHUB_RUN_NUMBER}" >> "${GITHUB_ENV}"
+          echo "LINUXDO_BUILD_VERSION=${base_version}-edge.${GITHUB_RUN_NUMBER}" >> "${GITHUB_ENV}"
 
       - uses: actions/setup-java@v4
         with:

build.rs

@@ -1,5 +1,23 @@
 fn main() {
     println!("cargo:rerun-if-changed=assets/icons/linuxdo.ico");
+    println!("cargo:rerun-if-env-changed=LINUXDO_BUILD_VERSION");
+    println!("cargo:rerun-if-env-changed=RELEASE_VERSION");
+
+    let build_version = std::env::var("LINUXDO_BUILD_VERSION")
+        .ok()
+        .filter(|value| !value.trim().is_empty())
+        .or_else(|| {
+            std::env::var("RELEASE_VERSION")
+                .ok()
+                .filter(|value| !value.trim().is_empty())
+        })
+        .or_else(|| {
+            std::env::var("CARGO_PKG_VERSION")
+                .ok()
+                .filter(|value| !value.trim().is_empty())
+        })
+        .unwrap_or_else(|| "0.0.0".to_string());
+    println!("cargo:rustc-env=LINUXDO_BUILD_VERSION={build_version}");
 
     if std::env::var("CARGO_CFG_TARGET_OS").as_deref() == Ok("windows") {
         let mut res = winresource::WindowsResource::new();

src/gui.rs

@@ -35,7 +35,10 @@ use crate::state::{self, ServiceState};
 
 const APP_WINDOW_TITLE: &str = "Linux.do Accelerator";
 const APP_ID: &str = "linuxdo-accelerator";
-const APP_VERSION: &str = env!("CARGO_PKG_VERSION");
+const APP_VERSION: &str = match option_env!("LINUXDO_BUILD_VERSION") {
+    Some(version) => version,
+    None => env!("CARGO_PKG_VERSION"),
+};
 const ACTIVE_REPAINT_INTERVAL: Duration = Duration::from_millis(100);
 const IDLE_REPAINT_INTERVAL: Duration = Duration::from_secs(5);
 const TRAY_REPAINT_INTERVAL: Duration = Duration::from_secs(15);
@@ -1624,7 +1627,6 @@ impl AcceleratorApp {
         }
     }
 
-
     #[cfg(target_os = "windows")]
     fn restore_from_tray(&mut self, ctx: &egui::Context) {
         self.hidden_to_tray = false;
@@ -2719,7 +2721,7 @@ fn schedule_windows_shortcut_icon_refresh(config_path: &Path) {
             .with_context(|| format!("failed to create {}", paths.runtime_dir.display()))?;
 
         let stamp_path = paths.runtime_dir.join("windows-shortcut-icon-sync.txt");
-        let stamp = format!("{}\n{}", env!("CARGO_PKG_VERSION"), current_exe.display());
+        let stamp = format!("{}\n{}", APP_VERSION, current_exe.display());
         if std::fs::read_to_string(&stamp_path).ok().as_deref() == Some(stamp.as_str()) {
             return Ok(());
         }

src/proxy.rs

@@ -155,7 +155,10 @@ pub async fn run_proxy(
     Ok(())
 }
 
-async fn run_http_redirect(state: Arc<AppState>, mut shutdown_rx: watch::Receiver<bool>) -> Result<()> {
+async fn run_http_redirect(
+    state: Arc<AppState>,
+    mut shutdown_rx: watch::Receiver<bool>,
+) -> Result<()> {
     let address = format!("{}:{}", state.config.listen_host, state.config.http_port);
     let listener = TcpListener::bind(&address)
         .await
@@ -398,7 +401,11 @@ async fn dispatch_upstream_request(
             path_and_query,
             &format!(
                 "attempt addr={addr} scheme={upstream_scheme} ech={} edge_node={}",
-                if upstream.ech_config.is_some() { "yes" } else { "no" },
+                if upstream.ech_config.is_some() {
+                    "yes"
+                } else {
+                    "no"
+                },
                 state
                     .config
                     .edge_node_override()
@@ -633,7 +640,11 @@ async fn resolve_upstream(state: &AppState, host: &str, port: u16) -> Result<Res
             &format!(
                 "resolve cache-hit addrs={} ech={}",
                 format_socket_addrs(&cached.addrs),
-                if cached.ech_config.is_some() { "yes" } else { "no" }
+                if cached.ech_config.is_some() {
+                    "yes"
+                } else {
+                    "no"
+                }
             ),
         );
         return Ok(cached);
@@ -689,8 +700,7 @@ async fn resolve_upstream(state: &AppState, host: &str, port: u16) -> Result<Res
         }
         Ok((Vec::new(), None))
     };
-    let ((mut ips, addr_ttl), (extra_ips, extra_ttl)) = if let Some(edge_override) = edge_override
-    {
+    let ((mut ips, addr_ttl), (extra_ips, extra_ttl)) = if let Some(edge_override) = edge_override {
         let override_lookup = async {
             match edge_override {
                 DnsHostOverride::Addresses(ips) => Ok((ips, None)),
@@ -743,7 +753,11 @@ async fn resolve_upstream(state: &AppState, host: &str, port: u16) -> Result<Res
         &format!(
             "resolve binding_host={binding_host} target_host={target_host} addrs={} ech={} edge_node={}",
             format_socket_addrs(&upstream.addrs),
-            if upstream.ech_config.is_some() { "yes" } else { "no" },
+            if upstream.ech_config.is_some() {
+                "yes"
+            } else {
+                "no"
+            },
             state
                 .config
                 .edge_node_override()
@@ -1281,16 +1295,16 @@ fn extract_host(headers: &HeaderMap, uri: &http::Uri, config: &AppConfig) -> Opt
     uri.authority()
         .map(|authority| authority.host().to_ascii_lowercase())
         .or_else(|| {
-    headers
-        .get(HOST)
-        .and_then(|value| value.to_str().ok())
-        .map(|value| {
-            value
-                .split(':')
-                .next()
-                .unwrap_or(value)
-                .to_ascii_lowercase()
-        })
+            headers
+                .get(HOST)
+                .and_then(|value| value.to_str().ok())
+                .map(|value| {
+                    value
+                        .split(':')
+                        .next()
+                        .unwrap_or(value)
+                        .to_ascii_lowercase()
+                })
         })
         .or_else(|| config.proxy_domains.first().cloned())
 }

src/service.rs

@@ -1,5 +1,6 @@
 use std::net::{TcpStream, ToSocketAddrs};
 use std::path::PathBuf;
+#[cfg(target_family = "unix")]
 use std::process::Command;
 use std::sync::Arc;
 use std::sync::atomic::{AtomicBool, Ordering};
@@ -105,11 +106,7 @@ pub async fn run_foreground(config_path: Option<PathBuf>, with_setup: bool) -> R
     state::mark_running(&paths, pid)?;
     let ui_managed_shutdown = Arc::new(AtomicBool::new(false));
     let (shutdown_tx, shutdown_rx) = watch::channel(false);
-    let watchdog = spawn_ui_lease_watchdog(
-        paths.clone(),
-        ui_managed_shutdown.clone(),
-        shutdown_tx,
-    );
+    let watchdog = spawn_ui_lease_watchdog(paths.clone(), ui_managed_shutdown.clone(), shutdown_tx);
     let result = run_proxy(config.clone(), paths.clone(), bundle, shutdown_rx).await;
     watchdog.abort();
     let _ = state::clear_pid_if_matches(&paths, pid);
@@ -193,9 +190,7 @@ pub fn helper_start(config_path: Option<PathBuf>) -> Result<()> {
                 log_warn(
                     &paths,
                     "helper-start",
-                    &format!(
-                        "启动流程报告异常，但检测到现有服务仍在运行，已修复状态：{error:#}"
-                    ),
+                    &format!("启动流程报告异常，但检测到现有服务仍在运行，已修复状态：{error:#}"),
                 );
                 return Ok(());
             }
@@ -466,6 +461,7 @@ fn wait_until_running(paths: &AppPaths, config: &AppConfig, timeout: Duration) -
     bail!("daemon start timed out")
 }
 
+#[cfg_attr(not(target_family = "unix"), allow(unused_variables))]
 fn discover_running_daemon_pid(paths: &AppPaths) -> Option<u32> {
     #[cfg(target_family = "unix")]
     {
@@ -727,8 +723,18 @@ fn spawn_ui_lease_watchdog(
     shutdown_tx: watch::Sender<bool>,
 ) -> tokio::task::JoinHandle<()> {
     tokio::spawn(async move {
-        if state::read_ui_lease(&paths).ok().flatten().is_none() {
-            return;
+        match state::read_ui_lease(&paths) {
+            Ok(Some(_)) => {}
+            Ok(None) => return,
+            Err(error) => {
+                let _ = runtime_log::append(
+                    &paths,
+                    "WARN",
+                    "ui-watchdog",
+                    &format!("failed to read initial ui lease state: {error:#}"),
+                );
+                return;
+            }
         }
         let stale_after = Duration::from_secs(8);
         let mut missing_since: Option<u64> = None;
@@ -739,31 +745,43 @@ fn spawn_ui_lease_watchdog(
                 .duration_since(UNIX_EPOCH)
                 .map(|duration| duration.as_secs())
                 .unwrap_or(0);
-            let Some(lease) = state::read_ui_lease(&paths).ok().flatten() else {
-                let first_missing_at = *missing_since.get_or_insert(now);
-                let missing_for = now.saturating_sub(first_missing_at);
-                if missing_for < stale_after.as_secs() {
+            let lease = match state::read_ui_lease(&paths) {
+                Ok(Some(lease)) => lease,
+                Ok(None) => {
+                    let first_missing_at = *missing_since.get_or_insert(now);
+                    let missing_for = now.saturating_sub(first_missing_at);
+                    if missing_for < stale_after.as_secs() {
+                        continue;
+                    }
+                    ui_managed_shutdown.store(true, Ordering::SeqCst);
+                    let _ = runtime_log::append(
+                        &paths,
+                        "WARN",
+                        "ui-watchdog",
+                        &format!(
+                            "ui lease missing for {}s while daemon is ui-managed; requesting shutdown",
+                            missing_for
+                        ),
+                    );
+                    let _ = shutdown_tx.send(true);
+                    break;
+                }
+                Err(error) => {
+                    let _ = runtime_log::append(
+                        &paths,
+                        "WARN",
+                        "ui-watchdog",
+                        &format!("failed to read ui lease state, keeping daemon alive: {error:#}"),
+                    );
                     continue;
                 }
-                ui_managed_shutdown.store(true, Ordering::SeqCst);
-                let _ = runtime_log::append(
-                    &paths,
-                    "WARN",
-                    "ui-watchdog",
-                    &format!(
-                        "ui lease missing for {}s while daemon is ui-managed; requesting shutdown",
-                        missing_for
-                    ),
-                );
-                let _ = shutdown_tx.send(true);
-                break;
             };
             missing_since = None;
 
             let now = now.max(lease.updated_at);
             let stale = now.saturating_sub(lease.updated_at) >= stale_after.as_secs();
-            let owner_dead = !is_process_running(lease.owner_pid);
-            if stale || owner_dead {
+            if stale {
+                let owner_dead = !is_process_running(lease.owner_pid);
                 ui_managed_shutdown.store(true, Ordering::SeqCst);
                 let _ = runtime_log::append(
                     &paths,

src/state.rs

@@ -234,7 +234,11 @@ fn replace_file(path: &Path, content: &[u8]) -> Result<()> {
         .with_context(|| format!("failed to write {}", tmp_path.display()))?;
 
     move_file_replace(&tmp_path, path).with_context(|| {
-        format!("failed to move {} to {}", tmp_path.display(), path.display())
+        format!(
+            "failed to move {} to {}",
+            tmp_path.display(),
+            path.display()
+        )
     })?;
     Ok(())
 }
@@ -243,7 +247,13 @@ fn replace_file(path: &Path, content: &[u8]) -> Result<()> {
 fn move_file_replace(src: &Path, dst: &Path) -> Result<()> {
     let src_wide: Vec<u16> = src.as_os_str().encode_wide().chain(Some(0)).collect();
     let dst_wide: Vec<u16> = dst.as_os_str().encode_wide().chain(Some(0)).collect();
-    let ok = unsafe { MoveFileExW(src_wide.as_ptr(), dst_wide.as_ptr(), MOVEFILE_REPLACE_EXISTING) };
+    let ok = unsafe {
+        MoveFileExW(
+            src_wide.as_ptr(),
+            dst_wide.as_ptr(),
+            MOVEFILE_REPLACE_EXISTING,
+        )
+    };
     if ok == 0 {
         return Err(std::io::Error::last_os_error()).context("MoveFileExW failed");
     }