mirror of
https://github.com/clash-verge-rev/clash-verge-rev.git
synced 2026-11-22 04:12:08 +08:00
* fix(core): reopen PAC when a start attempt never happens `save_proxy_ports` closes the PAC endpoint before it stages a candidate, because the endpoint resolves the Mixed Port through the draft layer and would otherwise answer with a port nothing is listening on. Most ways out of that function are a rejection, though: the candidate is refused and the Core keeps serving on its old ports, having never been stopped. PAC is re-derived only when the Running Mode changes, and that is exactly what did not happen — so the endpoint stayed shut for the rest of the session, and every browser on PAC silently went direct. Give `core_starting` the counterpart it was missing. `core_start_settled` re-derives PAC from the Running Mode rather than restoring a saved flag, which makes it correct on all three endings — a start that succeeded, one that was abandoned, one that failed and left the Core down — and therefore safe to run from a guard on every path. * fix(config): refuse overlapping draft transactions instead of losing an edit A layer holds exactly one draft, so a second writer's `edit_draft` overwrites the first writer's staged value in place. `DraftTransaction` nonetheless rolled back by calling `discard` on the shared layer, which discarded whatever was staged there — including a change another transaction was about to commit. The other transaction then found no draft, and `apply` on an absent draft does nothing at all. It saved the committed value, returned Ok, and its side effect had already happened: auto-launch registered with the OS while the config that describes it says otherwise, and no log line either way. "Roll back only my edit" cannot be implemented over a single slot, so enforce the exclusivity the type already assumed. Beginning a transaction claims every layer and refuses rather than interleaving, which is the same shape as `try_start_config_update` and `begin_operation` elsewhere. `patch_verge` is the caller that matters: it holds its draft across `process_terminated_flags`, which restarts the Core and can take seconds. The TUN reconciliation runs on every Run State transition and can now lose that race, so it treats a busy layer as "later" rather than as a failure worth telling the user about. * fix(core): reconcile TUN availability when the setting itself changes Moving the TUN availability guard from the frontend into Rust also moved what triggers it. The old effect depended on `enable_tun_mode`; the new reconciliation is spawned from `RealEnv::publish`, so it only runs on a Run State transition. Those two sets are not the same, and the setting itself falls in the gap. Switching TUN on from the global hotkey is the case that reaches it. That path is not gated on availability — unlike the tray item and the settings switch, both of which read `tun_capable` — and the flags a TUN patch raises are answered by a Core reload, which changes no Run State at all. So on a machine with no Service and no elevation the setting stayed on: tray icon, settings switch and `enable_tun_mode` in verge.yaml all reported TUN as enabled while nothing carried its traffic, until some unrelated core lifecycle transition happened to reconcile it. Reconcile after any patch that touched the setting. The reconciliation writes configuration itself, so it goes through the plain apply rather than back through the patch-and-reconcile form; the absence of a cycle is then a property of the call graph rather than of a runtime early-return. `toggle_tun_mode` now reads the setting back instead of returning what it asked for, so the hotkey cannot report TUN as on moments before the notice saying it was turned off. * fix(core): an action already under way is not a decision to put to the user The legacy status could not distinguish a requested privileged operation from one already running, because readers blocked until the operation finished and so never observed the request at all. Run State pushes every transition instead, and `service_needs_attention` treated any pending action as a question for the user. So an install started from the settings page or the home card raised the migration dialog on top of it, and an uninstall raised one offering to reinstall the Service being removed. Both offer a button that can only fail, since the privileged-operation slot is already taken. An operation in flight is a report of progress. The dialog the user is already driving keeps itself open through its own loading state. `tun_should_be_disabled` is unaffected: it already refused to act while an operation was in flight, so the term this adds is redundant there. * fix(core): let the snapshot decide whether the Run State has settled `settled` read the operation slot twice: once to decide whether to wait, then again inside the snapshot it returned. An operation claiming the slot between those two reads was described rather than waited for. `prepare_startup` reads this. A start racing an install would see the requested install, flatten it to `InstallRequired`, and decide `Wait` — leaving the core stopped where waiting for the install to finish would have told it whether the Service came back. Read the slot once, inside the snapshot, so there is no window rather than a second check closing it. The rewrite that introduced this also fixed a lost wakeup here, and that fix stands: the waiter is still registered before the state is read. * fix(ui): re-read the Run State once its listener is live Replacing the poll with a push left a gap. `listen` resolves asynchronously, so between the first `get_runtime_state` and the subscription being registered there is a window, and a transition landing in it is not queued anywhere — it is simply missed. The next event is whenever the backend happens to move again, which during startup can be a long time; the 30-second safety net was all that stood behind it, where the old code polled every two seconds precisely through startup. The Run State is the one thing here that arrives only by event, so it is the one thing a missed event leaves stale. Re-read it once every listener is live, which closes the gap without going back to polling for it. `onSubscribed` fires even when a registration failed, because a resync is most needed when a subscription is missing, and not at all after teardown. * docs(config): state what makes the PAC endpoint's draft read safe `MixedPort::desired` reads the draft layer, so the PAC endpoint can name a port the Core has not moved to yet. That is only safe because the one path staging a listener port closes PAC across the change. Nothing said so at either end, and the two are in different modules. * fix(core): ask again when staging goes silent rather than assume it failed The Service commits the generation before it answers, so a reply that never arrives is not evidence that nothing was written: config.yaml can already hold the new configuration while this side concludes the staging never happened. The Core keeps running the previous configuration, so nothing looks wrong -- until the Core dies and the Service's watchdog restarts it in the same generation from whatever config.yaml says, quietly making live a configuration the app reported as failed. Silence is the one answer that has to be resolved rather than acted on, so ask once more before falling back. It is cheap exactly where it matters: staging plans against the manifest it wrote, so a bundle that already landed copies nothing and answers in milliseconds, and the Service's lifecycle lock makes a second ask wait for a first one still in flight instead of interleaving with it. A deadline keeps that wait off the caller, and a second silence goes where the first one used to.
448 lines
15 KiB
Rust
448 lines
15 KiB
Rust
#[cfg(test)]
|
|
mod tests {
|
|
use anyhow::anyhow;
|
|
use clash_verge_draft::Draft;
|
|
use std::future::Future;
|
|
use std::sync::Arc;
|
|
use std::time::Duration;
|
|
use tokio::sync::Notify;
|
|
use tokio::time::sleep;
|
|
|
|
#[derive(Clone, Debug, Default, PartialEq)]
|
|
struct IVerge {
|
|
enable_auto_launch: Option<bool>,
|
|
enable_tun_mode: Option<bool>,
|
|
}
|
|
|
|
const STRESS_LEVELS: [usize; 6] = [8, 16, 32, 64, 128, 256];
|
|
|
|
fn verge(enable_auto_launch: bool, enable_tun_mode: bool) -> IVerge {
|
|
IVerge {
|
|
enable_auto_launch: Some(enable_auto_launch),
|
|
enable_tun_mode: Some(enable_tun_mode),
|
|
}
|
|
}
|
|
|
|
fn block_on_ready<F: Future>(fut: F) -> F::Output {
|
|
tokio::runtime::Runtime::new().unwrap().block_on(fut)
|
|
}
|
|
|
|
#[test]
|
|
fn test_draft_basic_flow() {
|
|
let draft = Draft::new(verge(true, false));
|
|
|
|
{
|
|
let data = draft.data_arc();
|
|
assert_eq!(data.enable_auto_launch, Some(true));
|
|
assert_eq!(data.enable_tun_mode, Some(false));
|
|
}
|
|
|
|
draft.edit_draft(|d| {
|
|
d.enable_auto_launch = Some(false);
|
|
d.enable_tun_mode = Some(true);
|
|
});
|
|
|
|
{
|
|
let data = draft.data_arc();
|
|
assert_eq!(data.enable_auto_launch, Some(true));
|
|
assert_eq!(data.enable_tun_mode, Some(false));
|
|
}
|
|
|
|
{
|
|
let latest = draft.latest_arc();
|
|
assert_eq!(latest.enable_auto_launch, Some(false));
|
|
assert_eq!(latest.enable_tun_mode, Some(true));
|
|
}
|
|
|
|
draft.apply();
|
|
|
|
{
|
|
let data = draft.data_arc();
|
|
assert_eq!(data.enable_auto_launch, Some(false));
|
|
assert_eq!(data.enable_tun_mode, Some(true));
|
|
}
|
|
|
|
// 新一轮草稿并修改
|
|
draft.edit_draft(|d| {
|
|
d.enable_auto_launch = Some(true);
|
|
});
|
|
{
|
|
let latest = draft.latest_arc();
|
|
assert_eq!(latest.enable_auto_launch, Some(true));
|
|
assert_eq!(latest.enable_tun_mode, Some(true));
|
|
}
|
|
|
|
draft.discard();
|
|
|
|
{
|
|
draft.edit_draft(|d| {
|
|
assert_eq!(d.enable_auto_launch, Some(false));
|
|
d.enable_tun_mode = Some(false);
|
|
});
|
|
let data = draft.data_arc();
|
|
assert_eq!(data.enable_auto_launch, Some(false));
|
|
assert_eq!(data.enable_tun_mode, Some(true));
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_arc_pointer_behavior_on_edit_and_apply() {
|
|
let draft = Draft::new(verge(true, false));
|
|
|
|
let committed = draft.data_arc();
|
|
let latest = draft.latest_arc();
|
|
assert!(Arc::ptr_eq(&committed, &latest));
|
|
|
|
draft.edit_draft(|d| d.enable_tun_mode = Some(true));
|
|
let committed_after_first_edit = draft.data_arc();
|
|
let draft_after_first_edit = draft.latest_arc();
|
|
assert!(!Arc::ptr_eq(&committed_after_first_edit, &draft_after_first_edit));
|
|
let prev_draft_ptr = Arc::as_ptr(&draft_after_first_edit);
|
|
draft.apply();
|
|
let committed_after_apply = draft.data_arc();
|
|
assert_eq!(Arc::as_ptr(&committed_after_apply), prev_draft_ptr);
|
|
|
|
draft.edit_draft(|d| d.enable_auto_launch = Some(false));
|
|
let latest1 = draft.latest_arc();
|
|
let latest1_ptr = Arc::as_ptr(&latest1);
|
|
drop(latest1);
|
|
|
|
draft.edit_draft(|d| d.enable_tun_mode = Some(false));
|
|
let latest2 = draft.latest_arc();
|
|
let latest2_ptr = Arc::as_ptr(&latest2);
|
|
|
|
assert_eq!(latest1_ptr, latest2_ptr, "Unique edit should not clone Arc");
|
|
assert_eq!(latest2.enable_auto_launch, Some(false));
|
|
assert_eq!(latest2.enable_tun_mode, Some(false));
|
|
}
|
|
|
|
#[test]
|
|
fn test_discard_restores_latest_to_committed() {
|
|
let draft = Draft::new(verge(false, false));
|
|
|
|
draft.edit_draft(|d| d.enable_auto_launch = Some(true));
|
|
let committed = draft.data_arc();
|
|
let latest = draft.latest_arc();
|
|
assert!(!Arc::ptr_eq(&committed, &latest));
|
|
|
|
draft.discard();
|
|
let committed2 = draft.data_arc();
|
|
let latest2 = draft.latest_arc();
|
|
assert!(Arc::ptr_eq(&committed2, &latest2));
|
|
assert_eq!(latest2.enable_auto_launch, Some(false));
|
|
}
|
|
|
|
#[test]
|
|
fn test_edit_draft_returns_closure_result() {
|
|
let draft = Draft::new(IVerge::default());
|
|
let ret = draft.edit_draft(|d| {
|
|
d.enable_tun_mode = Some(true);
|
|
123usize
|
|
});
|
|
assert_eq!(ret, 123);
|
|
let latest = draft.latest_arc();
|
|
assert_eq!(latest.enable_tun_mode, Some(true));
|
|
}
|
|
|
|
#[test]
|
|
fn test_with_data_modify_ok_and_replaces_committed() {
|
|
let draft = Draft::new(verge(false, false));
|
|
|
|
let res = block_on_ready(draft.with_data_modify(|mut v| async move {
|
|
v.enable_auto_launch = Some(true);
|
|
Ok((v, "done"))
|
|
}));
|
|
assert_eq!(res.unwrap(), "done");
|
|
|
|
let committed = draft.data_arc();
|
|
assert_eq!(committed.enable_auto_launch, Some(true));
|
|
assert_eq!(committed.enable_tun_mode, Some(false));
|
|
}
|
|
|
|
#[test]
|
|
fn test_with_data_modify_keeps_boxed_data_shape() {
|
|
let draft = Draft::new(Box::new(verge(false, false)));
|
|
|
|
block_on_ready(draft.with_data_modify(|mut v| async move {
|
|
v.enable_auto_launch = Some(true);
|
|
Ok((v, ()))
|
|
}))
|
|
.unwrap();
|
|
|
|
assert_eq!(draft.data_arc().enable_auto_launch, Some(true));
|
|
}
|
|
|
|
#[test]
|
|
fn test_with_data_modify_error_releases_permit() {
|
|
let draft = Draft::new(IVerge::default());
|
|
|
|
#[allow(clippy::unwrap_used)]
|
|
let err = block_on_ready(draft.with_data_modify(|_v| async move { Err::<(IVerge, ()), _>(anyhow!("boom")) }))
|
|
.unwrap_err();
|
|
|
|
assert_eq!(format!("{err}"), "boom");
|
|
|
|
#[allow(clippy::unwrap_used)]
|
|
block_on_ready(draft.with_data_modify(|mut v| async move {
|
|
v.enable_auto_launch = Some(true);
|
|
Ok((v, ()))
|
|
}))
|
|
.unwrap();
|
|
|
|
assert_eq!(draft.data_arc().enable_auto_launch, Some(true));
|
|
}
|
|
|
|
#[test]
|
|
fn test_with_data_modify_serialized_under_stress_levels() {
|
|
for task_count in STRESS_LEVELS {
|
|
run_with_data_modify_stress(task_count, Duration::from_millis(1));
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_with_data_modify_keeps_apply_conflict_detection() {
|
|
let rt = tokio::runtime::Runtime::new().unwrap();
|
|
let draft = Arc::new(Draft::new(verge(false, false)));
|
|
let started = Arc::new(Notify::new());
|
|
let finish = Arc::new(Notify::new());
|
|
|
|
rt.block_on(async {
|
|
let task = {
|
|
let draft = Arc::clone(&draft);
|
|
let started = Arc::clone(&started);
|
|
let finish = Arc::clone(&finish);
|
|
tokio::spawn(async move {
|
|
draft
|
|
.with_data_modify(|mut v| async move {
|
|
started.notify_one();
|
|
finish.notified().await;
|
|
v.enable_auto_launch = Some(true);
|
|
Ok((v, ()))
|
|
})
|
|
.await
|
|
})
|
|
};
|
|
|
|
started.notified().await;
|
|
draft.edit_draft(|d| d.enable_tun_mode = Some(true));
|
|
draft.apply();
|
|
finish.notify_one();
|
|
|
|
let err = task.await.expect("task panicked").unwrap_err();
|
|
assert_eq!(
|
|
format!("{err}"),
|
|
"Optimistic lock failed: Committed data has changed during async operation"
|
|
);
|
|
});
|
|
|
|
let committed = draft.data_arc();
|
|
assert_eq!(committed.enable_auto_launch, Some(false));
|
|
assert_eq!(committed.enable_tun_mode, Some(true));
|
|
}
|
|
|
|
fn run_with_data_modify_stress(task_count: usize, delay: Duration) {
|
|
let rt = tokio::runtime::Runtime::new().unwrap();
|
|
let draft = Arc::new(Draft::new(verge(false, false)));
|
|
|
|
rt.block_on(async {
|
|
let mut handles = Vec::with_capacity(task_count);
|
|
for _ in 0..task_count {
|
|
let draft = Arc::clone(&draft);
|
|
handles.push(tokio::spawn(async move {
|
|
draft
|
|
.with_data_modify(|mut v| async move {
|
|
if !delay.is_zero() {
|
|
sleep(delay).await;
|
|
}
|
|
v.enable_auto_launch = Some(!v.enable_auto_launch.unwrap_or(false));
|
|
Ok((v, ()))
|
|
})
|
|
.await
|
|
}));
|
|
}
|
|
|
|
for handle in handles {
|
|
handle.await.expect("task panicked").expect("with_data_modify failed");
|
|
}
|
|
|
|
Ok::<(), anyhow::Error>(())
|
|
})
|
|
.unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn test_with_data_modify_does_not_touch_existing_draft() {
|
|
let draft = Draft::new(verge(false, false));
|
|
|
|
draft.edit_draft(|d| {
|
|
d.enable_auto_launch = Some(true);
|
|
d.enable_tun_mode = Some(true);
|
|
});
|
|
let draft_before = draft.latest_arc();
|
|
let draft_before_ptr = Arc::as_ptr(&draft_before);
|
|
|
|
#[allow(clippy::unwrap_used)]
|
|
block_on_ready(draft.with_data_modify(|mut v| async move {
|
|
v.enable_auto_launch = Some(false);
|
|
Ok((v, ()))
|
|
}))
|
|
.unwrap();
|
|
|
|
let draft_after = draft.latest_arc();
|
|
assert_eq!(
|
|
Arc::as_ptr(&draft_after),
|
|
draft_before_ptr,
|
|
"Existing draft should not be replaced by with_data_modify"
|
|
);
|
|
assert_eq!(draft_after.enable_auto_launch, Some(true));
|
|
assert_eq!(draft_after.enable_tun_mode, Some(true));
|
|
|
|
draft.discard();
|
|
let latest = draft.latest_arc();
|
|
assert_eq!(latest.enable_auto_launch, Some(false));
|
|
assert_eq!(latest.enable_tun_mode, Some(false));
|
|
}
|
|
}
|
|
|
|
mod transactions {
|
|
use clash_verge_draft::{Draft, DraftTransaction};
|
|
|
|
fn begin<'a>(layers: Vec<&'a dyn clash_verge_draft::DraftLayer>) -> DraftTransaction<'a> {
|
|
DraftTransaction::begin(layers).expect("no other transaction should hold these layers")
|
|
}
|
|
|
|
#[test]
|
|
fn committing_applies_every_layer() {
|
|
let first = Draft::new(1_u8);
|
|
let second = Draft::new("a".to_owned());
|
|
|
|
let transaction = begin(vec![&first, &second]);
|
|
first.edit_draft(|value| *value = 2);
|
|
second.edit_draft(|value| *value = "b".to_owned());
|
|
transaction.commit();
|
|
|
|
assert_eq!(**first.data_arc(), 2);
|
|
assert_eq!(**second.data_arc(), "b");
|
|
}
|
|
|
|
#[test]
|
|
fn dropping_without_committing_rolls_every_layer_back() {
|
|
let first = Draft::new(1_u8);
|
|
let second = Draft::new("a".to_owned());
|
|
|
|
{
|
|
let _transaction = begin(vec![&first, &second]);
|
|
first.edit_draft(|value| *value = 2);
|
|
second.edit_draft(|value| *value = "b".to_owned());
|
|
}
|
|
|
|
assert_eq!(**first.data_arc(), 1);
|
|
assert_eq!(**second.data_arc(), "a");
|
|
assert_eq!(
|
|
**first.latest_arc(),
|
|
1,
|
|
"the draft itself is gone, not just uncommitted"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn an_early_return_rolls_back_without_the_caller_saying_so() {
|
|
fn attempt(draft: &Draft<u8>, succeed: bool) -> Result<(), &'static str> {
|
|
let transaction = begin(vec![draft]);
|
|
draft.edit_draft(|value| *value = 9);
|
|
if !succeed {
|
|
return Err("failed after editing");
|
|
}
|
|
transaction.commit();
|
|
Ok(())
|
|
}
|
|
|
|
let draft = Draft::new(1_u8);
|
|
assert!(attempt(&draft, false).is_err());
|
|
assert_eq!(**draft.data_arc(), 1, "a failed attempt leaves nothing behind");
|
|
|
|
assert!(attempt(&draft, true).is_ok());
|
|
assert_eq!(**draft.data_arc(), 9);
|
|
}
|
|
|
|
#[test]
|
|
fn a_partly_edited_transaction_still_rolls_back_whole() {
|
|
// The layer nobody edited must not be left holding a stale draft either.
|
|
let edited = Draft::new(1_u8);
|
|
let untouched = Draft::new(5_u8);
|
|
|
|
drop(begin(vec![&edited, &untouched]));
|
|
edited.edit_draft(|value| *value = 2);
|
|
|
|
{
|
|
let _transaction = begin(vec![&edited, &untouched]);
|
|
}
|
|
|
|
assert_eq!(**edited.latest_arc(), 1, "the earlier stray draft is cleared too");
|
|
assert_eq!(**untouched.latest_arc(), 5);
|
|
}
|
|
}
|
|
|
|
mod transaction_exclusivity {
|
|
use clash_verge_draft::{Draft, DraftTransaction};
|
|
|
|
#[test]
|
|
fn a_second_transaction_over_a_claimed_layer_is_refused() {
|
|
let draft = Draft::new(1_u8);
|
|
let _held = DraftTransaction::begin(vec![&draft]).expect("the first claim should succeed");
|
|
|
|
let refused = DraftTransaction::begin(vec![&draft]);
|
|
|
|
assert!(refused.is_err(), "a layer may only be staged by one transaction");
|
|
}
|
|
|
|
#[test]
|
|
fn a_refused_transaction_leaves_the_layers_it_did_claim_free() {
|
|
// Claiming is all-or-nothing: a caller that failed on the third layer must not keep
|
|
// the first two, or the next attempt would be refused for a transaction that no
|
|
// longer exists.
|
|
let first = Draft::new(1_u8);
|
|
let second = Draft::new(2_u8);
|
|
let _contended = DraftTransaction::begin(vec![&second]).expect("the first claim should succeed");
|
|
|
|
assert!(DraftTransaction::begin(vec![&first, &second]).is_err());
|
|
|
|
drop(DraftTransaction::begin(vec![&first]).expect("the layer that was rolled off must be free"));
|
|
}
|
|
|
|
#[test]
|
|
fn a_layer_is_free_again_once_its_transaction_ends() {
|
|
let draft = Draft::new(1_u8);
|
|
|
|
drop(DraftTransaction::begin(vec![&draft]).expect("first"));
|
|
let committed = DraftTransaction::begin(vec![&draft]).expect("free after a rollback");
|
|
committed.commit();
|
|
|
|
drop(DraftTransaction::begin(vec![&draft]).expect("free after a commit"));
|
|
}
|
|
|
|
#[test]
|
|
fn an_overlapping_writer_can_no_longer_discard_a_staged_edit() {
|
|
// The regression this pins. A holds a transaction across a slow side effect; B starts,
|
|
// stages its own edit over the one draft slot, fails, and rolls back. Before layers
|
|
// were claimed, B's rollback cleared the single draft, A's commit then found nothing to
|
|
// apply and did nothing at all — while A's caller was told it had succeeded and A's own
|
|
// side effect had already happened.
|
|
let verge = Draft::new(String::from("committed"));
|
|
|
|
let transaction_a = DraftTransaction::begin(vec![&verge]).expect("A claims the layer");
|
|
verge.edit_draft(|value| *value = String::from("A-wants-this"));
|
|
|
|
let transaction_b = DraftTransaction::begin(vec![&verge]);
|
|
assert!(transaction_b.is_err(), "B must be refused rather than share the slot");
|
|
|
|
transaction_a.commit();
|
|
|
|
assert_eq!(
|
|
**verge.data_arc(),
|
|
"A-wants-this",
|
|
"A's edit must survive an overlapping writer"
|
|
);
|
|
}
|
|
}
|