refactor: profile switch (#5197)

* refactor: proxy refresh

* fix(proxy-store): properly hydrate and filter backend provider snapshots

* fix(proxy-store): add monotonic fetch guard and event bridge cleanup

* fix(proxy-store): tweak fetch sequencing guard to prevent snapshot invalidation from wiping fast responses

* docs: UPDATELOG.md

* fix(proxy-snapshot, proxy-groups): restore last-selected proxy and group info

* fix(proxy): merge static and provider entries in snapshot; fix Virtuoso viewport height

* fix(proxy-groups): restrict reduced-height viewport to chain-mode column

* refactor(profiles): introduce a state machine

* refactor:replace state machine with reducer

* refactor:introduce a profile switch worker

* refactor: hooked up a backend-driven profile switch flow

* refactor(profile-switch): serialize switches with async queue and enrich frontend events

* feat(profiles): centralize profile switching with reducer/driver queue to fix stuck UI on rapid toggles

* chore: translate comments and log messages to English to avoid encoding issues

* refactor: migrate backend queue to SwitchDriver actor

* fix(profile): unify error string types in validation helper

* refactor(profile): make switch driver fully async and handle panics safely

* refactor(cmd): move switch-validation helper into new profile_switch module

* refactor(profile): modularize switch logic into profile_switch.rs

* refactor(profile_switch): modularize switch handler

- Break monolithic switch handler into proper module hierarchy
- Move shared globals, constants, and SwitchScope guard to state.rs
- Isolate queue orchestration and async task spawning in driver.rs
- Consolidate switch pipeline and config patching in workflow.rs
- Extract request pre-checks/YAML validation into validation.rs

* refactor(profile_switch): centralize state management and add cancellation flow

- Introduced SwitchManager in state.rs to unify mutex, sequencing, and SwitchScope handling.
- Added SwitchCancellation and SwitchRequest wrappers to encapsulate cancel tokens and notifications.
- Updated driver to allocate task IDs via SwitchManager, cancel old tokens, and queue next jobs in order.
- Updated workflow to check cancellation and sequence at each phase, replacing global flags with manager APIs.

* feat(profile_switch): integrate explicit state machine for profile switching

- workflow.rs:24 now delegates each switch to SwitchStateMachine, passing an owned SwitchRequest.
  Queue cancellation and state-sequence checks are centralized inside the machine instead of scattered guards.
- workflow.rs:176 replaces the old helper with `SwitchStateMachine::new(manager(), None, profiles).run().await`,
  ensuring manual profile patches follow the same workflow (locking, validation, rollback) as queued switches.
- workflow.rs:180 & 275 expose `validate_profile_yaml` and `restore_previous_profile` for reuse inside the state machine.

- workflow/state_machine.rs:1 introduces a dedicated state machine module.
  It manages global mutex acquisition, request/cancellation state, YAML validation, draft patching,
  `CoreManager::update_config`, failure rollback, and tray/notification side-effects.
  Transitions check for cancellations and stale sequences; completions release guards via `SwitchScope` drop.

* refactor(profile-switch): integrate stage-aware panic handling

- src-tauri/src/cmd/profile_switch/workflow/state_machine.rs:1
  Defines SwitchStage and SwitchPanicInfo as crate-visible, wraps each transition in with_stage(...) with catch_unwind, and propagates CmdResult<bool> to distinguish validation failures from panics while keeping cancellation semantics.

- src-tauri/src/cmd/profile_switch/workflow.rs:25
  Updates run_switch_job to return Result<bool, SwitchPanicInfo>, routing timeout, validation, config, and stage panic cases separately. Reuses SwitchPanicInfo for logging/UI notifications; patch_profiles_config maps state-machine panics into user-facing error strings.

- src-tauri/src/cmd/profile_switch/driver.rs:1
  Adds SwitchJobOutcome to unify workflow results: normal completions carry bool, and panics propagate SwitchPanicInfo. The driver loop now logs panics explicitly and uses AssertUnwindSafe(...).catch_unwind() to guard setup-phase panics.

* refactor(profile-switch): add watchdog, heartbeat, and async timeout guards

- Introduce SwitchHeartbeat for stage tracking and timing; log stage transitions with elapsed durations.
- Add watchdog in driver to cancel stalled switches (5s heartbeat timeout).
- Wrap blocking ops (Config::apply, tray updates, profiles_save_file_safe, etc.) with time::timeout to prevent async stalls.
- Improve logs for stage transitions and watchdog timeouts to clarify cancellation points.

* refactor(profile-switch): async post-switch tasks, early lock release, and spawn_blocking for IO

* feat(profile-switch): track cleanup and coordinate pipeline

- Add explicit cleanup tracking in the driver (`cleanup_profiles` map + `CleanupDone` messages) to know when background post-switch work is still running before starting a new workflow. (driver.rs:29-50)
- Update `handle_enqueue` to detect “cleanup in progress”: same-profile retries are short-circuited; other requests collapse the pending queue, cancelling old tokens so only the latest intent survives. (driver.rs:176-247)
- Rework scheduling helpers: `start_next_job` refuses to start while cleanup is outstanding; discarded requests release cancellation tokens; cleanup completion explicitly restarts the pipeline. (driver.rs:258-442)

* feat(profile-switch): unify post-switch cleanup handling

- workflow.rs (25-427) returns `SwitchWorkflowResult` (success + CleanupHandle) or `SwitchWorkflowError`.
  All failure/timeout paths stash post-switch work into a single CleanupHandle.
  Cleanup helpers (`notify_profile_switch_finished` and `close_connections_after_switch`) run inside that task for proper lifetime handling.

- driver.rs (29-439) propagates CleanupHandle through `SwitchJobOutcome`, spawns a bridge to wait for completion, and blocks `start_next_job` until done.
  Direct driver-side panics now schedule failure cleanup via the shared helper.

* tmp

* Revert "tmp"

This reverts commit e582cf4a65.

* refactor: queue frontend events through async dispatcher

* refactor: queue frontend switch/proxy events and throttle notices

* chore: frontend debug log

* fix: re-enable only ProfileSwitchFinished events - keep others suppressed for crash isolation

- Re-enabled only ProfileSwitchFinished events; RefreshClash, RefreshProxy, and ProfileChanged remain suppressed (they log suppression messages)
- Allows frontend to receive task completion notifications for UI feedback while crash isolation continues
- src-tauri/src/core/handle.rs now only suppresses notify_profile_changed
- Serialized emitter, frontend logging bridge, and other diagnostics unchanged

* refactor: refreshClashData

* refactor(proxy): stabilize proxy switch pipeline and rendering

- Add coalescing buffer in notification.rs to emit only the latest proxies-updated snapshot
- Replace nextTick with queueMicrotask in asyncQueue.ts for same-frame hydration
- Hide auto-generated GLOBAL snapshot and preserve optional metadata in proxy-snapshot.ts
- Introduce stable proxy rendering state in AppDataProvider (proxyTargetProfileId, proxyDisplayProfileId, isProxyRefreshPending)
- Update proxy page to fade content during refresh and overlay status banner instead of showing incomplete snapshot

* refactor(profiles): move manual activating logic to reducer for deterministic queue tracking

* refactor: replace proxy-data event bridge with pure polling and simplify proxy store

- Replaced the proxy-data event bridge with pure polling: AppDataProvider now fetches the initial snapshot and drives refreshes from the polled switchStatus, removing verge://refresh-* listeners (src/providers/app-data-provider.tsx).
- Simplified proxy-store by dropping the proxies-updated listener queue and unused payload/normalizer helpers; relies on SWR/provider fetch path + calcuProxies for live updates (src/stores/proxy-store.ts).
- Trimmed layout-level event wiring to keep only notice/show/hide subscriptions, removing obsolete refresh listeners (src/pages/_layout/useLayoutEvents.ts).

* refactor(proxy): streamline proxies-updated handling and store event flow

- AppDataProvider now treats `proxies-updated` as the fast path: the listener
  calls `applyLiveProxyPayload` immediately and schedules only a single fallback
  `fetchLiveProxies` ~600 ms later (replacing the old 0/250/1000/2000 cascade).
  Expensive provider/rule refreshes run in parallel via `Promise.allSettled`, and
  the multi-stage queue on profile updates completion was removed
  (src/providers/app-data-provider.tsx).

- Rebuilt proxy-store to support the event flow: restored `setLive`, provider
  normalization, and an animation-frame + async queue that applies payloads without
  blocking. Exposed `applyLiveProxyPayload` so providers can push events directly
  into the store (src/stores/proxy-store.ts).

* refactor: switch delay

* refactor(app-data-provider): trigger getProfileSwitchStatus revalidation on profile-switch-finished

- AppDataProvider now listens to `profile-switch-finished` and calls `mutate("getProfileSwitchStatus")` to immediately update state and unlock buttons (src/providers/app-data-provider.tsx).
- Retain existing detailed timing logs for monitoring other stages.
- Frontend success notifications remain instant; background refreshes continue asynchronously.

* fix(profiles): prevent duplicate toast on page remount

* refactor(profile-switch): make active switches preemptible and prevent queue piling

- Add notify mechanism to SwitchCancellation to await cancellation without busy-waiting (state.rs:82)
- Collapse pending queue to a single entry in the driver; cancel in-flight task on newer request (driver.rs:232)
- Update handle_update_core to watch cancel token and 30s timeout; release locks, discard draft, and exit early if canceled (state_machine.rs:301)
- Providers revalidate status immediately on profile-switch-finished events (app-data-provider.tsx:208)

* refactor(core): make core reload phase controllable, reduce 0xcfffffff risk

- CoreManager::apply_config now calls `reload_config_with_retry`, each attempt waits up to 5s, retries 3 times; on failure, returns error with duration logged and triggers core restart if needed (src-tauri/src/core/manager/config.rs:175, 205)
- `reload_config_with_retry` logs attempt info on timeout or error; if error is a Mihomo connection issue, fallback to original restart logic (src-tauri/src/core/manager/config.rs:211)
- `reload_config_once` retains original Mihomo call for retry wrapper usage (src-tauri/src/core/manager/config.rs:247)

* chore(frontend-logs): downgrade routine event logs from info to debug

- Logs like `emit_via_app entering spawn_blocking`, `Async emit…`, `Buffered proxies…` are now debug-level (src-tauri/src/core/notification.rs:155, :265, :309…)
- Genuine warnings/errors (failures/timeouts) remain at warn/error
- Core stage logs remain info to keep backend tracking visible

* refactor(frontend-emit): make emit_via_app fire-and-forget async

- `emit_via_app` now a regular function; spawns with `tokio::spawn` and logs a warn if `emit_to` fails, caller returns immediately (src-tauri/src/core/notification.rs:269)
- Removed `.await` at Async emit and flush_proxies calls; only record dispatch duration and warn on failure (src-tauri/src/core/notification.rs:211, :329)

* refactor(ui): restructure profile switch for event-driven speed + polling stability

- Backend
  - SwitchManager maintains a lightweight event queue: added `event_sequence`, `recent_events`, and `SwitchResultEvent`; provides `push_event` / `events_after` (state.rs)
  - `handle_completion` pushes events on success/failure and keeps `last_result` (driver.rs) for frontend incremental fetch
  - New Tauri command `get_profile_switch_events(after_sequence)` exposes `events_after` (profile_switch/mod.rs → profile.rs → lib.rs)
- Notification system
  - `NotificationSystem::process_event` only logs debug, disables WebView `emit_to`, fixes 0xcfffffff
  - Related emit/buffer functions now safe no-op, removed unused structures and warnings (notification.rs)
- Frontend
  - services/cmds.ts defines `SwitchResultEvent` and `getProfileSwitchEvents`
  - `AppDataProvider` holds `switchEventSeqRef`, polls incremental events every 0.25s (busy) / 1s (idle); each event triggers:
      - immediate `globalMutate("getProfiles")` to refresh current profile
      - background refresh of proxies/providers/rules via `Promise.allSettled` (failures logged, non-blocking)
      - forced `mutateSwitchStatus` to correct state
  - original switchStatus effect calls `handleSwitchResult` as fallback; other toast/activation logic handled in profiles.tsx
- Commands / API cleanup
  - removed `pub use profile_switch::*;` in cmd::mod.rs to avoid conflicts; frontend uses new command polling

* refactor(frontend): optimize profile switch with optimistic updates

* refactor(profile-switch): switch to event-driven flow with Profile Store

- SwitchManager pushes events; frontend polls get_profile_switch_events
- Zustand store handles optimistic profiles; AppDataProvider applies updates and background-fetches
- UI flicker removed

* fix(app-data): re-hook profile store updates during switch hydration

* fix(notification): restore frontend event dispatch and non-blocking emits

* fix(app-data-provider): restore proxy refresh and seed snapshot after refactor

* fix: ensure switch completion events are received and handle proxies-updated

* fix(app-data-provider): dedupe switch results by taskId and fix stale profile state

* fix(profile-switch): ensure patch_profiles_config_by_profile_index waits for real completion and handle join failures in apply_config_with_timeout

* docs: UPDATELOG.md

* chore: add necessary comments

* fix(core): always dispatch async proxy snapshot after RefreshClash event

* fix(proxy-store, provider): handle pending snapshots and proxy profiles

- Added pending snapshot tracking in proxy-store so `lastAppliedFetchId` no longer jumps on seed. Profile adoption is deferred until a qualifying fetch completes. Exposed `clearPendingProfile` for rollback support.
- Cleared pending snapshot state whenever live payloads apply or the store resets, preventing stale optimistic profile IDs after failures.
- In provider integration, subscribed to the pending proxy profile and fed it into target-profile derivation. Cleared it on failed switch results so hydration can advance and UI status remains accurate.

* fix(proxy): re-hook tray refresh events into proxy refresh queue

- Reattached listen("verge://refresh-proxy-config", …) at src/providers/app-data-provider.tsx:402 and registered it for cleanup.
- Added matching window fallback handler at src/providers/app-data-provider.tsx:430 so in-app dispatches share the same refresh path.

* fix(proxy-snapshot/proxy-groups): address review findings on snapshot placeholders

- src/utils/proxy-snapshot.ts:72-95 now derives snapshot group members solely from proxy-groups.proxies, so provider ids under `use` no longer generate placeholder proxy items.
- src/components/proxy/proxy-groups.tsx:665-677 lets the hydration overlay capture pointer events (and shows a wait cursor) so users can’t interact with snapshot-only placeholders before live data is ready.

* fix(profile-switch): preserve queued requests and avoid stale connection teardown

- Keep earlier queued switches intact by dropping the blanket “collapse” call: after removing duplicates for the same profile, new requests are simply appended, leaving other profiles pending (driver.rs:376). Resolves queue-loss scenario.
- Gate connection cleanup on real successes so cancelled/stale runs no longer tear down Mihomo connections; success handler now skips close_connections_after_switch when success == false (workflow.rs:419).

* fix(profile-switch, layout): improve profile validation and restore backend refresh

- Hardened profile validation using `tokio::fs` with a 5s timeout and offloading YAML parsing to `AsyncHandler::spawn_blocking`, preventing slow disks or malformed files from freezing the runtime (src-tauri/src/cmd/profile_switch/validation.rs:9, 71).
- Restored backend-triggered refresh handling by listening for `verge://refresh-clash-config` / `verge://refresh-verge-config` and invoking shared refresh services so SWR caches stay in sync with core events (src/pages/_layout/useLayoutEvents.ts:6, 45, 55).

* feat(profile-switch): handle cancellations for superseded requests

- Added a `cancelled` flag and constructor so superseded requests publish an explicit cancellation instead of a failure (src-tauri/src/cmd/profile_switch/state.rs:249, src-tauri/src/cmd/profile_switch/driver.rs:482)
- Updated the profile switch effect to log cancellations as info, retain the shared `mutate` call, and skip emitting error toasts while still refreshing follow-up work (src/pages/profiles.tsx:554, src/pages/profiles.tsx:581)
- Exposed the new flag on the TypeScript contract to keep downstream consumers type-safe (src/services/cmds.ts:20)

* fix(profiles): wrap logging payload for Tauri frontend_log

* fix(profile-switch): add rollback and error propagation for failed persistence

- Added rollback on apply failure so Mihomo restores to the previous profile
  before exiting the success path early (state_machine.rs:474).
- Reworked persist_profiles_with_timeout to surface timeout/join/save errors,
  convert them into CmdResult failures, and trigger rollback + error propagation
  when persistence fails (state_machine.rs:703).

* fix(profile-switch): prevent mid-finalize reentrancy and lingering tasks

* fix(profile-switch): preserve pending queue and surface discarded switches

* fix(profile-switch): avoid draining Mihomo sockets on failed/cancelled switches

* fix(app-data-provider): restore backend-driven refresh and reattach fallbacks

* fix(profile-switch): queue concurrent updates and add bounded wait/backoff

* fix(proxy): trigger live refresh on app start for proxy snapshot

* refactor(profile-switch): split flow into layers and centralize async cleanup

- Introduced `SwitchDriver` to encapsulate queue and driver logic while keeping the public Tauri command API.
- Added workflow/cleanup helpers for notification dispatch and Mihomo connection draining, re-exported for API consistency.
- Replaced monolithic state machine with `core.rs`, `context.rs`, and `stages.rs`, plus a thin `mod.rs` re-export layer; stage methods are now individually testable.
- Removed legacy `workflow/state_machine.rs` and adjusted visibility on re-exported types/constants to ensure compilation.
This commit is contained in:
Sline
2025-10-30 17:29:15 +08:00
committed by GitHub
parent af79bcd1cf
commit c2dcd86722
36 changed files with 5912 additions and 1275 deletions
+8 -1
View File
@@ -6,8 +6,15 @@ import {
RuleProvider,
} from "tauri-plugin-mihomo-api";
import { ProxiesView, type ProfileSwitchStatus } from "@/services/cmds";
export interface AppDataContextType {
proxies: any;
proxies: ProxiesView | null;
proxyHydration: "none" | "snapshot" | "live";
proxyTargetProfileId: string | null;
proxyDisplayProfileId: string | null;
isProxyRefreshPending: boolean;
switchStatus: ProfileSwitchStatus | null;
clashConfig: BaseConfig;
rules: Rule[];
sysproxy: any;
+593 -150
View File
@@ -1,6 +1,6 @@
import { listen } from "@tauri-apps/api/event";
import React, { useCallback, useEffect, useMemo } from "react";
import useSWR from "swr";
import React, { useCallback, useEffect, useMemo, useRef } from "react";
import useSWR, { mutate as globalMutate } from "swr";
import {
getBaseConfig,
getRuleProviders,
@@ -9,31 +9,53 @@ import {
import { useVerge } from "@/hooks/use-verge";
import {
calcuProxies,
calcuProxyProviders,
getAppUptime,
getProfileSwitchStatus,
getProfileSwitchEvents,
getProfiles as fetchProfilesConfig,
getRunningMode,
readProfileFile,
getSystemProxy,
type ProxiesView,
type ProfileSwitchStatus,
type SwitchResultStatus,
} from "@/services/cmds";
import { SWR_DEFAULTS, SWR_REALTIME, SWR_SLOW_POLL } from "@/services/config";
import { SWR_DEFAULTS, SWR_SLOW_POLL } from "@/services/config";
import { useProfileStore } from "@/stores/profile-store";
import {
applyLiveProxyPayload,
fetchLiveProxies,
type ProxiesUpdatedPayload,
useProxyStore,
} from "@/stores/proxy-store";
import { createProxySnapshotFromProfile } from "@/utils/proxy-snapshot";
import { AppDataContext, AppDataContextType } from "./app-data-context";
// 全局数据提供者组件
// Global app data provider
export const AppDataProvider = ({
children,
}: {
children: React.ReactNode;
}) => {
const { verge } = useVerge();
const { data: proxiesData, mutate: refreshProxy } = useSWR(
"getProxies",
calcuProxies,
{
...SWR_REALTIME,
onError: (err) => console.warn("[DataProvider] Proxy fetch failed:", err),
},
const applyProfileSwitchResult = useProfileStore(
(state) => state.applySwitchResult,
);
const commitProfileSnapshot = useProfileStore(
(state) => state.commitHydrated,
);
const setSwitchEventSeq = useProfileStore((state) => state.setLastEventSeq);
const proxyView = useProxyStore((state) => state.data);
const proxyHydration = useProxyStore((state) => state.hydration);
const proxyProfileId = useProxyStore((state) => state.lastProfileId);
const pendingProxyProfileId = useProxyStore(
(state) => state.pendingProfileId,
);
const setProxySnapshot = useProxyStore((state) => state.setSnapshot);
const clearPendingProxyProfile = useProxyStore(
(state) => state.clearPendingProfile,
);
const { data: clashConfig, mutate: refreshClashConfig } = useSWR(
@@ -60,25 +82,259 @@ export const AppDataProvider = ({
SWR_DEFAULTS,
);
useEffect(() => {
let lastProfileId: string | null = null;
let lastUpdateTime = 0;
const refreshThrottle = 800;
const { data: switchStatus, mutate: mutateSwitchStatus } =
useSWR<ProfileSwitchStatus>(
"getProfileSwitchStatus",
getProfileSwitchStatus,
{
refreshInterval: (status) =>
status && (status.isSwitching || (status.queue?.length ?? 0) > 0)
? 400
: 4000,
dedupingInterval: 200,
},
);
let isUnmounted = false;
const scheduledTimeouts = new Set<number>();
const isUnmountedRef = useRef(false);
// Keep track of pending timers so we can cancel them on unmount and avoid stray updates.
const scheduledTimeoutsRef = useRef<Set<number>>(new Set());
// Shared metadata to dedupe switch events coming from both polling and subscriptions.
const switchMetaRef = useRef<{
pendingProfileId: string | null;
lastResultTaskId: number | null;
}>({
pendingProfileId: null,
lastResultTaskId: null,
});
const switchEventSeqRef = useRef(0);
const profileChangeMetaRef = useRef<{
lastProfileId: string | null;
lastEventTs: number;
}>({
lastProfileId: null,
lastEventTs: 0,
});
const lastClashRefreshAtRef = useRef(0);
const PROFILE_EVENT_DEDUP_MS = 400;
const CLASH_REFRESH_DEDUP_MS = 300;
// Thin wrapper around setTimeout that no-ops once the provider unmounts.
const scheduleTimeout = useCallback(
(callback: () => void | Promise<void>, delay: number) => {
if (isUnmountedRef.current) return -1;
const timeoutId = window.setTimeout(() => {
scheduledTimeoutsRef.current.delete(timeoutId);
if (!isUnmountedRef.current) {
void callback();
}
}, delay);
scheduledTimeoutsRef.current.add(timeoutId);
return timeoutId;
},
[],
);
const clearAllTimeouts = useCallback(() => {
scheduledTimeoutsRef.current.forEach((timeoutId) =>
clearTimeout(timeoutId),
);
scheduledTimeoutsRef.current.clear();
}, []);
// Delay live proxy refreshes slightly so we don't hammer Mihomo while a switch is still applying.
const queueProxyRefresh = useCallback(
(reason: string, delay = 1500) => {
scheduleTimeout(() => {
fetchLiveProxies().catch((error) =>
console.warn(
`[DataProvider] Proxy refresh failed (${reason}, fallback):`,
error,
),
);
}, delay);
},
[scheduleTimeout],
);
// Prime the proxy store with the static selections from the profile YAML before live data arrives.
const seedProxySnapshot = useCallback(
async (profileId: string) => {
if (!profileId) return;
try {
const yamlContent = await readProfileFile(profileId);
const snapshot = createProxySnapshotFromProfile(yamlContent);
if (!snapshot) return;
setProxySnapshot(snapshot, profileId);
} catch (error) {
console.warn(
"[DataProvider] Failed to seed proxy snapshot from profile:",
error,
);
}
},
[setProxySnapshot],
);
const handleSwitchResult = useCallback(
(result: SwitchResultStatus) => {
// Ignore duplicate notifications for the same switch execution.
const meta = switchMetaRef.current;
if (result.taskId === meta.lastResultTaskId) {
return;
}
meta.lastResultTaskId = result.taskId;
// Optimistically update the SWR cache so the UI shows the new profile immediately.
void globalMutate(
"getProfiles",
(current?: IProfilesConfig | null) => {
if (!current || !result.success) {
return current;
}
if (current.current === result.profileId) {
return current;
}
return {
...current,
current: result.profileId,
};
},
false,
);
applyProfileSwitchResult(result);
if (!result.success) {
clearPendingProxyProfile();
}
if (result.success && result.cancelled !== true) {
// Once the backend settles, refresh all dependent data in the background.
scheduleTimeout(() => {
void Promise.allSettled([
fetchProfilesConfig().then((data) => {
commitProfileSnapshot(data);
globalMutate("getProfiles", data, false);
}),
fetchLiveProxies(),
refreshProxyProviders(),
refreshRules(),
refreshRuleProviders(),
]).catch((error) => {
console.warn(
"[DataProvider] Background refresh after profile switch failed:",
error,
);
});
}, 100);
}
void mutateSwitchStatus((current) => {
if (!current) {
return current;
}
const filteredQueue = current.queue.filter(
(task) => task.taskId !== result.taskId,
);
const active =
current.active && current.active.taskId === result.taskId
? null
: current.active;
const isSwitching = filteredQueue.length > 0;
return {
...current,
active,
queue: filteredQueue,
isSwitching,
lastResult: result,
};
}, false);
},
[
scheduleTimeout,
refreshProxyProviders,
refreshRules,
refreshRuleProviders,
mutateSwitchStatus,
applyProfileSwitchResult,
commitProfileSnapshot,
clearPendingProxyProfile,
],
);
useEffect(() => {
isUnmountedRef.current = false;
return () => {
isUnmountedRef.current = true;
clearAllTimeouts();
};
}, [clearAllTimeouts]);
useEffect(() => {
if (!switchStatus) {
return;
}
const meta = switchMetaRef.current;
const nextTarget =
switchStatus.active?.profileId ??
(switchStatus.queue.length > 0 ? switchStatus.queue[0].profileId : null);
if (nextTarget && nextTarget !== meta.pendingProfileId) {
meta.pendingProfileId = nextTarget;
void seedProxySnapshot(nextTarget);
} else if (!nextTarget) {
meta.pendingProfileId = null;
}
const lastResult = switchStatus.lastResult ?? null;
if (lastResult) {
handleSwitchResult(lastResult);
}
}, [switchStatus, seedProxySnapshot, handleSwitchResult]);
useEffect(() => {
let disposed = false;
const pollEvents = async () => {
if (disposed) {
return;
}
try {
const events = await getProfileSwitchEvents(switchEventSeqRef.current);
if (events.length > 0) {
switchEventSeqRef.current = events[events.length - 1].sequence;
setSwitchEventSeq(switchEventSeqRef.current);
events.forEach((event) => handleSwitchResult(event.result));
}
} catch (error) {
console.warn("[DataProvider] Failed to poll switch events:", error);
} finally {
if (!disposed) {
const nextDelay =
switchStatus &&
(switchStatus.isSwitching || (switchStatus.queue?.length ?? 0) > 0)
? 250
: 1000;
scheduleTimeout(pollEvents, nextDelay);
}
}
};
scheduleTimeout(pollEvents, 0);
return () => {
disposed = true;
};
}, [scheduleTimeout, handleSwitchResult, switchStatus, setSwitchEventSeq]);
useEffect(() => {
const cleanupFns: Array<() => void> = [];
const registerCleanup = (fn: () => void) => {
if (isUnmounted) {
try {
fn();
} catch (error) {
console.error("[DataProvider] Immediate cleanup failed:", error);
}
} else {
cleanupFns.push(fn);
}
cleanupFns.push(fn);
};
const addWindowListener = (eventName: string, handler: EventListener) => {
@@ -87,140 +343,319 @@ export const AppDataProvider = ({
return () => window.removeEventListener(eventName, handler);
};
const scheduleTimeout = (
callback: () => void | Promise<void>,
delay: number,
const runProfileChangedPipeline = (
profileId: string | null,
source: "tauri" | "window",
) => {
if (isUnmounted) return -1;
const timeoutId = window.setTimeout(() => {
scheduledTimeouts.delete(timeoutId);
if (!isUnmounted) {
void callback();
}
}, delay);
scheduledTimeouts.add(timeoutId);
return timeoutId;
};
const clearAllTimeouts = () => {
scheduledTimeouts.forEach((timeoutId) => clearTimeout(timeoutId));
scheduledTimeouts.clear();
};
const handleProfileChanged = (event: { payload: string }) => {
const newProfileId = event.payload;
const now = Date.now();
const meta = profileChangeMetaRef.current;
if (
lastProfileId === newProfileId &&
now - lastUpdateTime < refreshThrottle
meta.lastProfileId === profileId &&
now - meta.lastEventTs < PROFILE_EVENT_DEDUP_MS
) {
return;
}
lastProfileId = newProfileId;
lastUpdateTime = now;
meta.lastProfileId = profileId;
meta.lastEventTs = now;
scheduleTimeout(() => {
refreshRules().catch((error) =>
console.warn("[DataProvider] Rules refresh failed:", error),
);
refreshRuleProviders().catch((error) =>
console.warn("[DataProvider] Rule providers refresh failed:", error),
);
}, 200);
};
const handleRefreshClash = () => {
const now = Date.now();
if (now - lastUpdateTime <= refreshThrottle) return;
lastUpdateTime = now;
scheduleTimeout(() => {
refreshProxy().catch((error) =>
console.error("[DataProvider] Proxy refresh failed:", error),
);
}, 200);
};
const handleRefreshProxy = () => {
const now = Date.now();
if (now - lastUpdateTime <= refreshThrottle) return;
lastUpdateTime = now;
scheduleTimeout(() => {
refreshProxy().catch((error) =>
console.warn("[DataProvider] Proxy refresh failed:", error),
);
}, 200);
};
const initializeListeners = async () => {
try {
const unlistenProfile = await listen<string>(
"profile-changed",
handleProfileChanged,
);
registerCleanup(unlistenProfile);
} catch (error) {
console.error("[AppDataProvider] 监听 Profile 事件失败:", error);
if (profileId) {
void seedProxySnapshot(profileId);
}
try {
const unlistenClash = await listen(
"verge://refresh-clash-config",
handleRefreshClash,
queueProxyRefresh(`profile-changed-${source}`, 500);
scheduleTimeout(() => {
void fetchProfilesConfig()
.then((data) => {
commitProfileSnapshot(data);
globalMutate("getProfiles", data, false);
})
.catch((error) =>
console.warn(
"[AppDataProvider] Failed to refresh profiles after profile change:",
error,
),
);
void refreshProxyProviders().catch((error) =>
console.warn(
"[AppDataProvider] Proxy providers refresh failed after profile change:",
error,
),
);
const unlistenProxy = await listen(
"verge://refresh-proxy-config",
handleRefreshProxy,
void refreshRules().catch((error) =>
console.warn(
"[AppDataProvider] Rules refresh failed after profile change:",
error,
),
);
void refreshRuleProviders().catch((error) =>
console.warn(
"[AppDataProvider] Rule providers refresh failed after profile change:",
error,
),
);
}, 200);
};
registerCleanup(() => {
unlistenClash();
unlistenProxy();
});
} catch (error) {
console.warn("[AppDataProvider] 设置 Tauri 事件监听器失败:", error);
const handleProfileChanged = (event: { payload: string }) => {
runProfileChangedPipeline(event.payload ?? null, "tauri");
};
const fallbackHandlers: Array<[string, EventListener]> = [
["verge://refresh-clash-config", handleRefreshClash],
["verge://refresh-proxy-config", handleRefreshProxy],
];
const runRefreshClashPipeline = (source: "tauri" | "window") => {
const now = Date.now();
if (now - lastClashRefreshAtRef.current < CLASH_REFRESH_DEDUP_MS) {
return;
}
fallbackHandlers.forEach(([eventName, handler]) => {
registerCleanup(addWindowListener(eventName, handler));
});
lastClashRefreshAtRef.current = now;
scheduleTimeout(() => {
void refreshClashConfig().catch((error) =>
console.warn(
"[AppDataProvider] Clash config refresh failed after backend update:",
error,
),
);
void refreshRules().catch((error) =>
console.warn(
"[AppDataProvider] Rules refresh failed after backend update:",
error,
),
);
void refreshRuleProviders().catch((error) =>
console.warn(
"[AppDataProvider] Rule providers refresh failed after backend update:",
error,
),
);
void refreshProxyProviders().catch((error) =>
console.warn(
"[AppDataProvider] Proxy providers refresh failed after backend update:",
error,
),
);
}, 0);
queueProxyRefresh(`refresh-clash-config-${source}`, 400);
};
const handleProfileUpdateCompleted = (_: { payload: { uid: string } }) => {
queueProxyRefresh("profile-update-completed", 3000);
if (!isUnmountedRef.current) {
scheduleTimeout(() => {
void refreshProxyProviders().catch((error) =>
console.warn(
"[DataProvider] Proxy providers refresh failed after profile update completed:",
error,
),
);
}, 0);
}
};
void initializeListeners();
const isProxiesPayload = (
value: unknown,
): value is ProxiesUpdatedPayload => {
if (!value || typeof value !== "object") {
return false;
}
const candidate = value as Partial<ProxiesUpdatedPayload>;
return candidate.proxies !== undefined && candidate.proxies !== null;
};
const handleProxiesUpdatedPayload = (
rawPayload: unknown,
source: "tauri" | "window",
) => {
if (!isProxiesPayload(rawPayload)) {
console.warn(
`[AppDataProvider] Ignored ${source} proxies-updated payload`,
rawPayload,
);
queueProxyRefresh(`proxies-updated-${source}-invalid`, 500);
return;
}
try {
applyLiveProxyPayload(rawPayload);
} catch (error) {
console.warn(
`[AppDataProvider] Failed to apply ${source} proxies-updated payload`,
error,
);
queueProxyRefresh(`proxies-updated-${source}-apply-failed`, 500);
}
};
listen<{ uid: string }>(
"profile-update-completed",
handleProfileUpdateCompleted,
)
.then(registerCleanup)
.catch((error) =>
console.error(
"[AppDataProvider] failed to attach profile update listeners:",
error,
),
);
listen<string>("profile-changed", handleProfileChanged)
.then(registerCleanup)
.catch((error) =>
console.error(
"[AppDataProvider] failed to attach profile-changed listener:",
error,
),
);
listen<ProxiesUpdatedPayload>("proxies-updated", (event) => {
handleProxiesUpdatedPayload(event.payload, "tauri");
})
.then(registerCleanup)
.catch((error) =>
console.error(
"[AppDataProvider] failed to attach proxies-updated listener:",
error,
),
);
listen("verge://refresh-clash-config", () => {
runRefreshClashPipeline("tauri");
})
.then(registerCleanup)
.catch((error) =>
console.error(
"[AppDataProvider] failed to attach refresh-clash-config listener:",
error,
),
);
listen("verge://refresh-proxy-config", () => {
queueProxyRefresh("refresh-proxy-config-tauri", 500);
})
.then(registerCleanup)
.catch((error) =>
console.error(
"[AppDataProvider] failed to attach refresh-proxy-config listener:",
error,
),
);
const fallbackHandlers: Array<[string, EventListener]> = [
[
"profile-update-completed",
((event: Event) => {
const payload = (event as CustomEvent<{ uid: string }>).detail ?? {
uid: "",
};
handleProfileUpdateCompleted({ payload });
}) as EventListener,
],
[
"profile-changed",
((event: Event) => {
const payload = (event as CustomEvent<string | null>).detail ?? null;
runProfileChangedPipeline(payload, "window");
}) as EventListener,
],
[
"proxies-updated",
((event: Event) => {
const payload = (event as CustomEvent<ProxiesUpdatedPayload>).detail;
handleProxiesUpdatedPayload(payload, "window");
}) as EventListener,
],
[
"verge://refresh-clash-config",
(() => {
runRefreshClashPipeline("window");
}) as EventListener,
],
[
"verge://refresh-proxy-config",
(() => {
queueProxyRefresh("refresh-proxy-config-window", 500);
}) as EventListener,
],
];
fallbackHandlers.forEach(([eventName, handler]) => {
registerCleanup(addWindowListener(eventName, handler));
});
return () => {
isUnmounted = true;
clearAllTimeouts();
const errors: Error[] = [];
cleanupFns.splice(0).forEach((fn) => {
cleanupFns.forEach((fn) => {
try {
fn();
} catch (error) {
errors.push(
error instanceof Error ? error : new Error(String(error)),
);
console.error("[AppDataProvider] cleanup error:", error);
}
});
if (errors.length > 0) {
console.error(
`[DataProvider] ${errors.length} errors during cleanup:`,
errors,
);
}
};
}, [refreshProxy, refreshRules, refreshRuleProviders]);
}, [
commitProfileSnapshot,
queueProxyRefresh,
refreshClashConfig,
refreshProxyProviders,
refreshRuleProviders,
refreshRules,
scheduleTimeout,
seedProxySnapshot,
]);
const switchTargetProfileId =
switchStatus?.active?.profileId ??
(switchStatus && switchStatus.queue.length > 0
? switchStatus.queue[0].profileId
: null);
const proxyTargetProfileId =
switchTargetProfileId ?? pendingProxyProfileId ?? proxyProfileId ?? null;
const displayProxyStateRef = useRef<{
view: ProxiesView | null;
profileId: string | null;
}>({
view: proxyView,
profileId: proxyTargetProfileId,
});
const currentDisplay = displayProxyStateRef.current;
if (!proxyView) {
if (
currentDisplay.view !== null ||
currentDisplay.profileId !== proxyTargetProfileId
) {
displayProxyStateRef.current = {
view: null,
profileId: proxyTargetProfileId,
};
}
} else if (proxyHydration === "live") {
if (
currentDisplay.view !== proxyView ||
currentDisplay.profileId !== proxyTargetProfileId
) {
displayProxyStateRef.current = {
view: proxyView,
profileId: proxyTargetProfileId,
};
}
} else if (!currentDisplay.view) {
displayProxyStateRef.current = {
view: proxyView,
profileId: proxyTargetProfileId,
};
}
const displayProxyState = displayProxyStateRef.current;
const proxyDisplayProfileId = displayProxyState.profileId;
const proxiesForRender = displayProxyState.view ?? proxyView;
const isProxyRefreshPending =
(switchStatus?.isSwitching ?? false) ||
proxyHydration !== "live" ||
proxyTargetProfileId !== proxyDisplayProfileId;
const { data: sysproxy, mutate: refreshSysproxy } = useSWR(
"getSystemProxy",
@@ -240,10 +675,10 @@ export const AppDataProvider = ({
errorRetryCount: 1,
});
// 提供统一的刷新方法
// Provide unified refresh method
const refreshAll = useCallback(async () => {
await Promise.all([
refreshProxy(),
fetchLiveProxies(),
refreshClashConfig(),
refreshRules(),
refreshSysproxy(),
@@ -251,7 +686,6 @@ export const AppDataProvider = ({
refreshRuleProviders(),
]);
}, [
refreshProxy,
refreshClashConfig,
refreshRules,
refreshSysproxy,
@@ -259,22 +693,22 @@ export const AppDataProvider = ({
refreshRuleProviders,
]);
// 聚合所有数据
// Aggregate data into context value
const value = useMemo(() => {
// 计算系统代理地址
// Compute the system proxy address
const calculateSystemProxyAddress = () => {
if (!verge || !clashConfig) return "-";
const isPacMode = verge.proxy_auto_config ?? false;
if (isPacMode) {
// PAC模式:显示我们期望设置的代理地址
// PAC mode: display the desired proxy address
const proxyHost = verge.proxy_host || "127.0.0.1";
const proxyPort =
verge.verge_mixed_port || clashConfig.mixedPort || 7897;
return `${proxyHost}:${proxyPort}`;
} else {
// HTTP代理模式:优先使用系统地址,但如果格式不正确则使用期望地址
// HTTP proxy mode: prefer system address, fallback to desired address if invalid
const systemServer = sysproxy?.server;
if (
systemServer &&
@@ -283,7 +717,7 @@ export const AppDataProvider = ({
) {
return systemServer;
} else {
// 系统地址无效,返回期望的代理地址
// System address invalid: fallback to desired proxy address
const proxyHost = verge.proxy_host || "127.0.0.1";
const proxyPort =
verge.verge_mixed_port || clashConfig.mixedPort || 7897;
@@ -293,22 +727,27 @@ export const AppDataProvider = ({
};
return {
// 数据
proxies: proxiesData,
// Data
proxies: proxiesForRender,
proxyHydration,
proxyTargetProfileId,
proxyDisplayProfileId,
isProxyRefreshPending,
switchStatus: switchStatus ?? null,
clashConfig,
rules: rulesData?.rules || [],
sysproxy,
runningMode,
uptime: uptimeData || 0,
// 提供者数据
// Provider data
proxyProviders: proxyProviders || {},
ruleProviders: ruleProviders?.providers || {},
systemProxyAddress: calculateSystemProxyAddress(),
// 刷新方法
refreshProxy,
// Refresh helpers
refreshProxy: fetchLiveProxies,
refreshClashConfig,
refreshRules,
refreshSysproxy,
@@ -317,7 +756,12 @@ export const AppDataProvider = ({
refreshAll,
} as AppDataContextType;
}, [
proxiesData,
proxiesForRender,
proxyHydration,
proxyTargetProfileId,
proxyDisplayProfileId,
isProxyRefreshPending,
switchStatus,
clashConfig,
rulesData,
sysproxy,
@@ -326,7 +770,6 @@ export const AppDataProvider = ({
proxyProviders,
ruleProviders,
verge,
refreshProxy,
refreshClashConfig,
refreshRules,
refreshSysproxy,