-
-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, Responder, middleware, App, HttpServer, web::Query };
+use actix_web::{ get, web, Responder, middleware, App, HttpServer };
use askama::Template;
-
-use std::{ /*sync::Mutex, */fs::File, env::args, 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;
text_status: String,
memory: String,
load_average: String,
- uptime: String
-}
-
-#[derive(Deserialize)]
-pub struct Request {
- m: Option<String>
+ uptime: String,
+ world_size: String,
+ nb_of_players: u32,
+ 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(/*key_shared: web::Data<Mutex<String>>,*/ query: Query<Request>) -> impl Responder {
- //let key = key_shared.lock().unwrap();
+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() {
+ 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()
+ uptime: info.format_uptime(),
+ world_size: info.format_world_size(),
+ nb_of_players: info.get_nb_of_player(),
+ 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() }
+ 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(), nb_of_players: 0, last_backup: value_unknown.clone() }
}
}
-
- /*
-
- let m =
- if valheim_controller::is_valheim_running() { String::from("Valheim server is up and running") } else { String::from("Valheim server is down :(") };
-
- MainTemplate { sentence: m }
- */
}
#[derive(Debug, Deserialize, Serialize)]
struct Config {
- port: u16
+ port: u16,
+
+ #[serde(default = "empty_string")]
+ world_path: String,
+
+ #[serde(default = "empty_string")]
+ backup_path: String,
}
-const DEFAULT_CONFIG: Config = Config { port: 8082 };
+fn empty_string() -> String { "".to_owned() }
+
+impl Config {
+ fn default() -> Self {
+ Config { port: 8082, world_path: String::from(""), backup_path: String::from("") }
+ }
+}
fn get_exe_name() -> String {
let first_arg = std::env::args().next().unwrap();
Ok(file) => from_reader(file).unwrap_or_else(|_| panic!("Failed to open configuration file {}", consts::FILE_CONF)),
Err(_) => {
let mut file = File::create(consts::FILE_CONF) .unwrap();
- file.write_all(to_string_pretty(&DEFAULT_CONFIG, PrettyConfig::new()).unwrap().as_bytes()).unwrap(); // We do not use 'to_writer' because it can't pretty format the output.
- DEFAULT_CONFIG
+ let default_config = Config::default();
+ file.write_all(to_string_pretty(&default_config, PrettyConfig::new()).unwrap().as_bytes()).unwrap(); // We do not use 'to_writer' because it can't pretty format the output.
+ default_config
}
}
}
#[actix_rt::main]
async fn main() -> std::io::Result<()> {
+ let config = load_config();
+ let port = config.port;
- if process_args() { return Ok(()) }
+ if process_args(&config) { return Ok(()) }
println!("Starting Valheim Admin as web server...");
- let config = load_config();
-
println!("Configuration: {:?}", config);
- let mut listenfd = ListenFd::from_env();
- let mut server =
+ let config_shared = web::Data::new(Mutex::new(config));
+
+ let server =
HttpServer::new(
move || {
App::new()
- // .app_data(key_shared.clone())
+ .app_data(config_shared.clone())
.wrap(middleware::Compress::default())
.wrap(middleware::Logger::default())
.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:{}", config.port)).unwrap()
- };
+ )
+ .bind(&format!("0.0.0.0:{}", port))
+ .unwrap();
server.run().await
}
-fn process_args() -> bool {
+fn process_args(config: &Config) -> bool {
fn print_usage() {
println!("Usage:");
println!(" {} [--help] [--status]", get_exe_name());
print_usage();
return true
} else if args.iter().any(|arg| arg == "--status") {
- println!("{:?}", valheim_controller::get_valheim_executable_information());
+ println!("{:?}", valheim_controller::get_valheim_executable_information(&config.world_path, &config.backup_path));
return true
}