src/main.rs

   1 extern crate actix_web;
   2 extern crate listenfd;
   3 extern crate askama;
   4
   5 use listenfd::ListenFd;
   6 use actix_files as fs;
   7 use actix_web::{web, middleware, App, HttpServer, HttpResponse, Responder, Result, web::Query};
   8 use askama::Template;
   9
  10 use ron::de::from_reader;
  11 use serde::Deserialize;
  12 use std::{fs::File, env::args};
  13
  14 use itertools::Itertools;
  15
  16 mod consts;
  17 mod crypto;
  18
  19 #[derive(Template)]
  20 #[template(path = "main.html")]
  21 struct MainTemplate<'a> {
  22     sentence: &'a str,
  23 }
  24
  25 #[derive(Deserialize)]
  26 pub struct Request {
  27    m: Option<String>
  28 }
  29
  30 static DEFAULT_MESSAGE: &str = "Marc, roule un pet'!";
  31 static KEY: &str = "secret";
  32
  33 fn main_page(query: Query<Request>) -> Result<HttpResponse> {
  34     let m =
  35         match &query.m {
  36             Some(b) =>
  37                 match crypto::decrypt(KEY, b) {
  38                     Some(m) => m,
  39                     None => String::from(DEFAULT_MESSAGE)
  40                 },
  41             None => String::from(DEFAULT_MESSAGE)
  42         };
  43
  44     let hello = MainTemplate { sentence: &m };
  45
  46     let s = hello.render().unwrap();
  47     Ok(HttpResponse::Ok().content_type("text/html").body(s))
  48 }
  49
  50 #[derive(Debug, Deserialize)]
  51 struct Config {
  52     port: u16
  53 }
  54
  55 fn get_exe_name() -> String {
  56     let first_arg = std::env::args().nth(0).unwrap();
  57     //dbg!(&first_arg);
  58     let sep: &[_] = &['\\', '/'];
  59     first_arg[first_arg.rfind(sep).unwrap()+1..].to_string()
  60 }
  61
  62 fn print_usage() {
  63     println!("Usage:");
  64     println!(" {} [--help] [--encrypt <message>]", get_exe_name());
  65 }
  66
  67 fn main() -> std::io::Result<()> {
  68     let args: Vec<String> = args().collect();
  69
  70     if args.iter().any(|arg| arg == "--help") {
  71         print_usage();
  72         return Ok(());
  73     } else if let Some((position_arg_encrypt, _)) = args.iter().find_position(|arg| arg == &"--encrypt") {
  74         match args.iter().nth(position_arg_encrypt + 1) {
  75             Some(mess_to_encrypt) => {
  76                 let encrypted_mess = mess_to_encrypt;
  77                 //let encrypted_mess = crypto::encrypt(key: &str, plain_text: &str);
  78                 println!("Encrypted message: {}", encrypted_mess);
  79             }
  80             None => print_usage()
  81         }
  82
  83         return Ok(());
  84     }
  85
  86     println!("Starting RUP as web server...");
  87
  88     let config: Config = {
  89         let f = File::open(consts::FILE_CONF).expect(&format!("Failed to open configuration file {}", consts::FILE_CONF));
  90         match from_reader(f) {
  91             Ok(c) => c,
  92             Err(e) => panic!("Failed to load config: {}", e)
  93         }
  94     };
  95
  96     let key = File::open(consts::FILE_KEY).expect(&format!("Failed to open key file: {}", consts::FILE_KEY));
  97
  98     println!("Configuration: {:?}", config);
  99
 100     let mut listenfd = ListenFd::from_env();
 101     let mut server =
 102         HttpServer::new(
 103             || {
 104                 App::new()
 105                     .wrap(middleware::Compress::default())
 106                     .wrap(middleware::Logger::default())
 107                     .service(web::resource("/").to(main_page))
 108                     .service(fs::Files::new("/static", "static").show_files_listing())
 109             }
 110         );
 111
 112     server =
 113         if let Some(l) = listenfd.take_tcp_listener(0).unwrap() {
 114             server.listen(l).unwrap()
 115         } else {
 116             server.bind(&format!("0.0.0.0:{}", config.port)).unwrap()
 117         };
 118
 119     server.run()
 120 }