server/src/main.rs

   1 extern crate lemmy_server;
   2 #[macro_use]
   3 extern crate diesel_migrations;
   4 #[macro_use]
   5 pub extern crate lazy_static;
   6
   7 pub type DbPool = Pool<ConnectionManager<PgConnection>>;
   8
   9 use crate::lemmy_server::actix_web::dev::Service;
  10 use actix::prelude::*;
  11 use actix_web::{
  12   body::Body,
  13   client::Client,
  14   dev::{ServiceRequest, ServiceResponse},
  15   http::{
  16     header::{CACHE_CONTROL, CONTENT_TYPE},
  17     HeaderValue,
  18   },
  19   *,
  20 };
  21 use diesel::{
  22   r2d2::{ConnectionManager, Pool},
  23   PgConnection,
  24 };
  25 use lemmy_db::get_database_url_from_env;
  26 use lemmy_server::{
  27   blocking,
  28   code_migrations::run_advanced_migrations,
  29   rate_limit::{rate_limiter::RateLimiter, RateLimit},
  30   routes::{api, federation, feeds, index, nodeinfo, webfinger},
  31   websocket::server::*,
  32   LemmyError,
  33 };
  34 use lemmy_utils::{settings::Settings, CACHE_CONTROL_REGEX};
  35 use std::sync::Arc;
  36 use tokio::sync::Mutex;
  37
  38 lazy_static! {
  39   // static ref CACHE_CONTROL_VALUE: String = format!("public, max-age={}", 365 * 24 * 60 * 60);
  40   // Test out 1 hour here, this is breaking some things
  41   static ref CACHE_CONTROL_VALUE: String = format!("public, max-age={}", 60 * 60);
  42 }
  43
  44 embed_migrations!();
  45
  46 #[actix_rt::main]
  47 async fn main() -> Result<(), LemmyError> {
  48   env_logger::init();
  49   let settings = Settings::get();
  50
  51   // Set up the r2d2 connection pool
  52   let db_url = match get_database_url_from_env() {
  53     Ok(url) => url,
  54     Err(_) => settings.get_database_url(),
  55   };
  56   let manager = ConnectionManager::<PgConnection>::new(&db_url);
  57   let pool = Pool::builder()
  58     .max_size(settings.database.pool_size)
  59     .build(manager)
  60     .unwrap_or_else(|_| panic!("Error connecting to {}", db_url));
  61
  62   // Run the migrations from code
  63   blocking(&pool, move |conn| {
  64     embedded_migrations::run(conn)?;
  65     run_advanced_migrations(conn)?;
  66     Ok(()) as Result<(), LemmyError>
  67   })
  68   .await??;
  69
  70   // Set up the rate limiter
  71   let rate_limiter = RateLimit {
  72     rate_limiter: Arc::new(Mutex::new(RateLimiter::default())),
  73   };
  74
  75   // Set up websocket server
  76   let server = ChatServer::startup(pool.clone(), rate_limiter.clone(), Client::default()).start();
  77
  78   println!(
  79     "Starting http server at {}:{}",
  80     settings.bind, settings.port
  81   );
  82
  83   // Create Http server with websocket support
  84   HttpServer::new(move || {
  85     let settings = Settings::get();
  86     let rate_limiter = rate_limiter.clone();
  87     App::new()
  88       .wrap_fn(add_cache_headers)
  89       .wrap(middleware::Logger::default())
  90       .data(pool.clone())
  91       .data(server.clone())
  92       .data(Client::default())
  93       // The routes
  94       .configure(move |cfg| api::config(cfg, &rate_limiter))
  95       .configure(federation::config)
  96       .configure(feeds::config)
  97       .configure(index::config)
  98       .configure(nodeinfo::config)
  99       .configure(webfinger::config)
 100       // static files
 101       .service(actix_files::Files::new(
 102         "/static",
 103         settings.front_end_dir.to_owned(),
 104       ))
 105       .service(actix_files::Files::new(
 106         "/docs",
 107         settings.front_end_dir + "/documentation",
 108       ))
 109   })
 110   .bind((settings.bind, settings.port))?
 111   .run()
 112   .await?;
 113
 114   Ok(())
 115 }
 116
 117 fn add_cache_headers<S>(
 118   req: ServiceRequest,
 119   srv: &mut S,
 120 ) -> impl Future<Output = Result<ServiceResponse, Error>>
 121 where
 122   S: Service<Request = ServiceRequest, Response = ServiceResponse<Body>, Error = Error>,
 123 {
 124   let fut = srv.call(req);
 125   async move {
 126     let mut res = fut.await?;
 127     if let Some(content_type) = res.headers().get(CONTENT_TYPE) {
 128       if CACHE_CONTROL_REGEX.is_match(content_type.to_str().unwrap()) {
 129         let header_val = HeaderValue::from_static(&CACHE_CONTROL_VALUE);
 130         res.headers_mut().insert(CACHE_CONTROL, header_val);
 131       }
 132     }
 133     Ok(res)
 134   }
 135 }