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 = String::from("hello");
  34     MainTemplate { sentence: m }
  35 }
  36
  37 #[derive(Debug, Deserialize, Serialize)]
  38 struct Config {
  39     port: u16
  40 }
  41
  42 const DEFAULT_CONFIG: Config = Config { port: 8082 };
  43
  44 fn get_exe_name() -> String {
  45     let first_arg = std::env::args().next().unwrap();
  46     let sep: &[_] = &['\\', '/'];
  47     first_arg[first_arg.rfind(sep).unwrap()+1..].to_string()
  48 }
  49
  50 fn load_config() -> Config {
  51     // unwrap_or_else(|_| panic!("Failed to open configuration file {}", consts::FILE_CONF));
  52     match File::open(consts::FILE_CONF) {
  53         Ok(file) => from_reader(file).unwrap_or_else(|_| panic!("Failed to open configuration file {}", consts::FILE_CONF)),
  54         Err(_) => {
  55             let mut file = File::create(consts::FILE_CONF) .unwrap();
  56             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.
  57             DEFAULT_CONFIG
  58         }
  59     }
  60 }
  61
  62 #[actix_rt::main]
  63 async fn main() -> std::io::Result<()> {
  64
  65     if process_args() { return Ok(()) }
  66
  67     println!("Starting RUP as web server...");
  68
  69     let config = load_config();
  70
  71     println!("Configuration: {:?}", config);
  72
  73     let mut listenfd = ListenFd::from_env();
  74     let mut server =
  75         HttpServer::new(
  76             move || {
  77                 App::new()
  78                     // .app_data(key_shared.clone())
  79                     .wrap(middleware::Compress::default())
  80                     .wrap(middleware::Logger::default())
  81                     .service(main_page)
  82                     .service(fs::Files::new("/static", "static").show_files_listing())
  83             }
  84         );
  85
  86     server =
  87         if let Some(l) = listenfd.take_tcp_listener(0).unwrap() {
  88             server.listen(l).unwrap()
  89         } else {
  90             server.bind(&format!("0.0.0.0:{}", config.port)).unwrap()
  91         };
  92
  93     server.run().await
  94 }
  95
  96 fn process_args() -> bool {
  97     fn print_usage() {
  98         println!("Usage:");
  99         println!(" {} [--help] [--status]", get_exe_name());
 100     }
 101
 102     let args: Vec<String> = args().collect();
 103
 104     if args.iter().any(|arg| arg == "--help") {
 105         print_usage();
 106         return true
 107     } else if args.iter().any(|arg| arg == "--status") {
 108         valheim_controller::is_valheim_running();
 109         return true
 110     }
 111
 112     false
 113 }