fix(webview): recover Windows WebView2 startup

This commit is contained in:
zipg authored and GitHub committed 2026-08-02 16:34:00 +08:00
1 parent b053adf175
commit 3af3dda9b5
6 files changed
+700 -160

No files matched your search

+42 -159
View File
@@ -4,15 +4,17 @@ mod db;
#[cfg(target_os = "macos")]
mod macos_app_delegate;
mod models;
#[cfg(any(target_os = "windows", test))]
mod startup_recovery;
#[cfg(all(not(target_os = "windows"), not(test)))]
#[path = "startup_recovery_noop.rs"]
mod startup_recovery;
mod window_state_guard;
use commands::connection::AppState;
use dbx_core::sql_dialect::dialect_loader::{register_core_dialects, DialectPluginLoader, DialectRegistry};
use dbx_core::sql_dialect::hot_reload::DialectHotReload;
use dbx_core::storage::{maybe_import_user_data_db, DesktopIconTheme, DesktopSettings, Storage};
use std::ffi::OsString;
use std::io::Write;
use std::path::PathBuf;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
use std::time::{Duration, Instant};
@@ -34,12 +36,6 @@ use tauri_plugin_deep_link::DeepLinkExt;
const DESKTOP_TRAY_ID: &str = "main-tray";
const APP_CLOSE_REQUESTED_EVENT: &str = "dbx-app-close-requested";
const STARTUP_PROBE_LOG_FILE: &str = "startup.log";
const STARTUP_PROBE_LOG_DIR_ENV: &str = "DBX_STARTUP_LOG_DIR";
const STARTUP_PROBE_KEEP_ENV: &str = "DBX_KEEP_STARTUP_LOG";
const WINDOWS_APP_DATA_DIR_NAME: &str = "com.dbx.app";
#[cfg(target_os = "windows")]
const WEBVIEW2_NO_SANDBOX_ENV: &str = "DBX_WEBVIEW2_NO_SANDBOX";
#[cfg(target_os = "macos")]
const APP_MENU_QUIT_ID: &str = "app-menu-quit";
#[cfg(target_os = "macos")]
@@ -123,6 +119,14 @@ fn should_enable_single_instance(debug_build: bool) -> bool {
!debug_build
}
fn startup_data_dir_mode(mode: &data_dir::DataDirMode) -> &'static str {
match mode {
data_dir::DataDirMode::Default => "default",
data_dir::DataDirMode::EnvOverride => "env_override",
data_dir::DataDirMode::Portable { .. } => "portable",
}
}
#[cfg(target_os = "macos")]
fn development_dock_badge_label(debug_build: bool) -> Option<&'static str> {
debug_build.then_some("DEV")
@@ -157,112 +161,14 @@ fn should_show_main_window_before_setup_tasks() -> bool {
true
}
fn startup_probe_log_dir_from_inputs(
target_os: &str,
explicit_dir: Option<OsString>,
windows_appdata: Option<OsString>,
) -> Option<PathBuf> {
if let Some(dir) = explicit_dir.filter(|value| !value.is_empty()) {
return Some(PathBuf::from(dir));
}
if target_os == "windows" {
return windows_appdata
.filter(|value| !value.is_empty())
.map(PathBuf::from)
.map(|dir| dir.join(WINDOWS_APP_DATA_DIR_NAME));
}
None
}
fn startup_probe_log_dir() -> Option<PathBuf> {
startup_probe_log_dir_from_inputs(
std::env::consts::OS,
std::env::var_os(STARTUP_PROBE_LOG_DIR_ENV),
std::env::var_os("APPDATA"),
)
}
fn startup_probe_log_path() -> Option<PathBuf> {
startup_probe_log_dir().map(|dir| dir.join(STARTUP_PROBE_LOG_FILE))
}
fn startup_probe_should_keep_after_frontend_ready_from_value(value: Option<&str>) -> bool {
matches!(value, Some("1"))
}
fn startup_probe_should_keep_after_frontend_ready() -> bool {
startup_probe_should_keep_after_frontend_ready_from_value(std::env::var(STARTUP_PROBE_KEEP_ENV).ok().as_deref())
}
fn ensure_startup_probe_parent_dir(path: &std::path::Path) -> bool {
let Some(dir) = path.parent() else {
return false;
};
if std::fs::create_dir_all(dir).is_err() {
return false;
}
true
}
fn reset_startup_probe() {
let Some(path) = startup_probe_log_path() else {
return;
};
if !ensure_startup_probe_parent_dir(&path) {
return;
}
let _ = std::fs::remove_file(path);
}
fn append_startup_probe(message: impl AsRef<str>) {
let Some(path) = startup_probe_log_path() else {
return;
};
if !ensure_startup_probe_parent_dir(&path) {
return;
}
let Ok(mut file) = std::fs::OpenOptions::new().create(true).append(true).open(path) else {
return;
};
let _ = writeln!(
file,
"[{}][pid={}] {}",
chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f"),
std::process::id(),
message.as_ref()
);
startup_recovery::record(message);
}
pub(crate) fn clear_startup_probe_after_frontend_ready() {
if startup_probe_should_keep_after_frontend_ready() {
append_startup_probe("frontend ready; keeping startup probe by request");
return;
}
let Some(path) = startup_probe_log_path() else {
return;
};
let _ = std::fs::remove_file(path);
startup_recovery::mark_frontend_ready();
}
#[cfg(target_os = "windows")]
fn configure_webview2_sandbox_compat() {
if !matches!(std::env::var(WEBVIEW2_NO_SANDBOX_ENV).as_deref(), Ok("1")) {
return;
}
let mut args = std::env::var("WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS").unwrap_or_default();
if !args.split_whitespace().any(|arg| arg == "--no-sandbox") {
if !args.is_empty() {
args.push(' ');
}
args.push_str("--no-sandbox");
}
std::env::set_var("WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS", args);
}
#[cfg(not(target_os = "windows"))]
fn configure_webview2_sandbox_compat() {}
fn should_confirm_app_exit_request(target_os: &str, exit_code: Option<i32>, confirmed_exit: bool) -> bool {
should_hide_window_on_close(target_os) && exit_code != Some(tauri::RESTART_EXIT_CODE) && !confirmed_exit
}
@@ -928,11 +834,11 @@ mod tests {
linux_webkit_rendering_workarounds, native_window_decorations_override, should_confirm_app_exit_request,
should_enable_single_instance, should_fallback_to_native_quit, should_hide_window_on_close,
should_setup_desktop_tray, should_show_main_window_after_setup, should_show_main_window_before_setup_tasks,
startup_probe_log_dir_from_inputs, startup_probe_should_keep_after_frontend_ready_from_value,
tray_menu_labels_for_locale, uses_application_level_icon, LinuxDrmRenderDevice, LinuxNvidiaDriver,
WINDOWS_APP_DATA_DIR_NAME,
startup_data_dir_mode, tray_menu_labels_for_locale, uses_application_level_icon, LinuxDrmRenderDevice,
LinuxNvidiaDriver,
};
use std::ffi::{OsStr, OsString};
use crate::data_dir::DataDirMode;
use std::ffi::OsStr;
use std::path::{Path, PathBuf};
const TEST_GTK3_IMMODULES_CACHE: &str = "/usr/lib/test/gtk-3.0/3.0.0/immodules.cache";
@@ -999,6 +905,16 @@ mod tests {
assert!(should_enable_single_instance(false));
}
#[test]
fn startup_data_dir_diagnostics_never_include_paths() {
let private_path = PathBuf::from(r"C:\Users\private-user\DBXData");
assert_eq!(startup_data_dir_mode(&DataDirMode::Default), "default");
assert_eq!(startup_data_dir_mode(&DataDirMode::EnvOverride), "env_override");
let label = startup_data_dir_mode(&DataDirMode::Portable { exe_dir: private_path });
assert_eq!(label, "portable");
assert!(!label.contains("private-user"));
}
#[cfg(target_os = "macos")]
#[test]
fn labels_debug_builds_in_the_macos_dock() {
@@ -1047,40 +963,6 @@ mod tests {
assert!(should_show_main_window_before_setup_tasks());
}
#[test]
fn startup_probe_log_dir_prefers_explicit_override() {
assert_eq!(
startup_probe_log_dir_from_inputs(
"windows",
Some(OsString::from(r"D:\DBXDiagnostics")),
Some(OsString::from(r"C:\Users\test\AppData\Roaming")),
),
Some(PathBuf::from(r"D:\DBXDiagnostics"))
);
}
#[test]
fn startup_probe_log_dir_uses_windows_appdata() {
assert_eq!(
startup_probe_log_dir_from_inputs("windows", None, Some(OsString::from(r"C:\Users\test\AppData\Roaming")),),
Some(PathBuf::from(r"C:\Users\test\AppData\Roaming").join(WINDOWS_APP_DATA_DIR_NAME))
);
}
#[test]
fn startup_probe_log_dir_is_disabled_without_windows_appdata() {
assert_eq!(startup_probe_log_dir_from_inputs("windows", None, None), None);
assert_eq!(startup_probe_log_dir_from_inputs("macos", None, Some(OsString::from("/Users/test/Library"))), None);
}
#[test]
fn startup_probe_log_is_kept_only_when_requested() {
assert!(startup_probe_should_keep_after_frontend_ready_from_value(Some("1")));
assert!(!startup_probe_should_keep_after_frontend_ready_from_value(None));
assert!(!startup_probe_should_keep_after_frontend_ready_from_value(Some("true")));
assert!(!startup_probe_should_keep_after_frontend_ready_from_value(Some("0")));
}
#[test]
fn only_user_requested_app_exit_needs_frontend_confirmation() {
assert!(should_confirm_app_exit_request("windows", None, false));
@@ -1279,16 +1161,8 @@ mod tests {
#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
reset_startup_probe();
append_startup_probe(format!(
"process start version={} os={} arch={} exe={:?}",
env!("CARGO_PKG_VERSION"),
std::env::consts::OS,
std::env::consts::ARCH,
std::env::current_exe()
));
startup_recovery::initialize();
rustls::crypto::aws_lc_rs::default_provider().install_default().expect("Failed to install rustls crypto provider");
configure_webview2_sandbox_compat();
append_startup_probe("runtime prerequisites configured");
#[cfg(target_os = "linux")]
apply_linux_webkit_rendering_workarounds();
@@ -1380,7 +1254,8 @@ pub fn run() {
let data_dir_resolution = data_dir::resolve_data_dir_with_mode(default_data_dir);
let data_dir = data_dir_resolution.data_dir.clone();
std::fs::create_dir_all(&data_dir).expect("Failed to create data dir");
append_startup_probe(format!("data dir ready: {}", data_dir.display()));
let data_dir_mode = startup_data_dir_mode(&data_dir_resolution.mode);
append_startup_probe(format!("data dir ready mode={data_dir_mode}"));
let alternative_data_dir = data_dir::alternative_data_dir(&data_dir_resolution);
match maybe_import_user_data_db(&data_dir, alternative_data_dir.as_deref()) {
Ok(result) => eprintln!("[STARTUP] data db fallback import: {result:?}"),
@@ -1389,7 +1264,7 @@ pub fn run() {
let db_path = data_dir.join("dbx.db");
let t = Instant::now();
append_startup_probe(format!("opening storage: {}", db_path.display()));
append_startup_probe(format!("opening storage file=dbx.db data_dir_mode={data_dir_mode}"));
let storage = tauri::async_runtime::block_on(async {
let s = Storage::open(&db_path).await.expect("Failed to open storage");
eprintln!("[STARTUP] Storage::open in {:?}", t.elapsed());
@@ -2107,8 +1982,16 @@ pub fn run() {
commands::tunnel_profiles::test_tunnel_profile,
])
.build(tauri::generate_context!())
.expect("error while building tauri application")
.inspect(|app| {
append_startup_probe(format!("tauri application built after {:?}", startup_begin.elapsed()));
startup_recovery::start_watchdog(app.handle());
})
.unwrap_or_else(|error| {
append_startup_probe(format!("tauri application build failed: {error}"));
panic!("error while building tauri application: {error}");
})
.run(|app_handle, event| {
startup_recovery::record_run_event();
#[cfg(not(target_os = "macos"))]
let _ = (&app_handle, &event);