mirror of
https://github.com/clash-verge-rev/clash-verge-rev.git
synced 2026-11-19 02:12:10 +08:00
fix(service): avoid sticky availability probes
This commit is contained in:
@@ -42,11 +42,6 @@ pub async fn repair_service() -> CmdResult {
|
|||||||
execute_service_operation_sync(ServiceStatus::ForceReinstallRequired, "SERVICE_REPAIR_FAILED").await
|
execute_service_operation_sync(ServiceStatus::ForceReinstallRequired, "SERVICE_REPAIR_FAILED").await
|
||||||
}
|
}
|
||||||
|
|
||||||
#[tauri::command]
|
|
||||||
pub async fn is_service_available() -> CmdResult<bool> {
|
|
||||||
Ok(service::is_service_available().await)
|
|
||||||
}
|
|
||||||
|
|
||||||
#[tauri::command]
|
#[tauri::command]
|
||||||
pub async fn get_service_install_state() -> CmdResult<service::ServiceInstallState> {
|
pub async fn get_service_install_state() -> CmdResult<service::ServiceInstallState> {
|
||||||
Ok(SERVICE_MANAGER.install_state().await)
|
Ok(SERVICE_MANAGER.install_state().await)
|
||||||
|
|||||||
@@ -179,7 +179,7 @@ impl Logger {
|
|||||||
*self.sidecar_file_writer.write() = Some(sidecar_writer);
|
*self.sidecar_file_writer.write() = Some(sidecar_writer);
|
||||||
|
|
||||||
// update service writer config
|
// update service writer config
|
||||||
if service::is_service_available().await {
|
if service::SERVICE_MANAGER.is_ready_cached() {
|
||||||
service::update_writer_by_service(&clash_verge_service_ipc::WriterConfig {
|
service::update_writer_by_service(&clash_verge_service_ipc::WriterConfig {
|
||||||
directory: String::new(),
|
directory: String::new(),
|
||||||
max_log_size: log_max_size * 1024,
|
max_log_size: log_max_size * 1024,
|
||||||
|
|||||||
@@ -567,7 +567,7 @@ impl CoreManager {
|
|||||||
|
|
||||||
#[cfg(target_os = "windows")]
|
#[cfg(target_os = "windows")]
|
||||||
async fn wait_for_service_if_needed(&self) {
|
async fn wait_for_service_if_needed(&self) {
|
||||||
use crate::{config::Config, constants::timing, core::service};
|
use crate::{config::Config, constants::timing};
|
||||||
use backon::{ConstantBuilder, Retryable as _};
|
use backon::{ConstantBuilder, Retryable as _};
|
||||||
|
|
||||||
let tun_enabled = Config::verge().await.latest_arc().enable_tun_mode.unwrap_or(false);
|
let tun_enabled = Config::verge().await.latest_arc().enable_tun_mode.unwrap_or(false);
|
||||||
@@ -590,28 +590,17 @@ impl CoreManager {
|
|||||||
.with_delay(timing::SERVICE_WAIT_INTERVAL)
|
.with_delay(timing::SERVICE_WAIT_INTERVAL)
|
||||||
.with_max_times(max_times as usize);
|
.with_max_times(max_times as usize);
|
||||||
|
|
||||||
let _ = (|| async {
|
let wait_for_ready = (|| async {
|
||||||
if matches!(SERVICE_MANAGER.current().await, ServiceStatus::Ready) {
|
if SERVICE_MANAGER.is_ready_cached() {
|
||||||
return Ok(());
|
return Ok(());
|
||||||
}
|
}
|
||||||
|
|
||||||
// If the service IPC path is not ready yet, treat it as transient and retry.
|
// Probe the service directly. A transient transport failure does not overwrite
|
||||||
// Running init/refresh too early can mark service state unavailable and break later config reloads.
|
// the last confirmed install state and is retried within the startup deadline.
|
||||||
if !service::is_service_ipc_path_exists() {
|
SERVICE_MANAGER.confirm_ready().await
|
||||||
return Err(anyhow::anyhow!("Service IPC not ready"));
|
|
||||||
}
|
|
||||||
|
|
||||||
SERVICE_MANAGER.init().await?;
|
|
||||||
let _ = SERVICE_MANAGER.refresh().await;
|
|
||||||
|
|
||||||
if matches!(SERVICE_MANAGER.current().await, ServiceStatus::Ready) {
|
|
||||||
Ok(())
|
|
||||||
} else {
|
|
||||||
Err(anyhow::anyhow!("Service not ready"))
|
|
||||||
}
|
|
||||||
})
|
})
|
||||||
.retry(backoff)
|
.retry(backoff);
|
||||||
.await;
|
let _ = tokio::time::timeout(timing::SERVICE_WAIT_MAX, wait_for_ready).await;
|
||||||
}
|
}
|
||||||
|
|
||||||
/// 在窗口内等待服务就绪,再从 sidecar 交接到 service
|
/// 在窗口内等待服务就绪,再从 sidecar 交接到 service
|
||||||
@@ -675,17 +664,11 @@ impl CoreManager {
|
|||||||
|
|
||||||
#[cfg(target_os = "windows")]
|
#[cfg(target_os = "windows")]
|
||||||
async fn refresh_service_readiness_for_handoff() -> bool {
|
async fn refresh_service_readiness_for_handoff() -> bool {
|
||||||
use crate::core::service;
|
|
||||||
|
|
||||||
// 主动刷新服务状态,避免缓存状态阻止交接
|
// 主动刷新服务状态,避免缓存状态阻止交接
|
||||||
if !service::is_service_ipc_path_exists() {
|
if SERVICE_MANAGER.confirm_ready().await.is_err() {
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
if SERVICE_MANAGER.init().await.is_err() {
|
SERVICE_MANAGER.is_ready_cached()
|
||||||
return false;
|
|
||||||
}
|
|
||||||
let _ = SERVICE_MANAGER.refresh().await;
|
|
||||||
matches!(SERVICE_MANAGER.current().await, ServiceStatus::Ready)
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/// 服务就绪后停止 sidecar,再以 service 重启内核
|
/// 服务就绪后停止 sidecar,再以 service 重启内核
|
||||||
|
|||||||
+49
-142
@@ -114,10 +114,6 @@ const fn classify_service_install_state(current: CurrentServiceProbe, has_instal
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn confirmed_service_available<E>(result: std::result::Result<bool, E>) -> bool {
|
|
||||||
matches!(result, Ok(true))
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||||
struct ServiceVersionReply {
|
struct ServiceVersionReply {
|
||||||
code: u16,
|
code: u16,
|
||||||
@@ -166,10 +162,6 @@ fn classify_service_version_reply(reply: &ServiceVersionReply) -> ServiceVersion
|
|||||||
}
|
}
|
||||||
|
|
||||||
async fn probe_service_version_once() -> Result<ServiceVersionReply> {
|
async fn probe_service_version_once() -> Result<ServiceVersionReply> {
|
||||||
if !is_service_ipc_path_exists() {
|
|
||||||
bail!("service IPC path is not available");
|
|
||||||
}
|
|
||||||
|
|
||||||
let response = clash_verge_service_ipc::get_version().await?;
|
let response = clash_verge_service_ipc::get_version().await?;
|
||||||
Ok(ServiceVersionReply {
|
Ok(ServiceVersionReply {
|
||||||
code: response.code,
|
code: response.code,
|
||||||
@@ -312,21 +304,6 @@ fn trusted_service_evidence() -> Result<bool> {
|
|||||||
}
|
}
|
||||||
|
|
||||||
async fn detect_service_install_state() -> ServiceInstallState {
|
async fn detect_service_install_state() -> ServiceInstallState {
|
||||||
let current = if is_service_ipc_path_exists() {
|
|
||||||
match probe_service_version_once().await {
|
|
||||||
Ok(reply) if classify_service_version_reply(&reply) == ServiceVersionCheck::Ready => {
|
|
||||||
CurrentServiceProbe::Ready
|
|
||||||
}
|
|
||||||
Ok(_) => CurrentServiceProbe::VersionMismatch,
|
|
||||||
Err(error) => {
|
|
||||||
logging!(warn, Type::Service, "current service IPC is unavailable: {error:#}");
|
|
||||||
CurrentServiceProbe::Unavailable
|
|
||||||
}
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
CurrentServiceProbe::Missing
|
|
||||||
};
|
|
||||||
|
|
||||||
let markers = match trusted_service_evidence() {
|
let markers = match trusted_service_evidence() {
|
||||||
Ok(exists) => exists,
|
Ok(exists) => exists,
|
||||||
Err(error) => {
|
Err(error) => {
|
||||||
@@ -338,6 +315,20 @@ async fn detect_service_install_state() -> ServiceInstallState {
|
|||||||
return ServiceInstallState::Unavailable;
|
return ServiceInstallState::Unavailable;
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
|
if !markers {
|
||||||
|
return classify_service_install_state(CurrentServiceProbe::Missing, false);
|
||||||
|
}
|
||||||
|
|
||||||
|
let current = match probe_service_version_once().await {
|
||||||
|
Ok(reply) if classify_service_version_reply(&reply) == ServiceVersionCheck::Ready => CurrentServiceProbe::Ready,
|
||||||
|
Ok(_) => CurrentServiceProbe::VersionMismatch,
|
||||||
|
Err(error) => {
|
||||||
|
logging!(warn, Type::Service, "current service IPC is unavailable: {error:#}");
|
||||||
|
CurrentServiceProbe::Unavailable
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
classify_service_install_state(current, markers)
|
classify_service_install_state(current, markers)
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -1405,64 +1396,6 @@ async fn recover_after_owner_loss_while_locked(reason: OwnerRecoveryReason) {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
async fn probe_service_availability() -> Result<bool> {
|
|
||||||
probe_service_availability_with(&SERVICE_MANAGER, true, probe_service_version_once).await
|
|
||||||
}
|
|
||||||
|
|
||||||
async fn probe_service_availability_with<F, Fut>(
|
|
||||||
manager: &ServiceManager,
|
|
||||||
require_cached_ready: bool,
|
|
||||||
probe: F,
|
|
||||||
) -> Result<bool>
|
|
||||||
where
|
|
||||||
F: FnOnce() -> Fut,
|
|
||||||
Fut: Future<Output = Result<ServiceVersionReply>>,
|
|
||||||
{
|
|
||||||
let captured_generation = {
|
|
||||||
let status = manager.status.lock();
|
|
||||||
if manager.operation_running.load(Ordering::Acquire) {
|
|
||||||
return Ok(false);
|
|
||||||
}
|
|
||||||
if require_cached_ready && !matches!(*status, ServiceStatus::Ready) {
|
|
||||||
return Ok(false);
|
|
||||||
}
|
|
||||||
let generation = manager.status_generation.load(Ordering::Acquire);
|
|
||||||
drop(status);
|
|
||||||
generation
|
|
||||||
};
|
|
||||||
|
|
||||||
let result = probe().await;
|
|
||||||
let mut status = manager.status.lock();
|
|
||||||
if manager.operation_running.load(Ordering::Acquire)
|
|
||||||
|| manager.status_generation.load(Ordering::Acquire) != captured_generation
|
|
||||||
{
|
|
||||||
return Ok(false);
|
|
||||||
}
|
|
||||||
|
|
||||||
manager.status_generation.fetch_add(1, Ordering::AcqRel);
|
|
||||||
match result {
|
|
||||||
Ok(reply) => match classify_service_version_reply(&reply) {
|
|
||||||
ServiceVersionCheck::Ready => {
|
|
||||||
*status = ServiceStatus::Ready;
|
|
||||||
Ok(true)
|
|
||||||
}
|
|
||||||
ServiceVersionCheck::NeedsReinstall(error) => {
|
|
||||||
*status = ServiceStatus::NeedsReinstall;
|
|
||||||
Err(anyhow::anyhow!(error))
|
|
||||||
}
|
|
||||||
},
|
|
||||||
Err(error) => {
|
|
||||||
*status = ServiceStatus::Unavailable(format!("service availability probe failed: {error:#}"));
|
|
||||||
Err(error).context("service availability probe failed")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns true only when the service probe explicitly confirms availability.
|
|
||||||
pub async fn is_service_available() -> bool {
|
|
||||||
confirmed_service_available(probe_service_availability().await)
|
|
||||||
}
|
|
||||||
|
|
||||||
async fn wait_for_service_ipc(manager: &ServiceManager) -> Result<()> {
|
async fn wait_for_service_ipc(manager: &ServiceManager) -> Result<()> {
|
||||||
let config = ServiceManager::config();
|
let config = ServiceManager::config();
|
||||||
let result = poll_service_version(config.max_retries, config.retry_delay, probe_service_version_once).await;
|
let result = poll_service_version(config.max_retries, config.retry_delay, probe_service_version_once).await;
|
||||||
@@ -1470,10 +1403,6 @@ async fn wait_for_service_ipc(manager: &ServiceManager) -> Result<()> {
|
|||||||
apply_service_version_result(manager, result, "service IPC did not become available")
|
apply_service_version_result(manager, result, "service IPC did not become available")
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn is_service_ipc_path_exists() -> bool {
|
|
||||||
Path::new(clash_verge_service_ipc::IPC_PATH).exists()
|
|
||||||
}
|
|
||||||
|
|
||||||
impl ServiceManager {
|
impl ServiceManager {
|
||||||
pub const fn config() -> clash_verge_service_ipc::IpcConfig {
|
pub const fn config() -> clash_verge_service_ipc::IpcConfig {
|
||||||
clash_verge_service_ipc::IpcConfig {
|
clash_verge_service_ipc::IpcConfig {
|
||||||
@@ -1484,8 +1413,17 @@ impl ServiceManager {
|
|||||||
}
|
}
|
||||||
|
|
||||||
#[cfg(target_os = "windows")]
|
#[cfg(target_os = "windows")]
|
||||||
pub async fn init(&self) -> Result<()> {
|
pub async fn confirm_ready(&self) -> Result<()> {
|
||||||
apply_service_version_result(self, probe_service_version_once().await, "service connection failed")
|
let reply = probe_service_version_once()
|
||||||
|
.await
|
||||||
|
.context("service readiness probe failed")?;
|
||||||
|
apply_service_version_reply(self, &reply)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns the latest confirmed readiness without performing IPC.
|
||||||
|
pub fn is_ready_cached(&self) -> bool {
|
||||||
|
let status = self.status.lock();
|
||||||
|
!self.operation_running.load(Ordering::Acquire) && matches!(*status, ServiceStatus::Ready)
|
||||||
}
|
}
|
||||||
|
|
||||||
pub async fn current(&self) -> ServiceStatus {
|
pub async fn current(&self) -> ServiceStatus {
|
||||||
@@ -1702,10 +1640,9 @@ mod tests {
|
|||||||
CurrentServiceProbe, OwnerRecoveryReason, PrivilegedServiceAction, ServiceInstallState, ServiceStatus,
|
CurrentServiceProbe, OwnerRecoveryReason, PrivilegedServiceAction, ServiceInstallState, ServiceStatus,
|
||||||
ServiceVersionCheck, ServiceVersionReply, apply_service_version_result, capture_generation_before,
|
ServiceVersionCheck, ServiceVersionReply, apply_service_version_result, capture_generation_before,
|
||||||
claim_owner_recovery_generation, classify_service_install_state, classify_service_version_reply,
|
claim_owner_recovery_generation, classify_service_install_state, classify_service_version_reply,
|
||||||
confirmed_service_available, generate_service_session_token, macos_install_shell,
|
generate_service_session_token, macos_install_shell, mark_service_unavailable_after_owner_loss,
|
||||||
mark_service_unavailable_after_owner_loss, owner_recovery_policy, owner_status_recovery_reason,
|
owner_recovery_policy, owner_status_recovery_reason, poll_service_version, privileged_service_action,
|
||||||
poll_service_version, privileged_service_action, probe_service_availability_with, service_core_path_for,
|
service_core_path_for, session_matches_status, transport_failure_recovery_reason,
|
||||||
session_matches_status, transport_failure_recovery_reason,
|
|
||||||
};
|
};
|
||||||
#[cfg(unix)]
|
#[cfg(unix)]
|
||||||
use super::{service_core_path_for_with_publisher, service_tool_path_for};
|
use super::{service_core_path_for_with_publisher, service_tool_path_for};
|
||||||
@@ -2129,8 +2066,8 @@ mod tests {
|
|||||||
assert_eq!(classify_service_version_reply(&reply), ServiceVersionCheck::Ready);
|
assert_eq!(classify_service_version_reply(&reply), ServiceVersionCheck::Ready);
|
||||||
}
|
}
|
||||||
|
|
||||||
#[tokio::test]
|
#[test]
|
||||||
async fn stale_availability_probe_cannot_overwrite_a_newer_terminal_status() {
|
fn cached_readiness_reflects_confirmed_state_without_mutating_it() {
|
||||||
let manager = super::ServiceManager {
|
let manager = super::ServiceManager {
|
||||||
status: parking_lot::Mutex::new(ServiceStatus::Ready),
|
status: parking_lot::Mutex::new(ServiceStatus::Ready),
|
||||||
status_generation: AtomicU64::new(0),
|
status_generation: AtomicU64::new(0),
|
||||||
@@ -2138,44 +2075,28 @@ mod tests {
|
|||||||
operation_done: tokio::sync::Notify::new(),
|
operation_done: tokio::sync::Notify::new(),
|
||||||
};
|
};
|
||||||
|
|
||||||
let available = probe_service_availability_with(&manager, false, || async {
|
assert!(manager.is_ready_cached());
|
||||||
manager.set_status(ServiceStatus::NotInstalled);
|
assert_eq!(*manager.status.lock(), ServiceStatus::Ready);
|
||||||
Ok(ServiceVersionReply {
|
assert_eq!(manager.status_generation.load(Ordering::Acquire), 0);
|
||||||
code: 0,
|
|
||||||
message: String::new(),
|
|
||||||
protocol: Some(current_protocol()),
|
|
||||||
})
|
|
||||||
})
|
|
||||||
.await;
|
|
||||||
|
|
||||||
assert!(matches!(available, Ok(false)));
|
manager.set_status(ServiceStatus::NotInstalled);
|
||||||
|
assert!(!manager.is_ready_cached());
|
||||||
assert_eq!(*manager.status.lock(), ServiceStatus::NotInstalled);
|
assert_eq!(*manager.status.lock(), ServiceStatus::NotInstalled);
|
||||||
|
assert_eq!(manager.status_generation.load(Ordering::Acquire), 1);
|
||||||
}
|
}
|
||||||
|
|
||||||
#[tokio::test]
|
#[test]
|
||||||
async fn cached_non_ready_availability_gate_and_generation_are_captured_together() {
|
fn cached_readiness_is_false_while_a_service_operation_is_running() {
|
||||||
let manager = super::ServiceManager {
|
let manager = super::ServiceManager {
|
||||||
status: parking_lot::Mutex::new(ServiceStatus::NotInstalled),
|
status: parking_lot::Mutex::new(ServiceStatus::Ready),
|
||||||
status_generation: AtomicU64::new(4),
|
status_generation: AtomicU64::new(0),
|
||||||
operation_running: AtomicBool::new(false),
|
operation_running: AtomicBool::new(true),
|
||||||
operation_done: tokio::sync::Notify::new(),
|
operation_done: tokio::sync::Notify::new(),
|
||||||
};
|
};
|
||||||
let probed = AtomicBool::new(false);
|
|
||||||
|
|
||||||
let available = probe_service_availability_with(&manager, true, || async {
|
assert!(!manager.is_ready_cached());
|
||||||
probed.store(true, Ordering::Release);
|
assert_eq!(*manager.status.lock(), ServiceStatus::Ready);
|
||||||
Ok(ServiceVersionReply {
|
assert_eq!(manager.status_generation.load(Ordering::Acquire), 0);
|
||||||
code: 0,
|
|
||||||
message: String::new(),
|
|
||||||
protocol: Some(current_protocol()),
|
|
||||||
})
|
|
||||||
})
|
|
||||||
.await;
|
|
||||||
|
|
||||||
assert!(matches!(available, Ok(false)));
|
|
||||||
assert!(!probed.load(Ordering::Acquire));
|
|
||||||
assert_eq!(*manager.status.lock(), ServiceStatus::NotInstalled);
|
|
||||||
assert_eq!(manager.status_generation.load(Ordering::Acquire), 4);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
#[tokio::test]
|
#[tokio::test]
|
||||||
@@ -2228,8 +2149,8 @@ mod tests {
|
|||||||
);
|
);
|
||||||
}
|
}
|
||||||
|
|
||||||
#[tokio::test]
|
#[test]
|
||||||
async fn only_transport_owner_loss_marks_service_unavailable_and_blocks_stale_probe() {
|
fn only_transport_owner_loss_marks_cached_readiness_unavailable() {
|
||||||
for reason in [OwnerRecoveryReason::Displaced, OwnerRecoveryReason::SameOwnerFailure] {
|
for reason in [OwnerRecoveryReason::Displaced, OwnerRecoveryReason::SameOwnerFailure] {
|
||||||
let manager = super::ServiceManager {
|
let manager = super::ServiceManager {
|
||||||
status: parking_lot::Mutex::new(ServiceStatus::Ready),
|
status: parking_lot::Mutex::new(ServiceStatus::Ready),
|
||||||
@@ -2238,6 +2159,7 @@ mod tests {
|
|||||||
operation_done: tokio::sync::Notify::new(),
|
operation_done: tokio::sync::Notify::new(),
|
||||||
};
|
};
|
||||||
mark_service_unavailable_after_owner_loss(&manager, reason);
|
mark_service_unavailable_after_owner_loss(&manager, reason);
|
||||||
|
assert!(manager.is_ready_cached());
|
||||||
assert_eq!(*manager.status.lock(), ServiceStatus::Ready);
|
assert_eq!(*manager.status.lock(), ServiceStatus::Ready);
|
||||||
assert_eq!(manager.status_generation.load(Ordering::Acquire), 0);
|
assert_eq!(manager.status_generation.load(Ordering::Acquire), 0);
|
||||||
}
|
}
|
||||||
@@ -2248,17 +2170,9 @@ mod tests {
|
|||||||
operation_running: AtomicBool::new(false),
|
operation_running: AtomicBool::new(false),
|
||||||
operation_done: tokio::sync::Notify::new(),
|
operation_done: tokio::sync::Notify::new(),
|
||||||
};
|
};
|
||||||
let available = probe_service_availability_with(&manager, false, || async {
|
|
||||||
mark_service_unavailable_after_owner_loss(&manager, OwnerRecoveryReason::TransportFailure);
|
|
||||||
Ok(ServiceVersionReply {
|
|
||||||
code: 0,
|
|
||||||
message: String::new(),
|
|
||||||
protocol: Some(current_protocol()),
|
|
||||||
})
|
|
||||||
})
|
|
||||||
.await;
|
|
||||||
|
|
||||||
assert!(matches!(available, Ok(false)));
|
mark_service_unavailable_after_owner_loss(&manager, OwnerRecoveryReason::TransportFailure);
|
||||||
|
assert!(!manager.is_ready_cached());
|
||||||
let status = manager.status.lock().clone();
|
let status = manager.status.lock().clone();
|
||||||
assert!(matches!(
|
assert!(matches!(
|
||||||
status,
|
status,
|
||||||
@@ -2308,13 +2222,6 @@ mod tests {
|
|||||||
);
|
);
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn only_confirmed_true_service_probe_is_available() {
|
|
||||||
assert!(confirmed_service_available(Ok::<bool, &str>(true)));
|
|
||||||
assert!(!confirmed_service_available(Ok::<bool, &str>(false)));
|
|
||||||
assert!(!confirmed_service_available(Err::<bool, &str>("offline")));
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn checking_is_public_and_unavailable() {
|
fn checking_is_public_and_unavailable() {
|
||||||
assert_eq!(ServiceStatus::Checking.install_state(), ServiceInstallState::Checking);
|
assert_eq!(ServiceStatus::Checking.install_state(), ServiceInstallState::Checking);
|
||||||
|
|||||||
@@ -208,7 +208,7 @@ impl Tray {
|
|||||||
let verge = Config::verge().await.latest_arc();
|
let verge = Config::verge().await.latest_arc();
|
||||||
let system_proxy = verge.enable_system_proxy.as_ref().unwrap_or(&false);
|
let system_proxy = verge.enable_system_proxy.as_ref().unwrap_or(&false);
|
||||||
let tun_mode = verge.enable_tun_mode.as_ref().unwrap_or(&false);
|
let tun_mode = verge.enable_tun_mode.as_ref().unwrap_or(&false);
|
||||||
let tun_mode_available = is_current_app_handle_admin(app_handle) || service::is_service_available().await;
|
let tun_mode_available = is_current_app_handle_admin(app_handle) || service::SERVICE_MANAGER.is_ready_cached();
|
||||||
let mode = {
|
let mode = {
|
||||||
Config::clash()
|
Config::clash()
|
||||||
.await
|
.await
|
||||||
|
|||||||
@@ -158,7 +158,6 @@ mod app_init {
|
|||||||
cmd::uninstall_service,
|
cmd::uninstall_service,
|
||||||
cmd::reinstall_service,
|
cmd::reinstall_service,
|
||||||
cmd::repair_service,
|
cmd::repair_service,
|
||||||
cmd::is_service_available,
|
|
||||||
cmd::get_service_install_state,
|
cmd::get_service_install_state,
|
||||||
cmd::continue_with_sidecar,
|
cmd::continue_with_sidecar,
|
||||||
cmd::get_clash_info,
|
cmd::get_clash_info,
|
||||||
|
|||||||
@@ -7,11 +7,8 @@ import {
|
|||||||
supportedLanguages,
|
supportedLanguages,
|
||||||
} from '@/services/i18n'
|
} from '@/services/i18n'
|
||||||
|
|
||||||
import { useVerge } from './use-verge'
|
|
||||||
|
|
||||||
export const useI18n = () => {
|
export const useI18n = () => {
|
||||||
const { i18n, t } = useTranslation()
|
const { i18n, t } = useTranslation()
|
||||||
const { patchVerge } = useVerge()
|
|
||||||
const [isLoading, setIsLoading] = useState(false)
|
const [isLoading, setIsLoading] = useState(false)
|
||||||
|
|
||||||
const switchLanguage = useCallback(
|
const switchLanguage = useCallback(
|
||||||
@@ -30,17 +27,13 @@ export const useI18n = () => {
|
|||||||
setIsLoading(true)
|
setIsLoading(true)
|
||||||
try {
|
try {
|
||||||
await changeLanguage(targetLanguage)
|
await changeLanguage(targetLanguage)
|
||||||
|
|
||||||
if (patchVerge) {
|
|
||||||
await patchVerge({ language: targetLanguage })
|
|
||||||
}
|
|
||||||
} catch (error) {
|
} catch (error) {
|
||||||
console.error('Failed to change language:', error)
|
console.error('Failed to change language:', error)
|
||||||
} finally {
|
} finally {
|
||||||
setIsLoading(false)
|
setIsLoading(false)
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
[i18n.language, patchVerge],
|
[i18n.language],
|
||||||
)
|
)
|
||||||
|
|
||||||
return {
|
return {
|
||||||
|
|||||||
@@ -4,7 +4,6 @@ import {
|
|||||||
getRunningMode,
|
getRunningMode,
|
||||||
getServiceInstallState,
|
getServiceInstallState,
|
||||||
isAdmin,
|
isAdmin,
|
||||||
isServiceAvailable,
|
|
||||||
type RunningMode,
|
type RunningMode,
|
||||||
type ServiceInstallState,
|
type ServiceInstallState,
|
||||||
} from '@/services/cmds'
|
} from '@/services/cmds'
|
||||||
@@ -29,17 +28,15 @@ const defaultSystemState = {
|
|||||||
} as SystemState
|
} as SystemState
|
||||||
|
|
||||||
export const fetchSystemState = async (): Promise<SystemState> => {
|
export const fetchSystemState = async (): Promise<SystemState> => {
|
||||||
const [runningMode, isAdminMode, isServiceOk, serviceInstallState] =
|
const [runningMode, isAdminMode, serviceInstallState] = await Promise.all([
|
||||||
await Promise.all([
|
getRunningMode(),
|
||||||
getRunningMode(),
|
isAdmin(),
|
||||||
isAdmin(),
|
getServiceInstallState().catch(() => null),
|
||||||
isServiceAvailable(),
|
])
|
||||||
getServiceInstallState().catch(() => null),
|
|
||||||
])
|
|
||||||
return {
|
return {
|
||||||
runningMode,
|
runningMode,
|
||||||
isAdminMode,
|
isAdminMode,
|
||||||
isServiceOk,
|
isServiceOk: serviceInstallState === 'ready',
|
||||||
serviceInstallState,
|
serviceInstallState,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -61,7 +61,6 @@ export const useLayoutEvents = (
|
|||||||
'getSystemProxy',
|
'getSystemProxy',
|
||||||
'getAutotemProxy',
|
'getAutotemProxy',
|
||||||
'getRunningMode',
|
'getRunningMode',
|
||||||
'isServiceAvailable',
|
|
||||||
'getSystemState',
|
'getSystemState',
|
||||||
])
|
])
|
||||||
}),
|
}),
|
||||||
|
|||||||
@@ -404,14 +404,6 @@ export const continueWithSidecar = async () => {
|
|||||||
return invoke<void>('continue_with_sidecar')
|
return invoke<void>('continue_with_sidecar')
|
||||||
}
|
}
|
||||||
|
|
||||||
// 系统服务是否可用
|
|
||||||
export const isServiceAvailable = async () => {
|
|
||||||
try {
|
|
||||||
return await invoke<boolean>('is_service_available')
|
|
||||||
} catch {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
}
|
|
||||||
export const entry_lightweight_mode = async () => {
|
export const entry_lightweight_mode = async () => {
|
||||||
return invoke<void>('entry_lightweight_mode')
|
return invoke<void>('entry_lightweight_mode')
|
||||||
}
|
}
|
||||||
|
|||||||
Reference in New Issue
Block a user