mirror of
https://github.com/clash-verge-rev/clash-verge-rev.git
synced 2026-11-18 09:52:13 +08:00
refactor: Rewrite and improve sysproxy logic (#7744)
* fix(cmd): preserve anyhow context in coded errors Use alternate error formatting so coded failures retain the full anyhow context chain without changing their wire format. * fix(macos): skip redundant proxy disable writes When both proxy modes are off, read macOS state first and skip networksetup if the OS is already clean. Update the guard target only after a successful write. * feat(proxy): classify system proxy failures Attach stable, actionable proxy failure codes to anyhow chains while preserving the original diagnostic causes. * feat(cmd): return structured command failures Replace encoded error strings with serializable code and detail fields, and update frontend notice consumers to handle the structured shape. * fix(scripts): use the js-yaml namespace import Import js-yaml through its ESM namespace so the i18n cleanup script can access load and dump. * feat(proxy): localize classified proxy failures Map privilege and direct-fallback codes to localized explanations, and let mapped causes outrank generic operation keys in notices. * fix(ui): bound notice text and render failure details Limit resolved notice text without truncating clipboard content, and normalize structured failures embedded in translation parameters. * feat(proxy): persist unseen proxy failures Store unresolved classified failures by code, notify the frontend when the table changes, and show each failure sequence once when a visible window can receive it. * feat(proxy): report tray and hotkey toggle failures Record classified failures from tray and hotkey proxy toggles so they appear when a visible window is available. * fix(ui): restore the proxy switch after failed toggles Refresh frontend proxy state after a failed toggle so the switch reflects the rolled-back configuration. * feat(proxy): stop the guard after repeated failures Report guard outcomes, stop after the failure threshold, and persist the classified failure for the frontend. * fix(macos): preserve proxy during service handoff Stop a sidecar being handed to the service without clearing proxy state that the new owner must inherit. * feat(macos): classify misplaced sidecar state Distinguish a refused sidecar proxy write from a machine that still needs the privileged service installed. * feat(ui): recover misplaced sidecar notices Offer a restart action for macOS proxy failures caused by a ready service while the core still runs as a sidecar. * feat(ui): install the service from proxy notices Let privilege notices install the macOS service, restart the core, and report the runtime mode that was actually reached. * feat(cmd): attach requested proxy operations Carry the requested proxy direction with structured command failures when the originating command knows it. * feat(sysproxy): drain guards before OS access Wait for the local proxy guard to stop before OS reads, service handoff, or final writes, and refuse transitions when it does not drain. * feat(sysproxy): recover partial proxy writes Use write progress to choose whether to restore the old guard or compensate with a disabled proxy state, while preserving actionable errors. * feat(sysproxy): skip already-applied proxy writes Compare macOS proxy snapshots with global, PAC, and disabled targets so matching state avoids redundant privileged writes. * feat(proxy): report background proxy failures Persist and surface classified proxy failures from lifecycle paths that have no direct caller awaiting the result. * feat(ui): move proxy recovery into a dialog Guide users through installing or switching to the service after a refused proxy write, and suppress duplicate toast reports. * fix(ui): close proxy dialog after service recovery Dismiss the recovery dialog once the core reaches service mode, even when the original proxy request remains pending. * feat(ui): retry proxy request after service recovery Replay the requested proxy direction after the core reaches service mode, while leaving incidental restores unchanged. * fix(proxy): refresh state after successful apply Publish the proxy refresh from the shared apply path after releasing the lifecycle lock, and remove the tray-specific duplicate. * feat(ui): show proxy recovery progress Display installation, restart, and proxy-apply stages while keeping the primary action spinner visible during recovery. * feat(ui): route unavailable TUN through service recovery Let the TUN switch request service recovery and restore its requested state after the core restarts in service mode. * fix(ui): avoid duplicate TUN recovery errors Roll back deferred TUN toggles without reporting an error, and publish configuration refreshes from the transaction commit path. * chore: update changelog & pinlock * fix(core): resolve platform-specific clippy warnings * fix(core): detect Windows wildcard TCP conflicts Windows permits a specific exclusive bind beside an existing non-exclusive wildcard listener. Consult the system TCP listener table so the probe reports that overlap as a conflict.
This commit is contained in:
+240
-11
@@ -1,12 +1,94 @@
|
||||
use anyhow::Result;
|
||||
use smartstring::alias::String;
|
||||
|
||||
pub type CmdResult<T = ()> = Result<T, String>;
|
||||
pub type CmdResult<T = ()> = Result<T, CommandFailure>;
|
||||
|
||||
const USER_ERROR_PREFIX: &str = "CVR_ERROR:";
|
||||
/// Structured command failure returned to the frontend.
|
||||
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)]
|
||||
pub struct CommandFailure {
|
||||
/// Stable frontend identifier, when classified.
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
pub code: Option<std::string::String>,
|
||||
/// Human-readable diagnostic detail.
|
||||
pub detail: std::string::String,
|
||||
/// Requested operation when known by the command.
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
pub operation: Option<crate::core::notification::FailedOperation>,
|
||||
}
|
||||
|
||||
pub fn coded_error(code: &str, detail: impl std::fmt::Display) -> String {
|
||||
format!("{USER_ERROR_PREFIX}{code}\n{detail}").into()
|
||||
impl CommandFailure {
|
||||
/// A failure with a stable code.
|
||||
pub fn coded(code: &str, detail: impl std::fmt::Display) -> Self {
|
||||
Self {
|
||||
code: Some(code.to_owned()),
|
||||
detail: detail.to_string(),
|
||||
operation: None,
|
||||
}
|
||||
}
|
||||
|
||||
/// A failure with nothing to classify it by.
|
||||
pub fn plain(detail: impl std::fmt::Display) -> Self {
|
||||
Self {
|
||||
code: None,
|
||||
detail: detail.to_string(),
|
||||
operation: None,
|
||||
}
|
||||
}
|
||||
|
||||
/// Attach the requested operation when known.
|
||||
#[must_use]
|
||||
pub const fn asking_for(mut self, operation: Option<crate::core::notification::FailedOperation>) -> Self {
|
||||
self.operation = operation;
|
||||
self
|
||||
}
|
||||
}
|
||||
|
||||
/// Preserve plain-string failures without inventing a code.
|
||||
impl From<&str> for CommandFailure {
|
||||
fn from(detail: &str) -> Self {
|
||||
Self::plain(detail)
|
||||
}
|
||||
}
|
||||
|
||||
impl From<std::string::String> for CommandFailure {
|
||||
fn from(detail: std::string::String) -> Self {
|
||||
Self {
|
||||
code: None,
|
||||
detail,
|
||||
operation: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<String> for CommandFailure {
|
||||
fn from(detail: String) -> Self {
|
||||
Self::plain(detail)
|
||||
}
|
||||
}
|
||||
|
||||
impl std::fmt::Display for CommandFailure {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
f.write_str(&self.detail)
|
||||
}
|
||||
}
|
||||
|
||||
pub fn coded_error(code: &str, detail: impl std::fmt::Display) -> CommandFailure {
|
||||
CommandFailure::coded(code, detail)
|
||||
}
|
||||
|
||||
/// Prefer an actionable proxy classification over the operation's fallback code.
|
||||
pub fn proxy_aware_coded_error(error: &anyhow::Error, fallback: &str) -> CommandFailure {
|
||||
let code =
|
||||
crate::core::proxy_control::SysproxyFailure::from_chain(error).map_or(fallback, |failure| failure.code());
|
||||
CommandFailure::coded(code, format_args!("{error:#}"))
|
||||
}
|
||||
|
||||
/// Preserve uncoded failures unless the chain contains a proxy classification.
|
||||
pub fn proxy_aware_error(error: &anyhow::Error) -> CommandFailure {
|
||||
match crate::core::proxy_control::SysproxyFailure::from_chain(error) {
|
||||
Some(failure) => CommandFailure::coded(failure.code(), format_args!("{error:#}")),
|
||||
None => CommandFailure::plain(format_args!("{error:#}")),
|
||||
}
|
||||
}
|
||||
|
||||
// Command modules
|
||||
@@ -60,7 +142,7 @@ pub trait WithErrorCode<T> {
|
||||
|
||||
impl<T, E: std::fmt::Display> StringifyErr<T> for Result<T, E> {
|
||||
fn stringify_err(self) -> CmdResult<T> {
|
||||
self.map_err(|e| e.to_string().into())
|
||||
self.map_err(CommandFailure::plain)
|
||||
}
|
||||
|
||||
fn stringify_err_log<F>(self, log_fn: F) -> CmdResult<T>
|
||||
@@ -68,28 +150,175 @@ impl<T, E: std::fmt::Display> StringifyErr<T> for Result<T, E> {
|
||||
F: Fn(&str),
|
||||
{
|
||||
self.map_err(|e| {
|
||||
let msg = String::from(e.to_string());
|
||||
log_fn(&msg);
|
||||
msg
|
||||
let failure = CommandFailure::plain(e);
|
||||
log_fn(&failure.detail);
|
||||
failure
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl<T, E: std::fmt::Display> WithErrorCode<T> for Result<T, E> {
|
||||
fn with_error_code(self, code: &str) -> CmdResult<T> {
|
||||
self.map_err(|error| coded_error(code, error))
|
||||
// Alternate formatting expands the full `anyhow` context chain.
|
||||
self.map_err(|error| CommandFailure::coded(code, format_args!("{error:#}")))
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::coded_error;
|
||||
use super::{CommandFailure, WithErrorCode as _, coded_error, proxy_aware_coded_error, proxy_aware_error};
|
||||
use crate::core::proxy_control::SysproxyFailure;
|
||||
use anyhow::Context as _;
|
||||
|
||||
#[test]
|
||||
fn coded_error_preserves_stable_code_and_diagnostic_detail() {
|
||||
assert_eq!(
|
||||
coded_error("CORE_RESTART_FAILED", "connection refused"),
|
||||
"CVR_ERROR:CORE_RESTART_FAILED\nconnection refused"
|
||||
CommandFailure {
|
||||
code: Some("CORE_RESTART_FAILED".to_owned()),
|
||||
detail: "connection refused".to_owned(),
|
||||
operation: None,
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn with_error_code_preserves_whole_anyhow_context_chain() {
|
||||
let source: anyhow::Result<()> = Err(anyhow::anyhow!("connection refused"))
|
||||
.context("failed to reach the mihomo core")
|
||||
.context("failed to restart the core");
|
||||
|
||||
let failure = source
|
||||
.with_error_code("CORE_RESTART_FAILED")
|
||||
.err()
|
||||
.unwrap_or_else(|| CommandFailure::plain("the call should have failed"));
|
||||
|
||||
assert_eq!(
|
||||
failure,
|
||||
CommandFailure {
|
||||
code: Some("CORE_RESTART_FAILED".to_owned()),
|
||||
detail: "failed to restart the core: failed to reach the mihomo core: connection refused".to_owned(),
|
||||
operation: None,
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn with_error_code_leaves_plain_display_errors_untouched() {
|
||||
let source: Result<(), &str> = Err("plain failure");
|
||||
|
||||
let failure = source
|
||||
.with_error_code("PROFILE_READ_FAILED")
|
||||
.err()
|
||||
.unwrap_or_else(|| CommandFailure::plain("the call should have failed"));
|
||||
|
||||
assert_eq!(
|
||||
failure,
|
||||
CommandFailure {
|
||||
code: Some("PROFILE_READ_FAILED".to_owned()),
|
||||
detail: "plain failure".to_owned(),
|
||||
operation: None,
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_classification_outranks_the_code_naming_the_operation() {
|
||||
let failure = anyhow::Error::new(sysproxy::Error::RequiresAdminPrivileges)
|
||||
.context(SysproxyFailure::PrivilegeRequired)
|
||||
.context("failed to restart the core");
|
||||
|
||||
let reported = proxy_aware_coded_error(&failure, "CORE_RESTART_FAILED");
|
||||
|
||||
assert_eq!(reported.code.as_deref(), Some("SYSPROXY_PRIVILEGE_REQUIRED"));
|
||||
assert!(reported.detail.contains("failed to restart the core"), "{reported:?}");
|
||||
assert!(reported.detail.contains("admin privileges"), "{reported:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn without_a_classification_the_callers_code_is_used() {
|
||||
let failure = anyhow::anyhow!("connection refused").context("failed to start the core");
|
||||
|
||||
let reported = proxy_aware_coded_error(&failure, "CORE_START_FAILED");
|
||||
|
||||
assert_eq!(
|
||||
reported,
|
||||
CommandFailure {
|
||||
code: Some("CORE_START_FAILED".to_owned()),
|
||||
detail: "failed to start the core: connection refused".to_owned(),
|
||||
operation: None,
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn commands_that_report_plain_text_stay_uncoded_without_a_classification() {
|
||||
let failure = anyhow::anyhow!("disk full").context("failed to save the configuration");
|
||||
|
||||
let reported = proxy_aware_error(&failure);
|
||||
|
||||
assert_eq!(
|
||||
reported,
|
||||
CommandFailure {
|
||||
code: None,
|
||||
detail: "failed to save the configuration: disk full".to_owned(),
|
||||
operation: None,
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn commands_that_report_plain_text_still_carry_a_classification() {
|
||||
let failure = anyhow::Error::new(SysproxyFailure::DirectFallback {
|
||||
detail: "service could not set the proxy".to_owned(),
|
||||
})
|
||||
.context("failed to apply the verge patch");
|
||||
|
||||
let reported = proxy_aware_error(&failure);
|
||||
|
||||
assert_eq!(reported.code.as_deref(), Some("SYSPROXY_DIRECT_FALLBACK"));
|
||||
assert!(
|
||||
reported.detail.contains("failed to apply the verge patch"),
|
||||
"{reported:?}"
|
||||
);
|
||||
assert!(
|
||||
reported.detail.contains("service could not set the proxy"),
|
||||
"{reported:?}"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_command_that_knows_the_request_can_say_which_way_it_went() {
|
||||
let asking_on = CommandFailure::coded("SYSPROXY_PRIVILEGE_REQUIRED", "refused")
|
||||
.asking_for(Some(crate::core::notification::FailedOperation::SystemProxyEnable));
|
||||
|
||||
assert_eq!(
|
||||
serde_json::to_value(asking_on).unwrap_or(serde_json::Value::Null),
|
||||
serde_json::json!({
|
||||
"code": "SYSPROXY_PRIVILEGE_REQUIRED",
|
||||
"detail": "refused",
|
||||
"operation": "systemProxyEnable",
|
||||
})
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
serde_json::to_value(CommandFailure::coded("CORE_START_FAILED", "no").asking_for(None))
|
||||
.unwrap_or(serde_json::Value::Null),
|
||||
serde_json::json!({ "code": "CORE_START_FAILED", "detail": "no" })
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_serialised_shape_is_what_the_frontend_reads() {
|
||||
assert_eq!(
|
||||
serde_json::to_value(CommandFailure::coded("CORE_START_FAILED", "connection refused"))
|
||||
.unwrap_or(serde_json::Value::Null),
|
||||
serde_json::json!({ "code": "CORE_START_FAILED", "detail": "connection refused" })
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
serde_json::to_value(CommandFailure::plain("disk full")).unwrap_or(serde_json::Value::Null),
|
||||
serde_json::json!({ "detail": "disk full" })
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user