justrun 1.0.0

Just run it! A simple init system
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

mod check_running;
pub mod cleanup;
mod maintainer;
pub mod service;

use justrun::{ipc, paths::RESULT_BASE};
use log::{error, info};
use std::sync::{Arc, Mutex};
use tokio::runtime::Runtime;

fn main() {
    env_logger::Builder::from_default_env()
        .filter_level(log::LevelFilter::Info)
        .init();

    if let Err(err) = check_running::check_running() {
        error!("{}", err);
        std::process::exit(1);
    }

    let rt = Runtime::new().unwrap_or_else(|err| {
        error!("Failed to create Tokio runtime: {}", err);
        std::process::exit(1);
    });

    let maintainer = {
        let mut maintainer = maintainer::Maintainer::new();
        maintainer.load().unwrap_or_else(|err| {
            error!("{}", err);
            std::process::exit(1);
        });
        maintainer.start_all().unwrap_or_else(|err| {
            error!("{}", err);
            std::process::exit(1);
        });
        Arc::new(Mutex::new(maintainer))
    };

    rt.block_on(async {
        let require_root = maintainer.lock().unwrap().require_root;
        let listener = ipc::Listener::new(require_root).unwrap_or_else(|err| {
            error!("{}", err);
            std::process::exit(1);
        });
        info!("Started socket successfully");

        let mut sigterm_stream =
            tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate())
                .unwrap_or_else(|err| {
                    error!("Failed to create SIGTERM stream: {}", err);
                    std::process::exit(1);
                });

        let maintainer = maintainer.clone();
        loop {
            tokio::select! {
                result = listener.accept() => {
                    match result {
                        Ok(data) => {
                            let parts = data.split_whitespace().collect::<Vec<_>>();
                            if parts.len() < 3 {
                                error!("Invalid command: {}", data);
                                continue;
                            }
                            let timestamp = parts[0];
                            let action = parts[1];
                            let arg = parts[2];
                            let mut maintainer = maintainer.lock().unwrap();
                            let output = match action {
                                "start" => {
                                    maintainer.start(arg).unwrap_or_else(|err| {
                                        error!("Failed to start service: {}", err);
                                        format!("Failed to start service: {}", err)
                                    })
                                }
                                "stop" => {
                                    maintainer.stop(arg).unwrap_or_else(|err| {
                                        error!("Failed to stop service: {}", err);
                                        format!("Failed to stop service: {}", err)
                                    })
                                }
                                "restart" => {
                                    maintainer.restart(arg).unwrap_or_else(|err| {
                                        error!("Failed to restart service: {}", err);
                                        format!("Failed to restart service: {}", err)
                                    })
                                }
                                "status" => {
                                    maintainer.status(arg).unwrap_or_else(|err| {
                                        error!("Failed to get status: {}", err);
                                        format!("Failed to get status: {}", err)
                                    })
                                }
                                _ => {
                                    error!("Unknown command: {}", parts[0]);
                                    continue;
                                }
                            };
                            drop(maintainer);
                            let path = std::path::Path::new(RESULT_BASE).join(timestamp);
                            let parent = path.parent().unwrap();
                            std::fs::create_dir_all(parent).unwrap_or_else(|err| {
                                error!("Failed to create directory: {}", err);
                            });
                            if path.exists() {
                                std::fs::remove_file(&path).unwrap_or_else(|err| {
                                    error!("Failed to remove file: {}", err);
                                });
                            }
                            std::fs::write(&path, output).unwrap_or_else(|err| {
                                error!("Failed to write to file: {}", err);
                            });
                        }
                        Err(err) => {
                            error!("{}", err);
                            std::process::exit(1);
                        }
                    }
                }
                _ = tokio::signal::ctrl_c() => {
                    info!("Received Ctrl+C, shutting down...");
                    let mut maintainer = maintainer.lock().unwrap();
                    maintainer.stop_all().unwrap_or_else(|err| {
                        error!("Failed to stop all services: {}", err);
                    });
                    let _ = cleanup::cleanup();
                    break;
                }
                 _ = sigterm_stream.recv() => {
                    info!("Received SIGTERM, shutting down...");
                    let mut maintainer = maintainer.lock().unwrap();
                    maintainer.stop_all().unwrap_or_else(|err| {
                        error!("Failed to stop all services: {}", err);
                    });
                    let _ = cleanup::cleanup();
                    break;
                }
            }
        }
    });
}