trifid/tfclient/src/timerworker.rs

use std::ops::Add;
use std::sync::mpsc::{Receiver, TryRecvError};
use std::thread;
use std::time::{Duration, SystemTime};
use log::{error, info};
use crate::apiworker::APIWorkerMessage;
use crate::daemon::ThreadMessageSender;
use crate::nebulaworker::NebulaWorkerMessage;
use crate::socketworker::SocketWorkerMessage;

pub enum TimerWorkerMessage {
    Shutdown
}

pub fn timer_main(tx: ThreadMessageSender, rx: Receiver<TimerWorkerMessage>) {
    let mut api_reload_timer = SystemTime::now().add(Duration::from_secs(60));

    loop {
        thread::sleep(Duration::from_secs(10));

        match rx.try_recv() {
            Ok(msg) => {
                match msg {
                    TimerWorkerMessage::Shutdown => {
                        info!("recv on command socket: shutdown, stopping");
                        break;
                    }
                }
            },
            Err(e) => {
                match e {
                    TryRecvError::Empty => {}
                    TryRecvError::Disconnected => {
                        error!("timerworker command socket disconnected, shutting down to prevent orphaning");
                        break;
                    }
                }
            }
        }

        if SystemTime::now().gt(&api_reload_timer) {
            info!("Timer triggered: API_RELOAD_TIMER");
            api_reload_timer = SystemTime::now().add(Duration::from_secs(60));
            match tx.api_thread.send(APIWorkerMessage::Timer) {
                Ok(_) => (),
                Err(e) => {
                    error!("Error sending timer message to api worker thread: {}", e);
                }
            }
        }

        match tx.nebula_thread.send(NebulaWorkerMessage::WakeUp) {
            Ok(_) => (),
            Err(e) => {
                error!("Error sending wakeup message to nebula worker thread: {}", e);
            }
        }

        match tx.socket_thread.send(SocketWorkerMessage::WakeUp) {
            Ok(_) => (),
            Err(e) => {
                error!("Error sending wakeup message to socket worker thread: {}", e);
            }
        }
    }
}