crates/app/Cargo.toml

@@ -16,6 +16,8 @@ tokio = { version = "1.39.1", features = ["macros", "rt-multi-thread"] }
 tower-http = { version = "0.5.2", features = ["fs"] }
 tower-livereload = "0.9.3"
 
+utils = { path = "../utils" }
+
 [dev-dependencies]
 cargo-watch = "8.5.1"
 systemfd = "0.4.0"

crates/app/src/lib.rs

@@ -2,8 +2,13 @@ use std::path::PathBuf;
 
 use axum::http::{StatusCode, Uri};
 use axum_htmx::AutoVaryLayer;
+use thiserror::Error;
 use tower_http::services::ServeDir;
 
+use ::utils::config::{load_config, ConfigError};
+
+pub mod db;
+
 mod menu;
 mod pages;
 
@@ -11,6 +16,18 @@ async fn fallback(uri: Uri) -> (StatusCode, String) {
     (StatusCode::NOT_FOUND, format!("No route for {uri}"))
 }
 
+#[derive(Error, Debug)]
+pub enum InitError {
+    #[error(transparent)]
+    ConfigError(#[from] ConfigError),
+}
+
+pub fn init() -> Result<(), InitError> {
+    load_config(None)?;
+    Ok(())
+}
+
+
 pub async fn get_router(assets_path: PathBuf) -> axum::Router<()> {
     axum::Router::new()
         .nest_service("/assets", ServeDir::new(assets_path))

crates/app/src/main.rs

@@ -10,7 +10,7 @@ use tokio::net::TcpListener;
 use tower_livereload::predicate::Predicate;
 use tower_livereload::LiveReloadLayer;
 
-use ::app::get_router;
+use ::app::{get_router, init, InitError};
 
 #[derive(Error, Debug)]
 pub enum AppError {
@@ -20,6 +20,8 @@ pub enum AppError {
     NotifyWatcher(#[from] notify::Error),
     #[error("Missing environment variable {var}")]
     MissingEnvVar { var: &'static str },
+    #[error("Error while initialising the app")]
+    Initialisation(#[from] InitError),
 }
 
 /// Nous filtrons les requêtes de `htmx` pour ne pas inclure le script _JS_ qui gère le rechargement
@@ -61,6 +63,8 @@ fn get_livereload_layer(
 
 #[tokio::main]
 async fn main() -> Result<(), AppError> {
+    init()?;
+
     let manifest_dir = env::var("CARGO_MANIFEST_DIR").map_err(|_| AppError::MissingEnvVar {
         var: "CARGO_MANIFEST_DIR",
     })?;

crates/backend/Cargo.toml

@@ -7,8 +7,11 @@ edition = "2021"
 anyhow = "1.0.89"
 axum = "0.7.6"
 listenfd = "1.0.1"
+thiserror.workspace = true
 tokio = { version = "1.40.0", features = ["macros", "rt-multi-thread"] }
 
+utils = { path = "../utils" }
+
 [dev-dependencies]
 cargo-watch = "8.5.2"
 systemfd = "0.4.3"

crates/backend/src/lib.rs

@@ -2,6 +2,20 @@ use anyhow::Error as AnyError;
 use axum::http::{StatusCode, Uri};
 use axum::response::{IntoResponse, Response};
 use axum::{routing::get, Router};
+use thiserror::Error;
+
+use ::utils::config::{load_config, ConfigError};
+
+#[derive(Error, Debug)]
+pub enum InitError {
+    #[error(transparent)]
+    ConfigError(#[from] ConfigError),
+}
+
+pub fn init() -> Result<(), InitError> {
+    load_config(None)?;
+    Ok(())
+}
 
 pub fn get_router() -> Router {
     Router::new()

crates/backend/src/main.rs

@@ -1,24 +1,38 @@
 use listenfd::ListenFd;
+use thiserror::Error;
 use tokio::net::TcpListener;
 
-use backend::get_router;
+use backend::{get_router, init, InitError};
+
+#[derive(Error, Debug)]
+pub enum BackendError {
+    #[error("Error while setting up or serving the TCP listener")]
+    ServeTCPListener(#[from] std::io::Error),
+    #[error("Error while initialising the backend")]
+    InitError(#[from] InitError),
+}
 
 #[tokio::main]
-async fn main() {
+async fn main() -> Result<(), BackendError> {
+    init()?;
+
     let app = get_router();
 
     let mut listenfd = ListenFd::from_env();
 
-    let listener = match listenfd.take_tcp_listener(0).unwrap() {
+    let listener = match listenfd.take_tcp_listener(0)? {
         // if we are given a tcp listener on listen fd 0, we use that one
         Some(listener) => {
-            listener.set_nonblocking(true).unwrap();
-            TcpListener::from_std(listener).unwrap()
+            listener.set_nonblocking(true)?;
+            TcpListener::from_std(listener)?
         }
         // otherwise fall back to local listening
-        None => TcpListener::bind("0.0.0.0:8080").await.unwrap(),
+        None => TcpListener::bind("0.0.0.0:8080").await?,
     };
 
-    println!("Listening on {}", listener.local_addr().unwrap());
-    axum::serve(listener, app).await.unwrap();
+    let local_addr = listener.local_addr()?;
+    println!("Listening on {}", local_addr);
+    axum::serve(listener, app).await?;
+
+    Ok(())
 }