-
-extern crate listenfd;
extern crate askama;
-// use futures::sink::With;
-use listenfd::ListenFd;
+use std::{ sync::Mutex, env::args, fs::File, io::prelude::* };
use actix_files as fs;
use actix_web::{ get, web, Responder, middleware, App, HttpServer };
use askama::Template;
-
-use std::{ sync::Mutex, env::args, fs::File, io::prelude::* };
use ron::{ de::from_reader, ser::{ to_string_pretty, PrettyConfig } };
use serde::{ Deserialize, Serialize };
+use cached::proc_macro::cached;
mod consts;
mod tests;
memory: String,
load_average: String,
uptime: String,
- world_size: String
+ world_size: String,
+ active_players: String,
+ last_backup: String,
}
const VALUE_UNKNOWN: &str = "-";
+#[cached(size = 1, time = 10)]
+fn get_valheim_executable_information_cached(world_path: String, backup_path: String) -> Option<valheim_controller::ValheimExe> {
+ valheim_controller::get_valheim_executable_information(&world_path, &backup_path)
+}
+
#[get("/")]
async fn main_page(config_shared: web::Data<Mutex<Config>>) -> impl Responder {
let config = config_shared.lock().unwrap();
- match valheim_controller::get_valheim_executable_information(&config.world_path) {
+ match get_valheim_executable_information_cached(config.world_path.clone(), config.backup_path.clone()) {
Some(info) =>
MainTemplate {
text_status: String::from("Valheim server is up and running :)"),
memory: info.format_memory(),
load_average: info.format_load_average(),
uptime: info.format_uptime(),
- world_size: info.format_world_size()
+ world_size: info.format_world_size(),
+ active_players: info.format_active_players(),
+ last_backup: info.format_last_backup()
},
None => {
let value_unknown = String::from(VALUE_UNKNOWN);
- MainTemplate { text_status: String::from("Valheim server is down :("), memory: value_unknown.clone(), load_average: value_unknown.clone(), uptime: value_unknown.clone(), world_size: value_unknown.clone() }
+ MainTemplate {
+ text_status: String::from("Valheim server is down :("),
+ memory: value_unknown.clone(),
+ load_average: value_unknown.clone(),
+ uptime: value_unknown.clone(),
+ world_size: value_unknown.clone(),
+ active_players: value_unknown.clone(),
+ last_backup: value_unknown.clone() }
}
}
}
#[derive(Debug, Deserialize, Serialize)]
struct Config {
port: u16,
+
#[serde(default = "empty_string")]
world_path: String,
+
+ #[serde(default = "empty_string")]
+ backup_path: String,
}
-fn empty_string() -> String { "".to_string() }
+fn empty_string() -> String { "".to_owned() }
impl Config {
fn default() -> Self {
- Config { port: 8082, world_path: String::from("") }
+ Config { port: 8082, world_path: String::from(""), backup_path: String::from("") }
}
}
}
}
-#[actix_rt::main]
+#[actix_web::main]
async fn main() -> std::io::Result<()> {
let config = load_config();
let port = config.port;
let config_shared = web::Data::new(Mutex::new(config));
- let mut listenfd = ListenFd::from_env();
- let mut server =
+ let server =
HttpServer::new(
move || {
App::new()
.service(main_page)
.service(fs::Files::new("/static", "static").show_files_listing())
}
- );
-
- server =
- if let Some(l) = listenfd.take_tcp_listener(0).unwrap() {
- server.listen(l).unwrap()
- } else {
- server.bind(&format!("0.0.0.0:{}", port)).unwrap()
- };
+ )
+ .bind(&format!("0.0.0.0:{}", port))
+ .unwrap();
server.run().await
}
print_usage();
return true
} else if args.iter().any(|arg| arg == "--status") {
- println!("{:?}", valheim_controller::get_valheim_executable_information(&config.world_path));
+ println!("{:?}", valheim_controller::get_valheim_executable_information(&config.world_path, &config.backup_path));
return true
}