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::*,
  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(|cfg| api::config(cfg, &rate_limiter))
  95       .configure(federation::config)
  96       .configure(feeds::config)
  97       .configure(|cfg| images::config(cfg, &rate_limiter))
  98       .configure(index::config)
  99       .configure(nodeinfo::config)
 100       .configure(webfinger::config)
 101       // static files
 102       .service(actix_files::Files::new(
 103         "/static",
 104         settings.front_end_dir.to_owned(),
 105       ))
 106       .service(actix_files::Files::new(
 107         "/docs",
 108         settings.front_end_dir + "/documentation",
 109       ))
 110   })
 111   .bind((settings.bind, settings.port))?
 112   .run()
 113   .await?;
 114
 115   Ok(())
 116 }
 117
 118 fn add_cache_headers<S>(
 119   req: ServiceRequest,
 120   srv: &mut S,
 121 ) -> impl Future<Output = Result<ServiceResponse, Error>>
 122 where
 123   S: Service<Request = ServiceRequest, Response = ServiceResponse<Body>, Error = Error>,
 124 {
 125   let fut = srv.call(req);
 126   async move {
 127     let mut res = fut.await?;
 128     if let Some(content_type) = res.headers().get(CONTENT_TYPE) {
 129       if CACHE_CONTROL_REGEX.is_match(content_type.to_str().unwrap()) {
 130         let header_val = HeaderValue::from_static(&CACHE_CONTROL_VALUE);
 131         res.headers_mut().insert(CACHE_CONTROL, header_val);
 132       }
 133     }
 134     Ok(res)
 135   }
 136 }