watchmend 0.0.1

Watchmen is a daemon process manager that for you manage and keep your application online 24/7
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

use crate::common::config::Config;
use tokio::sync::mpsc;
use tracing::info;

use crate::global;

#[cfg(feature = "sock")]
pub mod sock;

#[cfg(feature = "socket")]
pub mod socket;

#[cfg(feature = "http")]
pub mod http;

pub async fn start(config: Config, load: bool) {
    if load {
        if let Some(path) = config.watchmen.cache.clone() {
            global::set_cache(path.clone()).await;
            match global::load(&path).await {
                Ok(_) => {
                    info!("Cache tasks loaded.");
                    println!("Cache tasks loaded.");
                }
                Err(e) => {
                    info!("Cache tasks load failed: {}", e);
                    println!("Cache tasks load failed: {}", e);
                }
            }
        } else {
            info!("Cache tasks load failed: cache file not set in config.");
            println!("Cache tasks load failed: cache file not set in config.");
        }
    }

    let (tx, mut rx) = mpsc::channel::<i32>(12);

    let tx_ctrl_c = tx.clone(); // 监听到 ctrl c 通信管道
    let tx_ctrl_d = tx.clone(); // 监听到 ctrl d 通信管道

    // ctrl c 停止运行 / terminate on ctrl-c
    let s_ctrl_c = tokio::spawn(async move {
        tokio::signal::ctrl_c().await.unwrap();
        tx_ctrl_c.send(9).await.unwrap();
    });

    // ctrl d 停止运行 / terminate on ctrl-d
    let s_ctrl_d = tokio::spawn(async move {
        tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate())
            .unwrap()
            .recv()
            .await;
        tx_ctrl_d.send(15).await.unwrap();
    });

    #[cfg(feature = "sock")]
    // sock in config.watchmen.engines ?
    let joinhandle_sock = if config.watchmen.engines.contains(&"sock".to_string()) {
        info!("Starting sock...");
        println!("Starting sock...");
        Some(sock::start(config.clone()).await)
    } else {
        None
    };

    #[cfg(feature = "socket")]
    let joinhandle_socket = if config.watchmen.engines.contains(&"socket".to_string()) {
        info!("Starting socket...");
        println!("Starting socket...");
        Some(socket::start(config.clone()).await)
    } else {
        None
    };

    #[cfg(feature = "http")]
    let joinhandle_http = if config.watchmen.engines.contains(&"http".to_string()) {
        info!("Starting http...");
        println!("Starting http...");
        Some(http::start(config.clone()).await)
    } else {
        None
    };

    info!("All engines started.");
    println!("All engines started.");

    // ================== Wait for all tasks to complete ==================

    let _res = rx.recv().await;

    s_ctrl_c.abort();
    s_ctrl_d.abort();

    println!("Shutting down...");

    #[cfg(feature = "sock")]
    if config.watchmen.engines.contains(&"sock".to_string()) && joinhandle_sock.is_some() {
        joinhandle_sock.unwrap().abort();
    }

    #[cfg(feature = "socket")]
    if config.watchmen.engines.contains(&"socket".to_string()) && joinhandle_socket.is_some() {
        joinhandle_socket.unwrap().abort();
    }

    #[cfg(feature = "http")]
    if config.watchmen.engines.contains(&"http".to_string()) && joinhandle_http.is_some() {
        joinhandle_http.unwrap().abort();
    }
}