chore: syntax crate::defs and remove monitor_rules.rs

src/clouds.rs

@@ -1,4 +1,3 @@
 pub mod defs;
 pub mod on_clouds;
-pub mod upcloud;
+pub mod upcloud;
-pub mod monitor_rules;

src/clouds/monitor_rules.rs

@@ -1,283 +0,0 @@
-use std::collections::HashMap;
-use serde::{Serialize,Deserialize,Deserializer};
-use std::fmt;
-use anyhow::{Result};
-
-use kloud::utils::load_fs_content;
-use crate::monitor::write_str_data;
-
-#[derive(Eq, PartialEq, Clone, Serialize, Debug, Deserialize)]
-pub enum RuleContext {
-  None,
-  Server(String),
-	Service(String),
-  Ip(String),
-}
-impl Default for RuleContext {
-	fn default() -> Self {
-		RuleContext::None
-	}
-}
-impl fmt::Display for RuleContext {
-	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-		match self {
-			RuleContext::Server(c) => write!(f,"server: {}",c),
-			RuleContext::None => write!(f,"none"),
-			RuleContext::Service(c) => write!(f,"service: {}",c),
-			RuleContext::Ip(c) => write!(f,"ip: {}",c),
-		}
-		//write!(f, "{:?}", self)
-	}
-}
-
-impl RuleContext {
-	pub fn get_value(&self) -> String {
-		match self {
-			RuleContext::Server(c) => format!("{}",c),
-			RuleContext::None => format!(""),
-			RuleContext::Service(c) => format!("{}",c),
-			RuleContext::Ip(c) => format!("{}",c),
-		}
-	}
-}
-
-#[derive(Eq, PartialEq, Clone, Serialize, Debug, Deserialize)]
-pub enum MonitorAction {
-  None,
-  Start(String,String,String),
-	Stop(String,String,String),
-  Restart(String,String,String),
-  Notify(String,String,String),
-}
-impl Default for MonitorAction {
-	fn default() -> Self {
-		MonitorAction::None
-	}
-}
-impl fmt::Display for MonitorAction {
-	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-		match self {
-			MonitorAction::None => write!(f,"none"),
-			MonitorAction::Start(v,p,a) => write!(f,"start: {} {} {}",v,p,a),
-			MonitorAction::Stop(v,p,a) => write!(f,"stop: {} {} {}",v,p,a),
-			MonitorAction::Restart(v,p,a) => write!(f,"restart: {} {} {}",v,p,a),
-			MonitorAction::Notify(v,p,a) => write!(f,"notify: {} {} {}",v,p,a),
-		}
-		//write!(f, "{:?}", self)
-	}
-}
-
-impl MonitorAction {
-	pub fn get_value(&self) -> String {
-		match self {
-			MonitorAction::None => format!(""),
-			MonitorAction::Start(v,p,a) => format!("{} {} {}",v,p,a),
-			MonitorAction::Stop(v,p,a) => format!("{} {} {}",v,p,a),
-			MonitorAction::Restart(v,p,a) => format!("{} {} {}",v,p,a),
-			MonitorAction::Notify(v,p,a) => format!("{} {} {}",v,p,a),
-		}
-	}
-}
-
-#[derive(Eq, PartialEq, Copy, Clone, Debug, Serialize,  Deserialize)]
-pub enum RuleSchedule {
-  None,
-  Check,
-	OnDemand,
-}
-
-impl Default for RuleSchedule {
- fn default() -> Self {
-    RuleSchedule::None
- }
-}
-
-impl fmt::Display for RuleSchedule {
-  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-    match self {
-      RuleSchedule::None => write!(f,"none"),
-      RuleSchedule::Check=> write!(f,"chechk"),
-      RuleSchedule::OnDemand=> write!(f,"ondemand"),
-    }
-  }
-}
-
-
-#[derive(Eq, PartialEq, Copy, Clone, Debug, Serialize,  Deserialize)]
-pub enum RuleOperator {
-  None,
-  Equal,
-	NotEqual,
-	Contains,
-	NotContains,
-}
-
-impl Default for RuleOperator {
- fn default() -> Self {
-    RuleOperator::None
- }
-}
-
-impl fmt::Display for RuleOperator {
-  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-    match self {
-      RuleOperator::None => write!(f,"none"),
-      RuleOperator::Equal => write!(f,"equal"),
-      RuleOperator::NotEqual=> write!(f,"not_equal"),
-      RuleOperator::Contains => write!(f,"matches"),
-      RuleOperator::NotContains => write!(f,"not_matches"),
-    }
-  }
-}
-
-fn deserialize_rulecontext<'de, D>(deserializer: D) -> Result<RuleContext, D::Error>
-where D: Deserializer<'de> {
-    let buf = String::deserialize(deserializer)?;
-    // let res = String::from_str(&buf).unwrap_or_else(|e|{
-		// 	eprintln!("deserialize rulecontext error: {}",e);
-		// 	String::from("")
-		// });
-		// println!("buf: {}",&buf);
-		let v: Vec<&str> = buf.split(':').collect();
-		if v.len() > 1 {
-			Ok(match v[0] {
-				"Service" => RuleContext::Service(v[1].to_owned()),
-				"Server" => RuleContext::Server(v[1].to_owned()),
-				"Ip" => RuleContext::Ip(v[1].to_owned()),
-				_ => RuleContext::None
-				
-			})
-		} else {
-      Ok(RuleContext::None)
-		}
-}
-fn deserialize_ruleactions<'de, D>(deserializer: D) -> Result<Vec<MonitorAction>, D::Error>
-where D: Deserializer<'de> {
-    let buf = Vec::deserialize(deserializer)?;
-		let mut actions = Vec::new();
-		buf.iter().for_each(|it: &String| {
-			let v: Vec<&str> = it.split(':').collect();
-		  if v.len() > 1 {
-			  let arg: Vec<&str> = v[1].split(',').collect();
-		    if arg.len() > 1 {
-					actions.push(match v[0] {
-						"Start" => MonitorAction::Start(arg[0].to_owned(),arg[1].to_owned(),arg[2].to_owned()),
-						"Stop" => MonitorAction::Stop(arg[0].to_owned(),arg[1].to_owned(),arg[2].to_owned()),
-						"Restart" => MonitorAction::Restart(arg[0].to_owned(),arg[1].to_owned(),arg[2].to_owned()),
-						"Notify" => MonitorAction::Notify(arg[0].to_owned(),arg[1].to_owned(),arg[2].to_owned()),
-						_ => MonitorAction::None
-					})
-				}
-			} 
-		});
-		Ok(actions)
-}
-#[allow(clippy::missing_docs_in_private_items)]
-#[allow(non_snake_case)]
-#[derive(Clone, Debug, Serialize,  Deserialize, Default)]
-pub struct MonitorRule {
-	pub id: String,
-	pub name: String,
-  pub description: String,
-	#[serde(deserialize_with = "deserialize_rulecontext")]
-  pub context: RuleContext,
-	pub command: String, 
-	pub selector: HashMap<String,String>,
-	pub operator: RuleOperator,
-	pub value: String,
-	pub result: bool,
-	pub use_state: bool,
-  pub wait_checks: isize,
-  pub schedule: RuleSchedule,
-	#[serde(deserialize_with = "deserialize_ruleactions")]
-	pub actions: Vec<MonitorAction>,
-}
-
-#[allow(clippy::missing_docs_in_private_items)]
-#[allow(non_snake_case)]
-#[derive(Clone, Debug, Serialize,  Deserialize, Default)]
-pub struct MonitorRules {
-  pub name: String,
-  pub description: String,
-	pub rules: Vec<MonitorRule>,
-}
-impl MonitorRules {
-  pub fn new(name: String, description: String, rules: Vec<MonitorRule> ) -> Self {
-    Self {
-      name,
-      description,
-			rules,
-    }
-  }
-	pub fn load(root: &str, path: &str, format: &str) -> Self {
-		let data_rules = load_fs_content(&root, &path, &format);
-		let err_load = |e|{
-			eprintln!("Error loading MonitorRules {}/{}.{}: {}",&root,&path,&format,e);
-			MonitorRules::default()
-		};
-		let res: MonitorRules;
-		if data_rules.is_empty() {
-			res = MonitorRules::default();
-		} else {
-		  // println!("Parse Montior Rules as: {}",&format);
-			res = match format {
-				"json" => serde_json::from_str(&data_rules).unwrap_or_else(|e| err_load(format!("{}",e))),
-				"yaml" => serde_yaml::from_str(&data_rules).unwrap_or_else(|e| err_load(format!("{}",e))),
-				"toml" => toml::from_str(&data_rules).unwrap_or_else(|e| err_load(format!("{}",e))),
-				_ => MonitorRules::default(),
-			};
-		} 
-		res
-	}
-	pub fn dump(&self, root: &str, path: &str, format: &str) -> Result<()> {
-		let err_load = |e| {
-			eprintln!("Error dump MonitorRules {}/{}.{}: {}",&root,&path,&format,e);	
-		  String::from("")	
-		};
-		let data_str = match format {
-			"json" => serde_json::to_string(&self).unwrap_or_else(|e| err_load(format!("{}",e))),
-			"yaml" => serde_yaml::to_string(&self).unwrap_or_else(|e| err_load(format!("{}",e))),
-			"toml" => toml::to_string(&self).unwrap_or_else(|e| err_load(format!("{}",e))),
-			_ => String::from(""),
-		};
-		if ! data_str.is_empty() {
-			println!("Dump loading MonitorRules to {}/{}.{}",&root,&path,&format);
-			let output_path = format!("{}/{}.{}",&root,&path,&format);
-			write_str_data(output_path, data_str, "Monitor rules dump".to_string())?;
-		}
-		Ok(())
-	}
-}
-
-#[allow(clippy::missing_docs_in_private_items)]
-#[allow(non_snake_case)]
-#[derive(Clone, Debug, Serialize,  Deserialize, Default)]
-pub struct MonitorStates {
-	pub when: String,
-  pub id: String,
-	pub data: String,	// to save JSON info 
-}
-impl MonitorStates {
-	pub fn load(root: &str, path: &str, format: &str) -> Self {
-    println!("Load Montior States ...");
-		let data_rules = load_fs_content(&root, &path, &format);
-		let res: MonitorStates = serde_json::from_str(&data_rules).unwrap_or_else(|e|{
-			eprintln!("Error loading MonitorStates {}/{}.{}: {}",&root,&path,&format,e);
-			MonitorStates::default()
-		});
-		res
-	}
-	pub fn dump(&self, root: &str, path: &str, format: &str) -> Result<()> {
-    println!("Dump Montior States ...");
-		let data_str = serde_json::to_string(&self).unwrap_or_else(|e| {
-			eprintln!("Error dump MonitorRules {}/{}.{}: {}",&root,&path,&format,e);	
-		  String::from("")	
-		}); 
-		if ! data_str.is_empty() {
-			println!("Dump MonitorStates to {}/{}.{}",&root,&path,&format);
-			let output_path = format!("{}/{}.{}",&root,&path,&format);
-			write_str_data(output_path, data_str, "Monitor states dump".to_string())?;
-		}
-		Ok(())
-	}
-}

src/clouds/on_clouds.rs

@@ -17,7 +17,17 @@ use crate::clouds::defs::{
 	TskSrvc,
 	MainResourcesConfig,
 };
-use crate::defs::{KloudHome,KloudCheckHome,SSHAccess,Cntrllr,CloudGroup,CloudCheckGroup,CloudItem,CloudCheckItem};
+use crate::defs::{
+	IsCritical,
+	KloudHome,
+	KloudCheckHome,
+	SSHAccess,
+	Cntrllr,
+	CloudGroup,
+	CloudCheckGroup,
+	CloudItem,
+	CloudCheckItem
+};
 use crate::clouds::defs::{TsksrvcInfo};
 
 use crate::clouds::upcloud::{get_upcloud_info,run_on_upcloud};
@@ -312,6 +322,7 @@ pub async fn parse_srvr_tsksrvcs(hostname: &str, sshaccess: &SSHAccess, tsksrvcs
 }
 pub async fn liveness_srvr_tsksrvcs(source: &str, cntrllrs: &Vec<Cntrllr>, tsksrvcs: &Vec<TskSrvc>, req_tsksrvc: &str) -> Vec<TsksrvcInfo> {
   let mut tsksrvcs_info: Vec<TsksrvcInfo> = Vec::new();
+	let debug=envmnt::get_isize("DEBUG",0);
 	for tsksrvc in tsksrvcs.iter() {
 		match format!("{}",&tsksrvc.name).as_str() {
 			"pause" => continue,
@@ -323,10 +334,17 @@ pub async fn liveness_srvr_tsksrvcs(source: &str, cntrllrs: &Vec<Cntrllr>, tsksr
 					continue;
 				}
 				let serverstring = format!("{}",&tsksrvc.liveness);
+				if debug > 2 {
+					println!("livenes: {} -> {}",&tsksrvc.name,&serverstring);
+				}
 				let res_info = match liveness_check(&source,&cntrllrs,&serverstring,&name).await {
 					Ok(_) => "ok",
 					Err(e) => {
-						eprint!("{}",e);
+						if tsksrvc.critical == IsCritical::yes {
+						 	let monitor_name = "WUJI_MONITOR";
+					    println!("{} : critical livenes: {} -> {}",envmnt::get_or(&monitor_name,""),&tsksrvc.name,&serverstring);
+						}
+						eprint!("liveness_check error: {}",e);
 						"err"
 					},
 				};