VladislavD
/
monitor
1
0
Fork 0
Code Issues 4 Pull Requests Packages Projects Releases 1 Wiki Activity

all fixed but...

pull/9/head
prplV 2024-07-08 05:41:17 -04:00
parent 759ff64532
commit 73daa8320b
2 changed files with 58 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
settings.json
View File

@ -59,7 +59,7 @@
"triggers" : {
"wait" : 10,
"delay" : 2,
"onLost" : "stop"
"onLost" : "hold"
}
}]
}

86
src/main.rs
View File

@ -121,13 +121,18 @@ async fn run_daemons(
match _val.unwrap() {
// 1 - File-dependency handling error -> terminating (after waiting)
1 => {
if is_active(&proc.name) {
println!("Dependency handling error: Terminating {} process ..." , &proc.name);
terminate_process(&proc.name).await;
break;
}
// break;
},
// 2 - File-dependency handling error -> holding (after waiting)
2 => {
println!("Error due to starting {} process", &proc.name);
if !is_frozen(&proc.name) {
println!("Dependency handling error: Freezing {} process ..." , &proc.name);
freeze_process(&proc.name).await;
}
},
// 3 - Running process error
3 => {
@ -139,14 +144,18 @@ async fn run_daemons(
},
// 5 - Timeout of waiting service-dependency -> terminating (after waiting)
5 => {
if is_active(&proc.name) {
println!("Timeout of waiting service-dependency: Terminating {} process ..." , &proc.name);
terminate_process(&proc.name).await;
break;
}
// break;
},
// 6 - Timeout of waiting service-dependency -> holding (after waiting)
6 => {
if !is_frozen(&proc.name) {
println!("Timeout of waiting service-dependency: Freezing {} process ..." , &proc.name);
freeze_process(&proc.name).await;
}
},
// // 7 - File-dependency change -> terminating (after check)
// 7 => {},
@ -157,13 +166,17 @@ async fn run_daemons(
// 10 - Process unfreaze call via file handler
10 => {
println!("Unfreezing process {} call via file handler...", &proc.name);
if is_frozen(&proc.name) {
println!("Unfreezing process {} call...", &proc.name);
unfreeze_process(&proc.name).await;
}
},
// 11 - Process unfreaze call via service handler
11 => {
println!("Unfreezing process {} call via service handler...", &proc.name);
if is_frozen(&proc.name) {
println!("Unfreezing process {} call...", &proc.name);
unfreeze_process(&proc.name).await;
}
},
// 101 - Impermissible trigger values in JSON
101 => {
@ -248,8 +261,8 @@ async fn start_process(name: &str, path: &str) -> Result<(), CustomError> {
}
// check process status daemon
async fn running_handler(prc: &TrackingProcess, tx: mpsc::Sender<u8>){
// println!("running daemon on {}", name);
loop {
// println!("running daemon on {}", prc.name);
// loop {
let _ = Command::new("pidof")
.arg(&prc.name)
.output()
@ -258,30 +271,26 @@ async fn running_handler(prc: &TrackingProcess, tx: mpsc::Sender<u8>){
let files_check = file_handler(&prc.name, &prc.dependencies.files, tx.clone());
let services_check = service_handler(&prc.name, &prc.dependencies.services, tx.clone());
join!(files_check, services_check);
let res = join!(files_check, services_check);
// if inactive -> spawn checks -> active is true
if !is_active(&prc.name){
if !is_active(&prc.name) && res.0.is_ok() && res.1.is_ok(){
if start_process(&prc.name, &prc.path).await.is_err() {
tx.send(3).await.unwrap();
// return;
return;
}
}
// if frozen -> spawn checks -> unfreeze is true
else if is_frozen(&prc.name){
else if is_frozen(&prc.name) && res.0.is_ok() && res.1.is_ok(){
tx.send(10).await.unwrap();
return;
}
tokio::time::sleep(Duration::from_millis(100)).await;
tokio::task::yield_now().await;
}
// }
}
async fn file_handler(name: &str, files: &Vec<Files>, tx: mpsc::Sender<u8>) {
async fn file_handler(name: &str, files: &Vec<Files>, tx: mpsc::Sender<u8>) -> Result<(), CustomError>{
// println!("file daemon on {}", name);
if is_active(name) && !is_frozen(name){
for file in files {
if check_file(&file.filename, &file.src).is_err() {
match file.triggers.on_delete.as_str() {
@ -289,31 +298,30 @@ async fn file_handler(name: &str, files: &Vec<Files>, tx: mpsc::Sender<u8>) {
continue;
},
"stop" => {
if is_active(name) {
tx.send(1).await.unwrap();
return;
}
tokio::time::sleep(Duration::from_millis(50)).await;
return Err(CustomError::Fatal);
},
"hold" => {
if is_active(name) {
tokio::time::sleep(Duration::from_millis(50)).await;
tx.send(2).await.unwrap();
// continue;
// while check_file(&file.filename, &file.src).is_err() {
// println!("zov");
// tokio::time::sleep(Duration::from_millis(100)).await;
// }
// tx.send(10).await.unwrap();
return Err(CustomError::Fatal);
}
},
_ => {
tokio::time::sleep(Duration::from_millis(50)).await;
tx.send(101).await.unwrap();
return;
return Err(CustomError::Fatal);
},
}
}
}
// if is_frozen(name) {
// tx.send(10).await.unwrap();
// }
}
tokio::time::sleep(Duration::from_millis(100)).await;
tokio::task::yield_now().await;
Ok(())
}
fn check_file(filename: &str, path: &str) -> Result<(), CustomError> {
let fileconcat = format!("{}{}", path, filename);
@ -326,9 +334,8 @@ fn check_file(filename: &str, path: &str) -> Result<(), CustomError> {
}
// ??
async fn service_handler(name: &str, services: &Vec<Services>, tx: mpsc::Sender<u8>) {
async fn service_handler(name: &str, services: &Vec<Services>, tx: mpsc::Sender<u8>) -> Result<(), CustomError> {
// println!("service daemon on {}", name);
if is_active(name) && !is_frozen(name) {
for serv in services {
if check_service(&serv.hostname, &serv.port).await.is_err() {
// println!("Service {}:{} is unreachable for process {}", &serv.hostname, &serv.port, &name);
@ -338,27 +345,28 @@ async fn service_handler(name: &str, services: &Vec<Services>, tx: mpsc::Sender<
"stop" => {
if looped_service_connecting(name, serv).await.is_err() {
tx.send(5).await.unwrap();
return;
return Err(CustomError::Fatal);
}
},
"hold" => {
if is_frozen(name) {
return Err(CustomError::Fatal);
}
if looped_service_connecting(name, serv).await.is_err() {
tx.send(6).await.unwrap();
return Err(CustomError::Fatal);
}
},
_ => {
tx.send(101).await.unwrap();
return;
return Err(CustomError::Fatal);
},
}
}
}
// if is_frozen(name) {
// tx.send(11).await.unwrap();
// }
}
tokio::time::sleep(Duration::from_millis(100)).await;
tokio::task::yield_now().await;
Ok(())
}