107 lines
2.9 KiB
Rust
107 lines
2.9 KiB
Rust
mod options;
|
|
mod utils;
|
|
|
|
use clap::Parser;
|
|
use log::{error, info};
|
|
use options::config::*;
|
|
use options::logger::setup_logger;
|
|
use options::signals::set_valid_destructor;
|
|
use options::structs::Processes;
|
|
use options::cli_pipeline::init_cli_pipeline;
|
|
use std::sync::Arc;
|
|
use std::time::Duration;
|
|
use tokio::sync::mpsc;
|
|
use utils::*;
|
|
|
|
#[allow(unused_imports)]
|
|
use options::preboot::PrebootParams;
|
|
|
|
#[tokio::main(flavor = "multi_thread")]
|
|
async fn main() {
|
|
let preboot = PrebootParams::parse().validate();
|
|
|
|
if let Err(_) = preboot {
|
|
return;
|
|
}
|
|
|
|
let _ = setup_logger();
|
|
|
|
info!("Runner is configurating...");
|
|
|
|
// setting up redis connection \
|
|
// then conf checks to choose the most actual \
|
|
let processes: Processes = get_actual_config().await.unwrap_or_else(|| {
|
|
error!("No actual configuration for runner. Stopping...");
|
|
std::process::exit(101);
|
|
});
|
|
|
|
info!(
|
|
"Current runner configuration: {}",
|
|
&processes.date_of_creation
|
|
);
|
|
info!("Runner is ready. Initializing...");
|
|
|
|
if processes.processes.is_empty() {
|
|
error!("Processes list is null, runner-rs initialization is stopped");
|
|
return;
|
|
}
|
|
let mut handler: Vec<tokio::task::JoinHandle<()>> = vec![];
|
|
// is in need to send to the signals handler thread
|
|
let mut senders: Vec<Arc<mpsc::Sender<u8>>> = vec![];
|
|
|
|
for proc in processes.processes.iter() {
|
|
info!(
|
|
"Process '{}' on stage: {}. Depends on {} file(s), {} service(s)",
|
|
proc.name,
|
|
proc.path,
|
|
proc.dependencies.files.len(),
|
|
proc.dependencies.services.len()
|
|
);
|
|
|
|
// creating msg channel
|
|
// can or should be executed in new thread
|
|
let (tx, mut rx) = mpsc::channel::<u8>(1);
|
|
let proc = Arc::new(proc.clone());
|
|
let tx = Arc::new(tx.clone());
|
|
|
|
senders.push(Arc::clone(&tx.clone()));
|
|
|
|
let event = tokio::spawn(async move {
|
|
run_daemons(proc.clone(), tx.clone(), &mut rx).await;
|
|
});
|
|
handler.push(event);
|
|
}
|
|
|
|
// destructor addition
|
|
handler.push(tokio::spawn(async move {
|
|
if set_valid_destructor(Arc::new(senders)).await.is_err() {
|
|
error!("Linux signals handler creation failed. Terminating main thread...");
|
|
return;
|
|
}
|
|
|
|
tokio::time::sleep(Duration::from_millis(200)).await;
|
|
info!("End of job. Terminating main thread...");
|
|
std::process::exit(0);
|
|
}));
|
|
|
|
// remote config update subscription
|
|
handler.push(tokio::spawn(async move {
|
|
let _ = subscribe_config_stream(Arc::new(processes)).await;
|
|
}));
|
|
|
|
// cli pipeline
|
|
handler.push(tokio::spawn(async move {
|
|
let _ = init_cli_pipeline().await;
|
|
}));
|
|
|
|
for i in handler {
|
|
let _ = i.await;
|
|
}
|
|
return;
|
|
}
|
|
|
|
// todo: integration tests
|
|
// todo: config pulling mechanism rework (socket)
|
|
// todo: tasks management after killing all processes
|
|
// todo:
|