cai/CAI-Watchdog
1
1
Fork 0
Code Issues Pull Requests Projects Releases 1 Wiki Activity

Locales are in external files now

Browse Source 
Locales are in external files now
This commit is contained in:
Alexander I. Chebykin
2022-11-12 19:08:33 +03:00
parent 3ea4c96cfc
commit 011e79e676
9 changed files with 364 additions and 202 deletions
Download Patch File Download Diff File Expand all files Collapse all files

89
src/locales.rs
View File

@@ -1,89 +0,0 @@
pub struct Lang {
pub cant_find_config_file: String,
pub check_failed: String,
pub check_is_ok: String,
pub configuration_file: String,
pub error: String,
pub execute: String,
pub exiting: String,
pub failed_to_execute_process: String,
pub is_not_running: String,
pub is_not_running_now: String,
pub is_offline: String,
pub is_offline_now: String,
pub is_online: String,
pub is_online_now: String,
pub is_running: String,
pub is_running_now: String,
pub process: String,
pub service: String,
pub service_started: String,
pub state_changed_to_false: String,
pub state_changed_to_true: String,
pub this_help_message: String,
pub usage: String,
pub ver: String,
pub version_info: String
}
pub fn t(lang: String) -> Lang {
let l:Lang = if lang == "ru-RU" {
Lang{
cant_find_config_file: "Не могу найти файл конфигурации".to_string(),
check_failed: "Проверка завершилась неудачей".to_string(),
check_is_ok: "проверка завершилась успешно".to_string(),
configuration_file: "Конфигурационный файл".to_string(),
error: "Ошибка".to_string(),
execute: "Выполняю".to_string(),
exiting: "Завершаю работу...".to_string(),
failed_to_execute_process: "Не удалось выполнить процесс".to_string(),
is_not_running: "не запущен".to_string(),
is_not_running_now: "сейчас не запущен".to_string(),
is_offline: "неактивна".to_string(),
is_offline_now: "сейчас неактивна".to_string(),
is_online: "активна".to_string(),
is_online_now: "сейчас активна".to_string(),
is_running: "запущен".to_string(),
is_running_now: "сейчас запущен".to_string(),
process: "Процесс".to_string(),
service: "Служба".to_string(),
service_started: "Служба запущена".to_string(),
state_changed_to_false: "состояние изменилось на истину".to_string(),
state_changed_to_true: "состояние изменилось на ложь".to_string(),
this_help_message: "Это справочное сообщение".to_string(),
usage: "Использование".to_string(),
ver: "версия".to_string(),
version_info: "Информация о версии".to_string()
}
} else {
Lang{
cant_find_config_file: "Can't find configuration file".to_string(),
check_failed: "check failed".to_string(),
check_is_ok: "check is ok".to_string(),
configuration_file: "Configuration file".to_string(),
error: "Error".to_string(),
execute: "Execute".to_string(),
exiting: "Exiting...".to_string(),
failed_to_execute_process: "Can't execute process".to_string(),
is_not_running: "is not running".to_string(),
is_not_running_now: "is not running now".to_string(),
is_offline: "is offline".to_string(),
is_offline_now: "is offline now".to_string(),
is_online: "is online".to_string(),
is_online_now: "is online now".to_string(),
is_running: "is running".to_string(),
is_running_now: "is running now".to_string(),
process: "Process".to_string(),
service: "Service".to_string(),
service_started: "Service started".to_string(),
state_changed_to_false: "state changed to false".to_string(),
state_changed_to_true: "state changed to true".to_string(),
this_help_message: "This help message".to_string(),
usage: "Usage".to_string(),
ver: "ver".to_string(),
version_info: "Version info".to_string()
}
};
return l;
}

184
src/main.rs
View File

@@ -8,9 +8,9 @@ use std::process::Command;
use std::thread;
use std::time::Duration;
use sysinfo::{System, SystemExt};
use sys_locale::get_locale;
mod locales;
mod mod_locales;
mod mod_fs;
/// Rule description structure
struct Rule {
@@ -134,21 +134,21 @@ fn debug_log(text: String) {
/// execute("gedit".to_string());
/// ```
fn execute(command: String) {
let locale = get_locale().unwrap_or_else(|| String::from("en-US"));
let locale = mod_locales::Locale::new();
debug_log(format!("{} {}", locales::t(locale.clone()).execute, command));
debug_log(format!("{} {}", locale.t().execute, command));
let output = if cfg!(target_os = "windows") {
Command::new("powershell")
.args(["-NoLogo", "-NonInteractive", "-Command", &command])
.output()
.expect(&locales::t(locale.clone()).failed_to_execute_process) //.expect("failed to execute process")
.expect(&locale.t().failed_to_execute_process) //.expect("failed to execute process")
} else {
Command::new("sh")
.arg("-c")
.arg(&command)
.output()
.expect(&locales::t(locale.clone()).failed_to_execute_process) //.expect("failed to execute process")
.expect(&locale.t().failed_to_execute_process) //.expect("failed to execute process")
};
let result = output.stdout;
@@ -169,18 +169,18 @@ fn execute(command: String) {
/// print_help(args.clone());
/// ```
fn print_help(args: Vec<String>) {
let locale = get_locale().unwrap_or_else(|| String::from("en-US"));
let locale = mod_locales::Locale::new();
if cfg!(windows) {
if args.len() > 1 && (args[1].to_string() == "/help".to_string() || args[1].to_string() == "/?".to_string()) {
const VERSION: &str = env!("CARGO_PKG_VERSION");
println!("CAI Watchdog {} {}", locales::t(locale.clone()).ver, VERSION);
println!("CAI Watchdog {} {}", locale.t().ver, VERSION);
println!("");
println!("Usage: {} [/? | /help | /v | /ver | config_file]", &args[0]);
println!(" /? | /help : {}", locales::t(locale.clone()).this_help_message);
println!(" /v | /ver : {}", locales::t(locale.clone()).version_info);
println!(" config_file : {}", locales::t(locale.clone()).configuration_file);
println!(" /? | /help : {}", locale.t().this_help_message);
println!(" /v | /ver : {}", locale.t().version_info);
println!(" config_file : {}", locale.t().configuration_file);
std::process::exit(exitcode::OK);
} else if args.len() > 1
@@ -188,7 +188,7 @@ fn print_help(args: Vec<String>) {
const VERSION: &str = env!("CARGO_PKG_VERSION");
println!("CAI Watchdog {} {}", locales::t(locale.clone()).ver, VERSION);
println!("CAI Watchdog {} {}", locale.t().ver, VERSION);
std::process::exit(exitcode::OK);
}
@@ -196,19 +196,19 @@ fn print_help(args: Vec<String>) {
if args.len() > 1 && (args[1].to_string() == "--help".to_string() || args[1].to_string() == "-h".to_string()) {
const VERSION: &str = env!("CARGO_PKG_VERSION");
println!("CAI Watchdog {} {}", locales::t(locale.clone()).ver, VERSION);
println!("CAI Watchdog {} {}", locale.t().ver, VERSION);
println!("");
println!("{}: {} [-h | --help | -v | --ver | config_file]", locales::t(locale.clone()).usage, &args[0]);
println!(" -h | --help : {}", locales::t(locale.clone()).this_help_message);
println!(" -v | --ver : {}", locales::t(locale.clone()).version_info);
println!(" config_file : {}", locales::t(locale.clone()).configuration_file);
println!("{}: {} [-h | --help | -v | --ver | config_file]", locale.t().usage, &args[0]);
println!(" -h | --help : {}", locale.t().this_help_message);
println!(" -v | --ver : {}", locale.t().version_info);
println!(" config_file : {}", locale.t().configuration_file);
std::process::exit(exitcode::OK);
} else if args.len() > 1
&& (args[1].to_string() == "--ver".to_string() || args[1].to_string() == "-v".to_string()) {
const VERSION: &str = env!("CARGO_PKG_VERSION");
println!("CAI Watchdog {} {}", locales::t(locale.clone()).ver, VERSION);
println!("CAI Watchdog {} {}", locale.t().ver, VERSION);
std::process::exit(exitcode::OK);
}
@@ -216,29 +216,32 @@ fn print_help(args: Vec<String>) {
}
fn main() {
let locale = mod_locales::Locale::new();
let args: Vec<String> = env::args().collect();
let locale = get_locale().unwrap_or_else(|| String::from("en-US"));
debug_log(format!("The current locale is {}", locale.clone()));
// println!("{}", locales::t(locale).usage);
print_help(args.clone());
let mut config_file = mod_fs::get_exe_path();
if cfg!(windows) {
config_file = format!("{}\\cai-watchdog.ini", config_file);
} else {
config_file = "/etc/cai-watchdog/cai-watchdog.conf".to_string();
}
let cfg_file = if args.len() > 1 {
&args[1]
} else if cfg!(windows) {
"cai-watchdog.ini"
} else {
"/etc/cai-watchdog/cai-watchdog.conf"
&config_file
};
if !Path::new(cfg_file).exists() {
println!("\u{26a0} {}! {}.",
locales::t(locale.clone()).error,
locales::t(locale.clone()).cant_find_config_file
println!("\u{26a0} {}! {}.",
locale.t().error,
locale.t().cant_find_config_file
);
println!("{}", locales::t(locale.clone()).exiting);
println!("{}", locale.t().exiting);
std::process::exit(exitcode::CONFIG);
}
@@ -329,7 +332,7 @@ fn main() {
"".to_string()
};
debug_log(format!("\u{2139} {}", locales::t(locale.clone()).service_started));
debug_log(format!("\u{2139} {}", locale.t().service_started));
if on_start_command.to_string() != "" {
execute(on_start_command);
@@ -347,89 +350,89 @@ fn main() {
if check(&tasks_web[i]).await {
if tasks_web[i].last_state != true || just_started_web {
if tasks_web[i].command.to_string() == "".to_string() {
println!("\u{2705} {} {}",
tasks_web[i].uri,
locales::t(locale.clone()).state_changed_to_true
println!("\u{2705} {} {}",
tasks_web[i].uri,
locale.t().state_changed_to_true
);
} else {
debug_log(format!("\u{2705} {} {}",
tasks_web[i].uri,
locales::t(locale.clone()).state_changed_to_true)
debug_log(format!("\u{2705} {} {}",
tasks_web[i].uri,
locale.t().state_changed_to_true)
);
let shell_cmd =
tasks_web[i].command.to_string()
.replace("<email>", &tasks_web[i].email)
.replace("<subject>",
.replace("<subject>",
&format!(
"\"\u{2705} {} {} ({}) {}\"",
locales::t(locale.clone()).service,
tasks_web[i].service,
"\"\u{2705} {} {} ({}) {}\"",
locale.t().service,
tasks_web[i].service,
tasks_web[i].uri,
locales::t(locale.clone()).is_online
locale.t().is_online
)
)
.replace("<message>",
.replace("<message>",
&format!(
"\"\u{2705} {} {} ({}) {}\"",
locales::t(locale.clone()).service,
tasks_web[i].service,
"\"\u{2705} {} {} ({}) {}\"",
locale.t().service,
tasks_web[i].service,
tasks_web[i].uri,
locales::t(locale.clone()).is_online_now
locale.t().is_online_now
)
)
.replace("<service>", &tasks_web[i].service)
.replace("<uri>", &tasks_web[i].uri)
.replace("<state>", "online");
debug_log(format!("{} {}", locales::t(locale.clone()).execute, shell_cmd));
debug_log(format!("{} {}", locale.t().execute, shell_cmd));
execute(shell_cmd);
}
}
debug_log(format!("\u{2705} {} {}", tasks_web[i].uri, locales::t(locale.clone()).check_is_ok));
debug_log(format!("\u{2705} {} {}", tasks_web[i].uri, locale.t().check_is_ok));
tasks_web[i].last_state = true;
} else {
if tasks_web[i].last_state != false || just_started_web {
if tasks_web[i].command.to_string() == "".to_string() {
println!("\u{274c} {} {}", tasks_web[i].uri, locales::t(locale.clone()).state_changed_to_false);
println!("\u{274c} {} {}", tasks_web[i].uri, locale.t().state_changed_to_false);
} else {
debug_log(format!("\u{274c} {} {}", tasks_web[i].uri, locales::t(locale.clone()).state_changed_to_false));
debug_log(format!("\u{274c} {} {}", tasks_web[i].uri, locale.t().state_changed_to_false));
let shell_cmd =
tasks_web[i].command.to_string()
.replace("<email>", &tasks_web[i].email)
.replace("<subject>", &
format!(
"\"\u{274c} {} {} ({}) {}\"",
locales::t(locale.clone()).service,
tasks_web[i].service,
"\"\u{274c} {} {} ({}) {}\"",
locale.t().service,
tasks_web[i].service,
tasks_web[i].uri,
locales::t(locale.clone()).is_offline
locale.t().is_offline
)
)
.replace("<message>", &
format!(
"\"\u{274c} {} {} ({}) {}\"",
locales::t(locale.clone()).service,
tasks_web[i].service,
"\"\u{274c} {} {} ({}) {}\"",
locale.t().service,
tasks_web[i].service,
tasks_web[i].uri,
locales::t(locale.clone()).is_offline_now
locale.t().is_offline_now
)
)
.replace("<service>", &tasks_web[i].service)
.replace("<uri>", &tasks_web[i].uri)
.replace("<state>", "offline");
debug_log(format!("{} {}", locales::t(locale.clone()).execute, shell_cmd));
debug_log(format!("{} {}", locale.t().execute, shell_cmd));
execute(shell_cmd);
}
}
debug_log(format!("\u{274c} {} {}", tasks_web[i].uri, locales::t(locale.clone()).check_failed));
debug_log(format!("\u{274c} {} {}", tasks_web[i].uri, locale.t().check_failed));
tasks_web[i].last_state = false;
}
@@ -443,7 +446,8 @@ fn main() {
});
let mut just_started_prc = true;
let locale_prc = get_locale().unwrap_or_else(|| String::from("en-US"));
let locale = mod_locales::Locale::new();
loop {
for i in 0..tasks_prc.len() {
@@ -454,82 +458,82 @@ fn main() {
if check(&tasks_prc[i]).await {
if tasks_prc[i].last_state != true || just_started_prc {
if tasks_prc[i].command.to_string() == "".to_string() {
println!("\u{2705} {} {}", tasks_prc[i].uri, locales::t(locale_prc.clone()).state_changed_to_true);
println!("\u{2705} {} {}", tasks_prc[i].uri, locale.t().state_changed_to_true);
} else {
debug_log(format!("\u{2705} {} {}", tasks_prc[i].uri, locales::t(locale_prc.clone()).state_changed_to_true));
debug_log(format!("\u{2705} {} {}", tasks_prc[i].uri, locale.t().state_changed_to_true));
let shell_cmd =
tasks_prc[i].command.to_string()
.replace("<email>", &tasks_prc[i].email)
.replace("<subject>",
.replace("<subject>",
&format!(
"\"\u{2705} {} {} ({}) {}\"",
locales::t(locale_prc.clone()).process,
tasks_prc[i].service,
"\"\u{2705} {} {} ({}) {}\"",
locale.t().process,
tasks_prc[i].service,
tasks_prc[i].process,
locales::t(locale_prc.clone()).is_running
locale.t().is_running
)
)
.replace("<message>",
.replace("<message>",
&format!(
"\"\u{2705} {} {} ({}) {}\"",
locales::t(locale_prc.clone()).process,
tasks_prc[i].service,
"\"\u{2705} {} {} ({}) {}\"",
locale.t().process,
tasks_prc[i].service,
tasks_prc[i].process,
locales::t(locale_prc.clone()).is_running_now
locale.t().is_running_now
)
)
.replace("<service>", &tasks_prc[i].service)
.replace("<process>", &tasks_prc[i].process)
.replace("<state>", "running");
debug_log(format!("{} {}", locales::t(locale_prc.clone()).execute, shell_cmd));
debug_log(format!("{} {}", locale.t().execute, shell_cmd));
execute(shell_cmd);
}
}
debug_log(format!("\u{2705} {} {}", tasks_prc[i].process, locales::t(locale_prc.clone()).is_running));
debug_log(format!("\u{2705} {} {}", tasks_prc[i].process, locale.t().is_running));
tasks_prc[i].last_state = true;
} else {
if tasks_prc[i].last_state != false || just_started_prc {
if tasks_prc[i].command.to_string() == "".to_string() {
println!("\u{274c} {} {}", tasks_prc[i].uri, locales::t(locale_prc.clone()).state_changed_to_false);
println!("\u{274c} {} {}", tasks_prc[i].uri, locale.t().state_changed_to_false);
} else {
debug_log(format!("\u{274c} {} {}", tasks_prc[i].uri, locales::t(locale_prc.clone()).state_changed_to_false));
debug_log(format!("\u{274c} {} {}", tasks_prc[i].uri, locale.t().state_changed_to_false));
let shell_cmd =
tasks_prc[i].command.to_string()
.replace("<email>", &tasks_prc[i].email)
.replace("<subject>",
.replace("<subject>",
&format!(
"\"\u{274c} {} {} ({}) {}\"",
locales::t(locale_prc.clone()).process,
tasks_prc[i].service,
"\"\u{274c} {} {} ({}) {}\"",
locale.t().process,
tasks_prc[i].service,
tasks_prc[i].process,
locales::t(locale_prc.clone()).is_not_running
locale.t().is_not_running
)
)
.replace("<message>",
.replace("<message>",
&format!(
"\"\u{274c} {} {} ({}) {}\"",
locales::t(locale_prc.clone()).process,
tasks_prc[i].service,
"\"\u{274c} {} {} ({}) {}\"",
locale.t().process,
tasks_prc[i].service,
tasks_prc[i].process,
locales::t(locale_prc.clone()).is_not_running_now
locale.t().is_not_running_now
)
)
.replace("<service>", &tasks_prc[i].service)
.replace("<process>", &tasks_prc[i].process)
.replace("<state>", "stopped");
debug_log(format!("{} {}", locales::t(locale_prc.clone()).execute, shell_cmd));
debug_log(format!("{} {}", locale.t().execute, shell_cmd));
execute(shell_cmd);
}
}
debug_log(format!("\u{274c} {} {}", tasks_prc[i].process, locales::t(locale_prc.clone()).is_not_running));
debug_log(format!("\u{274c} {} {}", tasks_prc[i].process, locale.t().is_not_running));
tasks_prc[i].last_state = false;

22
src/mod_fs.rs Normal file
View File

@@ -0,0 +1,22 @@
use std::env;
use std::path::PathBuf;
/// Return executable path
///
/// Return executable path or . if can't determine it
pub fn get_exe_path() -> String {
let mut dir;
let exe_path: String;
match env::current_exe() {
Ok(full_name) => {
dir = PathBuf::from(full_name);
dir.pop();
exe_path = dir.clone().into_os_string().into_string().unwrap();
},
Err(_e) => {
exe_path = ".".to_string();
},
}
return exe_path;
}

168
src/mod_locales.rs Normal file
View File

@@ -0,0 +1,168 @@
use std::borrow::Borrow;
use std::path::Path;
use crate::mod_fs;
use sys_locale::get_locale;
pub struct Lang {
pub cant_find_config_file: String,
pub check_failed: String,
pub check_is_ok: String,
pub configuration_file: String,
pub error: String,
pub execute: String,
pub exiting: String,
pub failed_to_execute_process: String,
pub is_not_running: String,
pub is_not_running_now: String,
pub is_offline: String,
pub is_offline_now: String,
pub is_online: String,
pub is_online_now: String,
pub is_running: String,
pub is_running_now: String,
pub process: String,
pub service: String,
pub service_started: String,
pub state_changed_to_false: String,
pub state_changed_to_true: String,
pub this_help_message: String,
pub usage: String,
pub ver: String,
pub version_info: String
}
pub struct Locale {
pub locale:Lang,
}
impl Locale {
pub fn new() -> Self {
let mut l:Lang = Lang{
cant_find_config_file: "Can't find configuration file".to_string(),
check_failed: "check failed".to_string(),
check_is_ok: "check is ok".to_string(),
configuration_file: "Configuration file".to_string(),
error: "Error".to_string(),
execute: "Execute".to_string(),
exiting: "Exiting...".to_string(),
failed_to_execute_process: "Can't execute process".to_string(),
is_not_running: "is not running".to_string(),
is_not_running_now: "is not running now".to_string(),
is_offline: "is offline".to_string(),
is_offline_now: "is offline now".to_string(),
is_online: "is online".to_string(),
is_online_now: "is online now".to_string(),
is_running: "is running".to_string(),
is_running_now: "is running now".to_string(),
process: "Process".to_string(),
service: "Service".to_string(),
service_started: "Service started".to_string(),
state_changed_to_false: "state changed to false".to_string(),
state_changed_to_true: "state changed to true".to_string(),
this_help_message: "This help message".to_string(),
usage: "Usage".to_string(),
ver: "ver".to_string(),
version_info: "Version info".to_string()
};
let locale = get_locale().unwrap_or_else(|| String::from("en-US"));
let mut locale_file = mod_fs::get_exe_path();
locale_file = if cfg!(windows) {
format!("{}\\locales\\{}.conf", locale_file, locale)
} else {
format!("/etc/cai-watchdog/locales/{}.conf", locale)
};
if Path::new(&locale_file).exists() {
let cfg = ini!(&locale_file);
if cfg["rules"].contains_key("cant_find_config_file") {
l.cant_find_config_file = cfg["rules"]["cant_find_config_file"].clone().unwrap();
}
if cfg["rules"].contains_key("check_failed") {
l.check_failed = cfg["rules"]["check_failed"].clone().unwrap();
}
if cfg["rules"].contains_key("check_is_ok") {
l.check_is_ok = cfg["rules"]["check_is_ok"].clone().unwrap();
}
if cfg["rules"].contains_key("configuration_file") {
l.configuration_file = cfg["rules"]["configuration_file"].clone().unwrap();
}
if cfg["rules"].contains_key("error") {
l.error = cfg["rules"]["error"].clone().unwrap();
}
if cfg["rules"].contains_key("execute") {
l.execute = cfg["rules"]["execute"].clone().unwrap();
}
if cfg["rules"].contains_key("exiting") {
l.exiting = cfg["rules"]["exiting"].clone().unwrap();
}
if cfg["rules"].contains_key("failed_to_execute_process") {
l.failed_to_execute_process = cfg["rules"]["failed_to_execute_process"].clone().unwrap();
}
if cfg["rules"].contains_key("is_not_running") {
l.is_not_running = cfg["rules"]["is_not_running"].clone().unwrap();
}
if cfg["rules"].contains_key("is_not_running_now") {
l.is_not_running_now = cfg["rules"]["is_not_running_now"].clone().unwrap();
}
if cfg["rules"].contains_key("is_offline") {
l.is_offline = cfg["rules"]["is_offline"].clone().unwrap();
}
if cfg["rules"].contains_key("is_offline_now") {
l.is_offline_now = cfg["rules"]["is_offline_now"].clone().unwrap();
}
if cfg["rules"].contains_key("is_online") {
l.is_online = cfg["rules"]["is_online"].clone().unwrap();
}
if cfg["rules"].contains_key("is_online_now") {
l.is_online_now = cfg["rules"]["is_online_now"].clone().unwrap();
}
if cfg["rules"].contains_key("is_running") {
l.is_running = cfg["rules"]["is_running"].clone().unwrap();
}
if cfg["rules"].contains_key("is_running_now") {
l.is_running_now = cfg["rules"]["is_running_now"].clone().unwrap();
}
if cfg["rules"].contains_key("process") {
l.process = cfg["rules"]["process"].clone().unwrap();
}
if cfg["rules"].contains_key("service") {
l.service = cfg["rules"]["service"].clone().unwrap();
}
if cfg["rules"].contains_key("service_started") {
l.service_started = cfg["rules"]["service_started"].clone().unwrap();
}
if cfg["rules"].contains_key("state_changed_to_false") {
l.state_changed_to_false = cfg["rules"]["state_changed_to_false"].clone().unwrap();
}
if cfg["rules"].contains_key("state_changed_to_true") {
l.state_changed_to_true = cfg["rules"]["state_changed_to_true"].clone().unwrap();
}
if cfg["rules"].contains_key("this_help_message") {
l.this_help_message = cfg["rules"]["this_help_message"].clone().unwrap();
}
if cfg["rules"].contains_key("usage") {
l.usage = cfg["rules"]["usage"].clone().unwrap();
}
if cfg["rules"].contains_key("ver") {
l.ver = cfg["rules"]["ver"].clone().unwrap();
}
if cfg["rules"].contains_key("version_info") {
l.version_info = cfg["rules"]["version_info"].clone().unwrap();
}
}
Self {
locale: l
}
}
pub fn t(&self) -> &Lang {
return self.locale.borrow().clone();
}
}