lexa_framework/server/

mod.rs

// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
// ┃ Copyright: (c) 2023, Mike 'PhiSyX' S. (https://github.com/PhiSyX)         ┃
// ┃ SPDX-License-Identifier: MPL-2.0                                          ┃
// ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
// ┃                                                                           ┃
// ┃  This Source Code Form is subject to the terms of the Mozilla Public      ┃
// ┃  License, v. 2.0. If a copy of the MPL was not distributed with this      ┃
// ┃  file, You can obtain one at https://mozilla.org/MPL/2.0/.                ┃
// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛

mod error;
pub mod settings;
mod components {
	#[cfg(feature = "cookies")]
	pub(super) mod cookies;
	#[cfg(feature = "cors")]
	pub(super) mod cors;
	#[cfg(feature = "database-postgres")]
	pub(super) mod database_postgres;
	#[cfg(feature = "encryption-argon2")]
	pub(super) mod encryption_argon2;
}

use std::net;

use console::style;

pub use self::error::Error;
use crate::{routing, state};

// -------- //
// Constant //
// -------- //

pub const PORT_PLAINTEXT: u16 = 80;
pub const PORT_ENCRYPT: u16 = 443;

// --------- //
// Structure //
// --------- //

pub struct Server<UserState> {
	pub state: crate::state::State<UserState>,

	pub application_settings: crate::application::Settings,
	pub(crate) settings: settings::Settings,
	#[cfg(feature = "cors")]
	pub(crate) cors_settings: Option<crate::http::cors::Settings>,

	global_router: axum::Router<()>,
	pub(crate) router: axum::Router<crate::state::State<UserState>>,
	pub(crate) routes: crate::routing::RouteCollection<UserState>,
	static_resources: Vec<settings::SettingsStaticResource>,
}

// -------------- //
// Implémentation //
// -------------- //

impl<UserState> Server<UserState>
where
	UserState: 'static,
	UserState: crate::state::StateInterface,
{
	/// Instancie un serveur.
	pub async fn new(
		application_settings: crate::application::Settings,
	) -> Result<Self, Error> {
		let state = crate::state::State {
			#[cfg(feature = "cookies")]
			cookie_key: None,
			#[cfg(feature = "database-postgres")]
			database_postgres: None,
			user_state: None,
		};

		let settings = settings::Settings::fetch_or_default(
			&application_settings.config_dir,
			&application_settings.loader_extension,
		);

		let static_resources = settings
			.static_resources
			.iter()
			.cloned()
			.map(|mut sr| {
				sr.dir_path = if sr.dir_path.is_relative() {
					application_settings.root_dir.join(&sr.dir_path)
				} else {
					sr.dir_path.to_owned()
				};
				sr
			})
			.collect();

		Ok(Self {
			state,
			#[cfg(feature = "cors")]
			cors_settings: {
				lexa_fs::load(
					&application_settings.config_dir,
					"cors",
					application_settings.loader_extension,
				)
				.ok()
			},
			application_settings,
			settings,
			global_router: axum::Router::new(),
			router: axum::Router::new(),
			routes: routing::RouteCollection::new(),
			static_resources,
		})
	}

	pub fn layer<Layer>(mut self, layer: Layer) -> Self
	where
		Layer: Clone + Send + Sync + 'static,
		Layer: tower_layer::Layer<axum::routing::Route>,
		Layer::Service: tower_service::Service<
			hyper::Request<hyper::Body>,
			Error = std::convert::Infallible,
		>,
		Layer::Service: Clone + Send + 'static,
		<Layer::Service as tower_service::Service<
			hyper::Request<hyper::Body>,
		>>::Response: axum::response::IntoResponse + 'static,
		<Layer::Service as tower_service::Service<
			hyper::Request<hyper::Body>,
		>>::Future: Send + 'static,
	{
		self.router = self.router.layer(layer);
		self
	}

	/// Crée une application qui est scopée pour le serveur.
	pub fn make_application<A>(mut self) -> Self
	where
		A: crate::Application<State = UserState>,
	{
		let routes = <A::Router as routing::RouterExt>::routes();
		let routes_state =
			<A::Router as routing::RouterExt>::routes_with_state(&self.state);

		let mut scoped_router = axum::Router::<state::State<UserState>>::new();

		for route in routes.all().chain(routes_state.all()) {
			scoped_router =
				scoped_router.route(&route.fullpath, route.action.to_owned());
		}

		scoped_router = A::register_extension(&self.state, scoped_router);
		scoped_router = A::register_layer(&self.state, scoped_router);
		scoped_router = A::register_middleware(&self.state, scoped_router);

		self.router = self.router.merge(scoped_router);
		self.routes.extend(routes);
		self.routes.extend(routes_state);

		A::register_service(self)
	}

	/// Démarre un serveur WEB avec ses composants. En se basant sur les
	/// configurations de l'utilisateur.
	///
	/// À terme:
	/// Pendant la phase de développement, une interface textuelle interactive y
	/// est également lancée, afin de:
	///  1) Apporter un peu d'aide visuelle à l'utilisateur.
	///  2) Afin d'accéder à la base de données pour y faire des modifications.
	///  3) Afin de pouvoir tester les requêtes HTTP.
	pub async fn run(mut self) -> Result<(), Error> {
		self.display_all_routes();

		self = self.define_static_resources();

		#[cfg(feature = "cors")]
		{
			self = self.using_cors_layer();
		}

		#[cfg(feature = "cookies")]
		{
			self = self.using_cookie_layer().await?;
		}

		self.launch_server().await?;

		Ok(())
	}

	/// Définit les paramètres utilisateur de l'état.
	pub fn with_user_state(mut self, data: UserState::UserData) -> Self {
		self.state.user_state.replace(UserState::new(data));
		self
	}
}

impl<UserState> Server<UserState>
where
	UserState: 'static,
	UserState: crate::state::StateInterface,
{
	fn define_static_resources(mut self) -> Self {
		for static_resource in self.static_resources.iter() {
			self.global_router = self.global_router.nest_service(
				&static_resource.url_path,
				tower_http::services::ServeDir::new(&static_resource.dir_path),
			);
		}

		self
	}

	fn display_all_routes(&self) {
		println!();
		println!("Liste des routes du serveur web:");
		for route in self.routes.all() {
			let methods = route
				.methods
				.iter()
				.map(|m| style(&m).yellow().to_string())
				.collect::<Vec<String>>()
				.join(" | ");

			println!(
				"\t[{}]: {} {}",
				methods,
				style(&route.fullpath).bright().green(),
				if let Some(name) = route.name.as_deref() {
					format!("as {}", style(name).bright().black())
				} else {
					String::new()
				}
			);
		}
		println!();

		for static_resource in self.static_resources.iter() {
			println!(
				"\t[{}]: {} -> {}",
				style("STATIC RESOURCE").magenta(),
				style(&static_resource.url_path).bright().green(),
				style(static_resource.dir_path.display()).bright().black(),
			);
		}
	}

	async fn launch_server(mut self) -> Result<(), Error> {
		log::info!("Tentative de lancement du serveur web...");

		self.global_router =
			self.global_router.merge(self.router.with_state(self.state));

		let protocol = if self.settings.tls.is_some() {
			"https"
		} else {
			"http"
		};
		let host = self.settings.host;
		let port = self.settings.port;

		let server_socket_addr =
			<_ as Into<net::SocketAddr>>::into((host, port));

		let port_with_prefix = if port == PORT_PLAINTEXT || port == PORT_ENCRYPT
		{
			String::new()
		} else {
			format!(":{}", port)
		};

		let url = format!("{protocol}://{host}{port_with_prefix}");
		type S = net::SocketAddr;
		println!("URL: {url}");

		if let Some(settings_tls) = self.settings.tls {
			let tls_config =
				axum_server::tls_rustls::RustlsConfig::from_pem_file(
					&settings_tls.cert,
					&settings_tls.key,
				)
				.await?;

			let http_config =
				axum_server::HttpConfig::new().http2_only(true).build();

			axum_server::bind_rustls(server_socket_addr, tls_config)
				.http_config(http_config)
				.serve(
					self.global_router
						.into_make_service_with_connect_info::<S>(),
				)
				.await?;
		} else {
			axum::Server::bind(&server_socket_addr)
				.serve(
					self.global_router
						.into_make_service_with_connect_info::<S>(),
				)
				.await?;
		}

		Ok(())
	}
}