artcraft/src/main.rs

#![allow(dead_code)]
#![allow(unused_mut)]
#![allow(unused_imports)]
#![warn(unused_must_use)]
//#![allow(warnings)]

#[macro_use] extern crate lazy_static;
#[macro_use] extern crate serde_derive;

pub mod common_queries;
pub mod endpoints;
pub mod server_state;
pub mod util;
pub mod validations;

use actix_cors::Cors;
use actix_http::http;
use log::{info};
use actix_web::middleware::{Logger, DefaultHeaders};
use actix_web::{HttpServer, web, HttpResponse, App};
use std::sync::Arc;
use crate::server_state::{ServerState, EnvConfig};
use sqlx::MySqlPool;
use sqlx::mysql::MySqlPoolOptions;
use crate::endpoints::users::create_account::create_account_handler;
use crate::endpoints::users::login::login_handler;
use crate::util::cookies::CookieManager;
use crate::endpoints::users::logout::logout_handler;
use crate::util::session_checker::SessionChecker;
use crate::endpoints::users::session_info::session_info_handler;

const DEFAULT_BIND_ADDRESS : &'static str = "0.0.0.0:12345";
const DEFAULT_RUST_LOG: &'static str = "debug,actix_web=info";

pub type AnyhowResult<T> = anyhow::Result<T>;

#[actix_web::main]
async fn main() -> AnyhowResult<()> {
  easyenv::init_all_with_default_logging(Some(DEFAULT_RUST_LOG));

  let server_hostname = hostname::get()
    .ok()
    .and_then(|h| h.into_string().ok())
    .unwrap_or("storyteller-web-unknown".to_string());

  let db_connection_string =
    easyenv::get_env_string_or_default(
      "MYSQL_URL",
      "mysql://root:root@localhost/storyteller");

  let pool = MySqlPoolOptions::new()
    .max_connections(5)
    .connect(&db_connection_string)
    .await?;

  let hmac_secret = easyenv::get_env_string_or_default("COOKIE_SECRET", "notsecret");
  let cookie_domain = easyenv::get_env_string_or_default("COOKIE_DOMAIN", ".vo.codes");

  let cookie_manager = CookieManager::new(&cookie_domain, &hmac_secret);
  let session_checker = SessionChecker::new(&cookie_manager);

  let server_state = ServerState {
    env_config: EnvConfig {
      num_workers: 4,
      bind_address: DEFAULT_BIND_ADDRESS.to_string(),
    },
    hostname: server_hostname,
    mysql_pool: pool,
    cookie_manager,
    session_checker,
  };

  serve(server_state)
    .await?;
  Ok(())
}

pub async fn serve(server_state: ServerState) -> AnyhowResult<()>
{
  let bind_address = server_state.env_config.bind_address.clone();
  let num_workers = server_state.env_config.num_workers.clone();
  let hostname = server_state.hostname.clone();

  let server_state_arc = web::Data::new(Arc::new(server_state));

  info!("Starting HTTP service.");

  let log_format = "[%{HOSTNAME}e] %a \"%r\" %s %b \"%{Referer}i\" \"%{User-Agent}i\" %T";

  HttpServer::new(move || {
    App::new()
      .app_data(server_state_arc.clone())
      .wrap(Cors::default()
        .allowed_origin("http://api.vo.codes")
        .allowed_origin("http://jungle.horse")
        .allowed_origin("http://localhost:12345")
        .allowed_origin("http://localhost:3000")
        .allowed_origin("http://localhost:5555")
        .allowed_origin("http://localhost:7000")
        .allowed_origin("http://localhost:8000")
        .allowed_origin("http://localhost:8080")
        .allowed_origin("http://mumble.stream")
        .allowed_origin("http://trumped.com")
        .allowed_origin("http://vo.codes")
        .allowed_origin("http://vocodes.com")
        .allowed_origin("https://jungle.horse")
        .allowed_origin("https://mumble.stream")
        .allowed_origin("https://trumped.com")
        .allowed_origin("https://vo.codes")
        .allowed_origin("https://vocodes.com")
        .allowed_methods(vec!["GET", "POST", "OPTIONS"])
        .allowed_headers(vec![
          http::header::ACCEPT,
          http::header::ACCESS_CONTROL_ALLOW_ORIGIN, // Tabulator Ajax
          http::header::CONTENT_TYPE,
          http::header::HeaderName::from_static("x-requested-with") // Tabulator Ajax sends
        ])
        .max_age(3600))
      .wrap(Logger::new(&log_format)
        .exclude("/liveness")
        .exclude("/readiness"))
      .wrap(DefaultHeaders::new()
        .header("X-Backend-Hostname", &hostname)
        .header("X-Build-Sha", ""))
      .service(
        web::resource("/create_account")
          .route(web::post().to(create_account_handler))
          .route(web::head().to(|| HttpResponse::Ok()))
      )
      .service(
        web::resource("/login")
          .route(web::post().to(login_handler))
          .route(web::head().to(|| HttpResponse::Ok()))
      )
      .service(
        web::resource("/logout")
          .route(web::post().to(logout_handler))
          .route(web::head().to(|| HttpResponse::Ok()))
      )
      .service(
        web::resource("/session")
          .route(web::get().to(session_info_handler))
          .route(web::head().to(|| HttpResponse::Ok()))
      )
      .service(
        web::scope("/foo")
          .service(
            web::resource("/bar")
              .route(web::get().to(|| HttpResponse::Ok()))
              .route(web::head().to(|| HttpResponse::Ok()))
          )
          .service(
            web::resource("/bin")
              .route(web::get().to(|| HttpResponse::Ok()))
              .route(web::head().to(|| HttpResponse::Ok()))
          )
      )
      .service(
        web::scope("/a")
          .service(
            web::resource("/b")
              .route(web::get().to(|| HttpResponse::Ok()))
              .route(web::head().to(|| HttpResponse::Ok()))
          )
          .service(
            web::resource("/c")
              .route(web::get().to(|| HttpResponse::Ok()))
              .route(web::head().to(|| HttpResponse::Ok()))
          )
      )
  })
  .bind(bind_address)?
  .workers(num_workers)
  .run()
  .await?;

  // Admin UI & old frontend
  //.service(Files::new("/frontend", admin_asset_directory.clone())
  //  .index_file("FAKE_INDEX.HTML"))
  //.service(Files::new("/adminui", admin_asset_directory.clone())
  //  .index_file("index.html"))
  // Early access static path for assets
  //.service(Files::new("/static", static_asset_directory.clone())
  //  .index_file("FAKE_INDEX.HTML"))
  /*.service(get_liveness)
  .service(get_models)
  .service(get_readiness)
  .service(get_root)
  .service(get_sentences)
  .service(get_service_settings)
  .service(get_speakers)
  .service(get_early_access_speakers)
  .service(get_dynamic_early_access_speakers)
  .service(get_words);*/

  Ok(())
}