lib_clds/src/clouds/upcloud.rs

use anyhow::{anyhow,Result};
use std::str;
use std::process::{Command};
use std::path::Path;

use crate::clouds::defs::{Cloud};
use crate::providers::defs::upcloud::{ResourcesConfig,ConfigResources};
use crate::providers::upcloud::{parse_resources_cfg,make_config_resources};
use crate::clouds::defs::{TsksrvcsHostInfo,HostInfo};
use crate::clouds::on_clouds::{parse_srvr_tsksrvcs,liveness_srvr_tsksrvcs};

pub async fn load_upcloud_config(cfg_data: String) -> Result<ConfigResources> {
	let mut res_cfg: ResourcesConfig = serde_yaml::from_str(&cfg_data)?;
  parse_resources_cfg(&mut res_cfg).await?;
  let config_res: ConfigResources = make_config_resources(&mut res_cfg).await?;
	Ok(config_res)
}

pub async fn upclapi_run(cmd: &str, id: &str, cfg_path: &str) -> Result<String> {
	let upclapi_path = envmnt::get_or("UPCLAPI", "upclapi");
	if ! Path::new(&upclapi_path).exists() {
		return Err(anyhow!("upclapi not found in {}",&upclapi_path));
	}
	let output: std::process::Output;
	if id.is_empty() {
		output = Command::new(&upclapi_path)
		.arg("-c")
		.arg(format!("{}",&cmd))
		.arg("-f")
		.arg(format!("{}",&cfg_path))
		.output()?;	
	} else {
		output = Command::new(&upclapi_path)
			.arg("-c")
			.arg(format!("{}",&cmd))
			.arg("-id")
			.arg(format!("{}",&id))
			.arg("-f")
			.arg(format!("{}",&cfg_path))
			.output()?;
	}
	if !&output.status.success() {
		return Err(anyhow!("upclapi run -c {} -id {} -s {} failed: {}",&cmd,&id,&cfg_path,&output.status));
	} 
	let res = str::from_utf8(&output.stdout).unwrap_or_else(|_| "");
  Ok(res.replace("\n","").to_owned())
}
pub async fn get_upcloud_info(hostname: &str, cmd: &str,cfg_path: &str) ->  String {
	match cmd {
		"server" => {
			upclapi_run("infoserver",&hostname,"").await
			.unwrap_or_else(|e| { 
				eprintln!("get_upcloud_info infoserver {}: {}",&hostname,e);
				String::from("")
			})
		},
		"floatip" => {
			upclapi_run("infofloatip","", &cfg_path).await
			.unwrap_or_else(|e| { 
				eprintln!("get_upcloud_info floatip {}: {}",&hostname,e);
				String::from("")
			})
		},
		_ => { String::from("")}
	}
}
pub async fn run_on_upcloud(reqname: &str,req_tsksrvc: &str, req_srvrs: &str, source: &str, cfg_data: String, env_cloud: &Cloud) -> String {
	let cloud_config = load_upcloud_config(cfg_data).await
	.unwrap_or_else(|e| {
		eprintln!("load_upcloud_config: {}",e);
		ConfigResources::default()
	});
	match reqname {
		"config" => {
			serde_json::to_string(&cloud_config)
			.unwrap_or_else(|e| { eprintln!("{}",e); String::from("")})
		},
		"provision" => {
			let mut hosts_info: Vec<HostInfo> = Vec::new();
			let cfg_path= format!("{}/{}/config.yaml",&env_cloud.env.home,&source);
			match req_tsksrvc {
				"floatip" => {
					hosts_info.push(HostInfo {
						hostname: "floatip".to_owned(),
						info: get_upcloud_info(&cloud_config.servers[0].hostname,&req_tsksrvc,&cfg_path).await,
					});
				},
				_ => {
					for srvr in cloud_config.servers.iter() {
						if req_srvrs == "" || req_srvrs.contains(&srvr.hostname) {
							hosts_info.push(HostInfo {
								hostname: srvr.hostname.to_owned(),
								info: get_upcloud_info(&srvr.hostname,"server",&cfg_path).await,
							});
						}
					};
				}
			};
			serde_json::to_string(&hosts_info)
			.unwrap_or_else(|e| { eprintln!("{}",e); String::from("")})
		},
		"status" => {
			match req_tsksrvc {
				_ => {	
					let mut hosts_tsksrvcs_info: Vec<TsksrvcsHostInfo> = Vec::new();
					for srvr in cloud_config.servers.iter() {
						if req_srvrs == "" || req_srvrs.contains(&srvr.hostname) {
						// let srvr=&cloud_config.servers[0];
							// serde_json::to_string(&cloud_config).unwrap_or_else(|_| String::from(""))
							// let str_host = format!("- hostname: {}\n  tsksrvcs:\n",&srvr.hostname);
							// res.push_str(&str_host);
							// TODO check if is alive 
							// res.push_str(
							hosts_tsksrvcs_info.push(TsksrvcsHostInfo {
								hostname: srvr.hostname.to_owned(),
								tsksrvcs: parse_srvr_tsksrvcs(&srvr.hostname, &srvr.sshAccess, &srvr.tsksrvcs,&req_tsksrvc).await,
							});
							// );
							// res.push('\n');
						}
					};
					// serde_json::to_string(&cloud_config).unwrap_or_else(|_| String::from(""))
					// res.to_owned()
					// println!("{}",&res);
					// let tsks_yaml: Vec<TsksrvcsHostInfo> = serde_yaml::from_str(&res)
					// .unwrap_or_else(|e| { eprintln!("{}",e); Vec::new() });
					serde_json::to_string(&hosts_tsksrvcs_info)
					.unwrap_or_else(|e| { eprintln!("{}",e); String::from("")})
				}
			}
		}
		"liveness" => {
			match req_tsksrvc {
				_ => {	
					let mut hosts_tsksrvcs_info: Vec<TsksrvcsHostInfo> = Vec::new();
					for srvr in cloud_config.servers.iter() {
						if req_srvrs == "" || req_srvrs.contains(&srvr.hostname) {
							hosts_tsksrvcs_info.push(TsksrvcsHostInfo {
								hostname: srvr.hostname.to_owned(),
								tsksrvcs: liveness_srvr_tsksrvcs(&source,&cloud_config.cntrllrs,&srvr.tsksrvcs,&req_tsksrvc).await,
							});
						}
					};
					serde_json::to_string(&hosts_tsksrvcs_info)
					.unwrap_or_else(|e| { eprintln!("serde liveness: {}",e); String::from("")})
				}
			}	
		},
		_ => {
			serde_json::to_string(&cloud_config)
			.unwrap_or_else(|e| { eprintln!("{}",e); String::from("")})
		},
	}
}