backend/src/main.rs

   1
   2 extern crate listenfd;
   3 extern crate askama;
   4
   5 // use futures::sink::With;
   6 use listenfd::ListenFd;
   7 use actix_files as fs;
   8 use actix_web::{ get, Responder, middleware, App, HttpServer };
   9 use askama::Template;
  10
  11 use std::{ /*sync::Mutex, */fs::File, env::args, io::prelude::* };
  12 use ron::{ de::from_reader, ser::{ to_string_pretty, PrettyConfig } };
  13 use serde::{ Deserialize, Serialize };
  14
  15 mod consts;
  16 mod tests;
  17 mod valheim_controller;
  18
  19 #[derive(Template)]
  20 #[template(path = "main.html")]
  21 struct MainTemplate {
  22     text_status: String,
  23     memory: String,
  24     load_average: String,
  25     uptime: String,
  26     world_size: String
  27 }
  28
  29 const VALUE_UNKNOWN: &str = "-";
  30
  31 #[get("/")]
  32 async fn main_page() -> impl Responder {
  33     //let key = key_shared.lock().unwrap();
  34
  35     match valheim_controller::get_valheim_executable_information() {
  36         Some(info) =>
  37             MainTemplate {
  38                 text_status: String::from("Valheim server is up and running :)"),
  39                 memory: info.format_memory(),
  40                 load_average: info.format_load_average(),
  41                 uptime: info.format_uptime(),
  42                 world_size: info.format_world_size()
  43             },
  44         None => {
  45             let value_unknown = String::from(VALUE_UNKNOWN);
  46             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() }
  47         }
  48     }
  49 }
  50
  51 #[derive(Debug, Deserialize, Serialize)]
  52 struct Config {
  53     port: u16
  54 }
  55
  56 const DEFAULT_CONFIG: Config = Config { port: 8082 };
  57
  58 fn get_exe_name() -> String {
  59     let first_arg = std::env::args().next().unwrap();
  60     let sep: &[_] = &['\\', '/'];
  61     first_arg[first_arg.rfind(sep).unwrap()+1..].to_string()
  62 }
  63
  64 fn load_config() -> Config {
  65     // unwrap_or_else(|_| panic!("Failed to open configuration file {}", consts::FILE_CONF));
  66     match File::open(consts::FILE_CONF) {
  67         Ok(file) => from_reader(file).unwrap_or_else(|_| panic!("Failed to open configuration file {}", consts::FILE_CONF)),
  68         Err(_) => {
  69             let mut file = File::create(consts::FILE_CONF) .unwrap();
  70             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.
  71             DEFAULT_CONFIG
  72         }
  73     }
  74 }
  75
  76 #[actix_rt::main]
  77 async fn main() -> std::io::Result<()> {
  78
  79     if process_args() { return Ok(()) }
  80
  81     println!("Starting Valheim Admin as web server...");
  82
  83     let config = load_config();
  84
  85     println!("Configuration: {:?}", config);
  86
  87     let mut listenfd = ListenFd::from_env();
  88     let mut server =
  89         HttpServer::new(
  90             move || {
  91                 App::new()
  92                     // .app_data(key_shared.clone())
  93                     .wrap(middleware::Compress::default())
  94                     .wrap(middleware::Logger::default())
  95                     .service(main_page)
  96                     .service(fs::Files::new("/static", "static").show_files_listing())
  97             }
  98         );
  99
 100     server =
 101         if let Some(l) = listenfd.take_tcp_listener(0).unwrap() {
 102             server.listen(l).unwrap()
 103         } else {
 104             server.bind(&format!("0.0.0.0:{}", config.port)).unwrap()
 105         };
 106
 107     server.run().await
 108 }
 109
 110 fn process_args() -> bool {
 111     fn print_usage() {
 112         println!("Usage:");
 113         println!(" {} [--help] [--status]", get_exe_name());
 114     }
 115
 116     let args: Vec<String> = args().collect();
 117
 118     if args.iter().any(|arg| arg == "--help") {
 119         print_usage();
 120         return true
 121     } else if args.iter().any(|arg| arg == "--status") {
 122         println!("{:?}", valheim_controller::get_valheim_executable_information());
 123         return true
 124     }
 125
 126     false
 127 }