ntex-server 3.10.1

use std::{cell::RefCell, sync::Mutex, thread};

use ntex_rt::System;

use crate::server::Server;

thread_local! {
    static HANDLERS: RefCell<Vec<oneshot::Sender<Signal>>> = RefCell::default();
}

type CB = Box<dyn Fn(Signal) + Send>;
static CUR_SYS: Mutex<RefCell<Option<(System, CB)>>> = Mutex::new(RefCell::new(None));

/// Different types of process signals
#[derive(PartialEq, Eq, Clone, Copy, Debug)]
pub enum Signal {
    /// SIGUSR1
    Usr1,
    /// SIGHUP
    Hup,
    /// SIGINT
    Int,
    /// SIGTERM
    Term,
    /// SIGQUIT
    Quit,
}

/// Register signal handler.
pub fn signal() -> oneshot::Receiver<Signal> {
    let (tx, rx) = oneshot::channel();
    System::current().handle().spawn(async move {
        HANDLERS.with(|handlers| {
            handlers.borrow_mut().push(tx);
        });
    });

    rx
}

fn register_system<T: Send + 'static>(srv: Server<T>) -> bool {
    let Ok(guard) = CUR_SYS.lock() else {
        log::error!("Cannot lock mutex");
        return true;
    };

    let mut sys = guard.borrow_mut();
    let started = sys.is_some();
    *sys = Some((System::current(), Box::new(move |sig| srv.signal(sig))));
    started
}

fn handle_signal(sig: Signal) {
    if let Ok(guard) = CUR_SYS.lock()
        && let Some((sys, srv)) = &*guard.borrow()
    {
        (*srv)(sig);
        sys.handle().spawn(async move {
            HANDLERS.with(|handlers| {
                for tx in handlers.borrow_mut().drain(..) {
                    let _ = tx.send(sig);
                }
            });
        });
    }
}

#[cfg(target_family = "unix")]
/// Register signal handler.
///
/// Signals are handled by oneshots, you have to re-register
/// after each signal.
pub(crate) fn start<T: Send + 'static>(srv: Server<T>) {
    if !register_system(srv) {
        let _ = thread::Builder::new()
            .name("ntex-server signals".to_string())
            .spawn(move || {
                use signal_hook::consts::signal::{SIGHUP, SIGINT, SIGQUIT, SIGTERM};
                use signal_hook::iterator::Signals;

                let sigs = vec![SIGHUP, SIGINT, SIGTERM, SIGQUIT];
                let mut signals = match Signals::new(sigs) {
                    Ok(signals) => signals,
                    Err(e) => {
                        log::error!("Cannot initialize signals handler: {e}");
                        return;
                    }
                };
                for info in &mut signals {
                    let sig = match info {
                        SIGUSR1 => Signal::Usr1,
                        SIGHUP => Signal::Hup,
                        SIGTERM => Signal::Term,
                        SIGINT => Signal::Int,
                        SIGQUIT => Signal::Quit,
                        _ => continue,
                    };
                    handle_signal(sig);

                    if matches!(sig, Signal::Int | Signal::Quit) {
                        return;
                    }
                }
            });
    }
}

#[cfg(target_family = "windows")]
/// Register signal handler.
///
/// Signals are handled by oneshots, you have to re-register
/// after each signal.
pub(crate) fn start<T: Send + 'static>(srv: Server<T>) {
    if !register_system(srv) {
        let _ = thread::Builder::new()
            .name("ntex-server signals".to_string())
            .spawn(move || {
                ctrlc::set_handler(|| handle_signal(Signal::Int))
                    .expect("Error setting Ctrl-C handler");
            });
    }
}