backend/src/main.rs

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