mirror of
https://github.com/clash-verge-rev/clash-verge-rev.git
synced 2026-11-11 04:42:09 +08:00
Tunglies
8328e34208
* refactor(core): type notice statuses behind the frozen wire contract * refactor(utils): unified retry and strategy-list helpers * refactor(feat): declarative effect registry for verge and clash patches * refactor(core): derive refresh announcements from transaction commit * refactor(core): fold tray, hotkey, autostart updates into effect ensures * refactor(utils): migrate remaining bounded retry loops * docs: add src-tauri architecture guardrails * refactor(core): coalesce burst refresh announcements * refactor(core): complete bounded service retry migration * ci(backend): add architecture ban gates * test(feat): freeze representative effect registry mappings * docs(backend): record dead wire contract entries * chore(core): document watcher exit conditions * fix(backend): preserve applied state across later failures * fix(config): retain runtime after an applied core replacement * refactor(backend): flatten refresh publication and retry policies * docs(backend): focus guardrails on architecture ownership * refactor(effects): use one execution order * fix(config): publish retained runtime and reconcile proxy settings
57 lines
1.7 KiB
Rust
57 lines
1.7 KiB
Rust
use crate::config::{Config, IVerge};
|
|
use anyhow::Result;
|
|
use clash_verge_draft::SharedDraft;
|
|
use serde_yaml_ng::Mapping;
|
|
use tokio::sync::MutexGuard;
|
|
|
|
pub async fn patch_clash(patch: &Mapping) -> Result<()> {
|
|
let config_write = Config::try_lock_config_write()?;
|
|
super::executor::apply(
|
|
&config_write,
|
|
super::executor::Patch::Clash(patch),
|
|
super::effects::clash_effects(patch),
|
|
)
|
|
.await
|
|
}
|
|
|
|
/// Apply a patch, then reconcile TUN when its setting changes.
|
|
///
|
|
/// TUN patches do not always produce a Run State transition, so reconciliation is explicit.
|
|
pub async fn patch_verge(patch: &IVerge, not_save_file: bool) -> Result<()> {
|
|
apply_verge_patch(patch, not_save_file).await?;
|
|
if patch.enable_tun_mode.is_some() {
|
|
super::reconcile_tun_availability().await;
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// Apply a patch without post-update reconciliation.
|
|
pub(super) async fn apply_verge_patch(patch: &IVerge, not_save_file: bool) -> Result<()> {
|
|
let config_write = Config::try_lock_config_write()?;
|
|
apply_verge_patch_locked(&config_write, patch, not_save_file).await
|
|
}
|
|
|
|
/// Apply a patch with the shared configuration write lock already held.
|
|
/// Callers must pass the guard returned by [`Config::lock_config_write`].
|
|
pub(super) async fn apply_verge_patch_locked(
|
|
_config_write: &MutexGuard<'_, ()>,
|
|
patch: &IVerge,
|
|
not_save_file: bool,
|
|
) -> Result<()> {
|
|
super::executor::apply(
|
|
_config_write,
|
|
super::executor::Patch::Verge {
|
|
patch,
|
|
persist: !not_save_file,
|
|
},
|
|
super::effects::verge_effects(patch),
|
|
)
|
|
.await
|
|
}
|
|
|
|
pub async fn fetch_verge_config() -> Result<SharedDraft<IVerge>> {
|
|
let draft = Config::verge().await;
|
|
let data = draft.data_arc();
|
|
Ok(data)
|
|
}
|