src/monitor.rs - master - pushamp/PACman

src/monitor.rs
71 строка3 KB
Dmitry Zhiltsov
feat(core): Init commit
19 фев 2026, 18:01
19 фев 2026, 18:011fadda9
use crate::settings::SharedConfig;
use std::sync::atomic::{AtomicBool, Ordering};
use std::time::Duration;

#[derive(Debug, Clone, Copy, PartialEq)]
pub struct VpnState {
    pub connected: bool,
}

static HAD_ERROR: AtomicBool = AtomicBool::new(false);

pub fn had_error() -> bool {
    HAD_ERROR.load(Ordering::Relaxed)
}

pub fn start_monitor<F>(config: SharedConfig, state_callback: F)
where
    F: Fn(VpnState) + Send + 'static,
{
    std::thread::Builder::new()
        .name("vpn-monitor".into())
        .spawn(move || {
            let mut prev_connected: Option<bool> = None;

            loop {
                let (interface, service, interval) = {
                    let cfg = config.read().unwrap();
                    (
                        cfg.vpn_interface.clone(),
                        cfg.network_service.clone(),
                        cfg.poll_interval_secs,
                    )
                };

                let connected = crate::proxy::check_vpn_interface(&interface);

                if prev_connected != Some(connected) {
                    if connected {
                        crate::logging::log_default(&format!(
                            "VPN interface {interface} detected"
                        ));
                        let pac_port = crate::pac_server::actual_port();
                        let pac_url = crate::pac_url(pac_port);
                        match crate::proxy::enable_proxy(&service, &pac_url) {
                            Ok(()) => HAD_ERROR.store(false, Ordering::Relaxed),
                            Err(e) => {
                                crate::logging::log_error(&format!("Enable proxy failed: {e}"));
                                HAD_ERROR.store(true, Ordering::Relaxed);
                            }
                        }
                    } else {
                        crate::logging::log_default(&format!(
                            "VPN interface {interface} gone"
                        ));
                        match crate::proxy::disable_proxy(&service) {
                            Ok(()) => HAD_ERROR.store(false, Ordering::Relaxed),
                            Err(e) => {
                                crate::logging::log_error(&format!("Disable proxy failed: {e}"));
                                HAD_ERROR.store(true, Ordering::Relaxed);
                            }
                        }
                    }
                    prev_connected = Some(connected);
                    state_callback(VpnState { connected });
                }

                std::thread::sleep(Duration::from_secs(interval));
            }
        })
        .expect("Failed to spawn monitor thread");
}