fix: Initialize DB when it doesn't exist

Cargo.lock

@@ -39,6 +39,17 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "async-trait"
+version = "0.1.92"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82f6aeea286b8eb4dd3431a1be1b59d290ace00f5bfd8e2a159bc2a05e2c1667"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 3.0.4",
+]
+
 [[package]]
 name = "atomic-waker"
 version = "1.1.2"
@@ -169,6 +180,9 @@ name = "camino"
 version = "1.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bb1307f12aa967b5a58416e87b3653360e0fd614a016b6e970db08fecbb1b80d"
+dependencies = [
+ "serde_core",
+]
 
 [[package]]
 name = "cc"
@@ -520,6 +534,7 @@ name = "llldap"
 version = "0.1.0"
 dependencies = [
  "argh",
+ "async-trait",
  "axum",
  "axum-extra",
  "camino",
@@ -530,6 +545,7 @@ dependencies = [
  "minijinja",
  "minijinja-embed",
  "serde",
+ "serde_json",
  "static-serve",
  "tokio",
  "tokio-util",

Cargo.toml

@@ -5,9 +5,10 @@ edition = "2024"
 
 [dependencies]
 argh = "0.1.19"
+async-trait = "0.1.92"
 axum = { version = "0.8.9", optional = true, features = ["macros"] }
 axum-extra = { version = "0.12.6", features = ["cookie"], optional = true }
-camino = "1.2.5"
+camino = { version = "1.2.5", features = ["serde1"] }
 dn_escape = { path = "vendor/dn_escape" }
 futures-util = { version = "0.3.34", features = ["sink"] }
 http = { version = "1.5.0", optional = true }
@@ -15,6 +16,7 @@ ldap3_proto = "0.8.1"
 minijinja = { version = "2.24.0", optional = true }
 minijinja-embed = { version = "2.24.0", optional = true }
 serde = { version = "1.0.229", features = ["derive"] }
+serde_json = "1.0.151"
 static-serve = { version = "0.6.3", optional = true }
 tokio = { version = "1.53.1", features = ["macros", "net", "rt", "time", "sync"] }
 tokio-util = { version = "0.7.19", features = ["codec"] }

src/cli.rs

@@ -1,8 +1,13 @@
 use argh::FromArgs;
+use camino::Utf8PathBuf;
 
 /// Run the llldap server
 #[derive(FromArgs)]
 pub struct CliArgs {
+    /// path to the JSON file for the database
+    #[argh(option)]
+    pub db: Option<Utf8PathBuf>,
+
     /// address or socket to listen on for LDAP connections
     #[argh(option, default = "String::from(\"127.0.0.1:3389\")")]
     pub listen_ldap: String,

src/db/common.rs

@@ -6,19 +6,19 @@ use crate::db::error::BoxedError;
 use crate::db::{DatabaseInterface, Domain, User, UserRef};
 
 #[derive(Clone, Debug)]
-pub struct Database<D: DatabaseInterface> {
-    pub inner: Arc<RwLock<D>>,
+pub struct Database {
+    pub inner: Arc<RwLock<Box<dyn DatabaseInterface>>>,
 }
 
-impl<D: DatabaseInterface> Database<D> {
-    pub fn new(db: D) -> Self {
+impl Database {
+    pub fn new(db: impl DatabaseInterface) -> Self {
         Self {
-            inner: Arc::new(RwLock::new(db)),
+            inner: Arc::new(RwLock::new(Box::new(db))),
         }
     }
 }
 
-impl<D: DatabaseInterface> Database<D> {
+impl Database {
     /// Return false if the user doesn't exist, or the password is wrong.
     ///
     /// TODO: should we return something else when the account doesn't exist?

src/db/domain.rs

@@ -1,6 +1,6 @@
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 
-#[derive(Clone, Debug, Default, Serialize)]
+#[derive(Clone, Debug, Default, Deserialize, Serialize)]
 pub struct Domain {
     pub name: String,
 }

src/db/filesystem.rs

@@ -0,0 +1,156 @@
+use camino::{Utf8Path, Utf8PathBuf};
+use serde::{Deserialize, Serialize};
+use serde_json::Error as JsonError;
+
+use std::fmt;
+use std::io::Error as IOError;
+
+use crate::db::error::{BoxedError, DomainCreationError, UserCreationError};
+use crate::db::{Database, DatabaseInterface, Domain, MemoryDatabase, User, UserRef};
+
+#[derive(Debug)]
+pub enum FilesystemDatabaseError {
+    ReadFileIO(Utf8PathBuf, IOError),
+    ReadFileJson(Utf8PathBuf, JsonError),
+    WriteFileIO(Utf8PathBuf, IOError),
+    WriteFileJson(Utf8PathBuf, JsonError),
+}
+
+impl fmt::Display for FilesystemDatabaseError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                Self::ReadFileIO(path, e) => format!("Failed to read database file {path}: {e}"),
+                Self::ReadFileJson(path, e) =>
+                    format!("Failed to parse database JSON file {path}: {e}"),
+                Self::WriteFileIO(path, e) => format!("Failed to write database file {path}: {e}"),
+                Self::WriteFileJson(path, e) =>
+                    format!("Failed to convert database to JSON file {path}: {e}"),
+            }
+        )
+    }
+}
+
+impl std::error::Error for FilesystemDatabaseError {}
+
+#[derive(Clone, Debug, Default, Deserialize, Serialize)]
+pub struct FilesystemDatabase {
+    // TODO: Once we have common validation steps in place across DB backends, we can reduce cloning.
+    //       For now, we clone the DB on every write operation, and update it when saving to disk
+    //       succeeds.
+    pub inner: MemoryDatabase,
+    pub path: Utf8PathBuf,
+}
+
+impl FilesystemDatabase {
+    pub async fn from_path(path: impl AsRef<Utf8Path>) -> Result<Database, BoxedError> {
+        let path = path.as_ref();
+
+        if !tokio::fs::try_exists(path)
+            .await
+            .map_err(|e| Box::new(FilesystemDatabaseError::ReadFileIO(path.to_path_buf(), e)))?
+        {
+            // The database doesn't exist yet, we create an empty one and try to write it
+            // to make sure the permissions are correct and the destination folder exists.
+            let mut db = Self {
+                inner: MemoryDatabase::default(),
+                path: path.to_path_buf(),
+            };
+
+            db.save().await?;
+            return Ok(Database::new(db));
+        }
+
+        let s = tokio::fs::read(path)
+            .await
+            .map_err(|e| Box::new(FilesystemDatabaseError::ReadFileIO(path.to_path_buf(), e)))?;
+        let inner: MemoryDatabase = serde_json::from_slice(&s)
+            .map_err(|e| Box::new(FilesystemDatabaseError::ReadFileJson(path.to_path_buf(), e)))?;
+        Ok(Database::new(Self {
+            inner,
+            path: path.to_path_buf(),
+        }))
+    }
+
+    pub async fn save(&mut self) -> Result<(), BoxedError> {
+        let s = serde_json::to_string(&self)
+            .map_err(|e| Box::new(FilesystemDatabaseError::WriteFileJson(self.path.clone(), e)))?;
+        Ok(tokio::fs::write(&self.path, &s)
+            .await
+            .map_err(|e| Box::new(FilesystemDatabaseError::WriteFileIO(self.path.clone(), e)))?)
+    }
+}
+
+#[async_trait::async_trait]
+impl DatabaseInterface for FilesystemDatabase {
+    async fn create_domain(
+        &mut self,
+        domain: &str,
+    ) -> Result<Result<(), DomainCreationError>, BoxedError> {
+        let mut new_db = self.inner.clone();
+
+        if let Err(e) = new_db.create_domain(domain).await? {
+            return Ok(Err(e));
+        }
+
+        self.save().await?;
+        self.inner = new_db;
+
+        Ok(Ok(()))
+    }
+
+    async fn get_domain(&self, domain: &str) -> Result<Option<Domain>, BoxedError> {
+        self.inner.get_domain(domain).await
+    }
+
+    async fn get_user(&self, req_user: &UserRef) -> Result<Option<User>, BoxedError> {
+        self.inner.get_user(req_user).await
+    }
+
+    async fn create_user(
+        &mut self,
+        user: User,
+    ) -> Result<Result<(), UserCreationError>, BoxedError> {
+        let mut new_db = self.inner.clone();
+
+        if let Err(e) = new_db.create_user(user).await? {
+            return Ok(Err(e));
+        }
+
+        self.save().await?;
+        self.inner = new_db;
+
+        Ok(Ok(()))
+    }
+
+    async fn try_create_user(
+        &mut self,
+        new_user: User,
+        current_user: &User,
+    ) -> Result<Result<(), UserCreationError>, BoxedError> {
+        let mut new_db = self.inner.clone();
+
+        if let Err(e) = new_db.try_create_user(new_user, current_user).await? {
+            return Ok(Err(e));
+        }
+
+        self.save().await?;
+        self.inner = new_db;
+
+        Ok(Ok(()))
+    }
+
+    async fn list_all_domains(&self) -> Result<Vec<Domain>, BoxedError> {
+        self.inner.list_all_domains().await
+    }
+
+    async fn list_all_users(&self) -> Result<Vec<User>, BoxedError> {
+        self.inner.list_all_users().await
+    }
+
+    async fn list_domain_users(&self, domain: Option<String>) -> Result<Vec<User>, BoxedError> {
+        self.inner.list_domain_users(domain).await
+    }
+}

src/db/group.rs

@@ -1,7 +1,7 @@
-#[derive(Clone, Debug)]
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct Group {
-    #[expect(unused)]
     name: String,
-    #[expect(unused)]
     domain: String,
 }

src/db/interface.rs

@@ -1,7 +1,8 @@
 use crate::db::error::{BoxedError, DomainCreationError, UserCreationError};
 use crate::db::{Database, Domain, User, UserRef};
 
-impl<D: DatabaseInterface> DatabaseInterface for Database<D> {
+#[async_trait::async_trait]
+impl DatabaseInterface for Database {
     async fn create_domain(
         &mut self,
         domain: &str,
@@ -49,39 +50,31 @@ impl<D: DatabaseInterface> DatabaseInterface for Database<D> {
     }
 }
 
-pub trait DatabaseInterface: Clone + Send + Sync + 'static {
-    fn create_domain(
+#[async_trait::async_trait]
+pub trait DatabaseInterface: std::fmt::Debug + Send + Sync + 'static {
+    async fn create_domain(
         &mut self,
         domain: &str,
-    ) -> impl Future<Output = Result<Result<(), DomainCreationError>, BoxedError>> + Send;
-    fn get_domain(
-        &self,
-        domain: &str,
-    ) -> impl Future<Output = Result<Option<Domain>, BoxedError>> + Send;
+    ) -> Result<Result<(), DomainCreationError>, BoxedError>;
+    async fn get_domain(&self, domain: &str) -> Result<Option<Domain>, BoxedError>;
 
-    fn get_user(
-        &self,
-        user: &UserRef,
-    ) -> impl std::future::Future<Output = Result<Option<User>, BoxedError>> + Send;
+    async fn get_user(&self, user: &UserRef) -> Result<Option<User>, BoxedError>;
     async fn create_user(
         &mut self,
         user: User,
     ) -> Result<Result<(), UserCreationError>, BoxedError>;
-    fn try_create_user(
+    async fn try_create_user(
         &mut self,
         new_user: User,
         current_user: &User,
-    ) -> impl Future<Output = Result<Result<(), UserCreationError>, BoxedError>> + Send;
+    ) -> Result<Result<(), UserCreationError>, BoxedError>;
 
-    fn list_all_domains(&self) -> impl Future<Output = Result<Vec<Domain>, BoxedError>> + Send;
+    async fn list_all_domains(&self) -> Result<Vec<Domain>, BoxedError>;
     #[expect(unused)]
-    fn list_all_users(&self) -> impl Future<Output = Result<Vec<User>, BoxedError>> + Send;
+    async fn list_all_users(&self) -> Result<Vec<User>, BoxedError>;
 
     /// List users on a specific domain.
     ///
     /// A `None` domain requested lists global service users.
-    fn list_domain_users(
-        &self,
-        domain: Option<String>,
-    ) -> impl std::future::Future<Output = Result<Vec<User>, BoxedError>> + Send;
+    async fn list_domain_users(&self, domain: Option<String>) -> Result<Vec<User>, BoxedError>;
 }

src/db/memory.rs

@@ -1,64 +1,60 @@
-use std::future::{Future, ready};
+use serde::{Deserialize, Serialize};
 
 use crate::db::error::{BoxedError, DomainCreationError, UserCreationError};
 use crate::db::{Database, DatabaseInterface, Domain, Group, Operation, User, UserRef};
 
-#[derive(Clone, Debug, Default)]
+#[derive(Clone, Debug, Default, Deserialize, Serialize)]
 pub struct MemoryDatabase {
     // We store data in tables like in SQL
     pub domains: Vec<Domain>,
-    #[expect(unused)]
     pub groups: Vec<Group>,
     pub users: Vec<User>,
 }
 
 impl MemoryDatabase {
-    pub fn new() -> Database<Self> {
+    #[allow(clippy::new_ret_no_self)]
+    pub fn new() -> Database {
         Database::new(Self::default())
     }
 }
 
+#[async_trait::async_trait]
 impl DatabaseInterface for MemoryDatabase {
-    fn create_domain(
+    async fn create_domain(
         &mut self,
         domain: &str,
-    ) -> impl Future<Output = Result<Result<(), DomainCreationError>, BoxedError>> {
+    ) -> Result<Result<(), DomainCreationError>, BoxedError> {
         if domain.is_empty() {
-            return ready(Ok(Err(DomainCreationError::InvalidDomain(
-                domain.to_string(),
-            ))));
+            return Ok(Err(DomainCreationError::InvalidDomain(domain.to_string())));
         }
 
         if self.domains.iter().find(|d| d.name == domain).is_some() {
-            return ready(Ok(Err(DomainCreationError::DomainAlreadyExists(
+            return Ok(Err(DomainCreationError::DomainAlreadyExists(
                 domain.to_string(),
-            ))));
+            )));
         }
 
         self.domains.push(Domain {
             name: domain.to_string(),
         });
 
-        ready(Ok(Ok(())))
+        Ok(Ok(()))
     }
 
-    fn get_domain(&self, domain: &str) -> impl Future<Output = Result<Option<Domain>, BoxedError>> {
+    async fn get_domain(&self, domain: &str) -> Result<Option<Domain>, BoxedError> {
         let Some(domain) = self.domains.iter().find(|d| d.name == domain) else {
-            return ready(Ok(None));
+            return Ok(None);
         };
 
-        ready(Ok(Some(domain.clone())))
+        Ok(Some(domain.clone()))
     }
 
-    fn get_user(
-        &self,
-        req_user: &UserRef,
-    ) -> impl Future<Output = Result<Option<User>, BoxedError>> {
-        ready(Ok(self
+    async fn get_user(&self, req_user: &UserRef) -> Result<Option<User>, BoxedError> {
+        Ok(self
             .users
             .iter()
             .find(|u| u.username == req_user.username && u.domain == req_user.domain)
-            .cloned()))
+            .cloned())
     }
 
     async fn create_user(
@@ -103,23 +99,20 @@ impl DatabaseInterface for MemoryDatabase {
         self.create_user(new_user).await
     }
 
-    fn list_all_domains(&self) -> impl Future<Output = Result<Vec<Domain>, BoxedError>> {
-        ready(Ok(self.domains.clone()))
+    async fn list_all_domains(&self) -> Result<Vec<Domain>, BoxedError> {
+        Ok(self.domains.clone())
     }
 
-    fn list_all_users(&self) -> impl Future<Output = Result<Vec<User>, BoxedError>> {
-        ready(Ok(self.users.clone()))
+    async fn list_all_users(&self) -> Result<Vec<User>, BoxedError> {
+        Ok(self.users.clone())
     }
 
-    fn list_domain_users(
-        &self,
-        domain: Option<String>,
-    ) -> impl Future<Output = Result<Vec<User>, BoxedError>> {
-        ready(Ok(self
+    async fn list_domain_users(&self, domain: Option<String>) -> Result<Vec<User>, BoxedError> {
+        Ok(self
             .users
             .iter()
             .filter(|u| u.domain == domain)
             .cloned()
-            .collect()))
+            .collect())
     }
 }

src/db/mod.rs

@@ -3,6 +3,8 @@ pub use common::Database;
 mod domain;
 pub use domain::Domain;
 pub mod error;
+mod filesystem;
+pub use filesystem::FilesystemDatabase;
 mod group;
 pub use group::Group;
 mod interface;

src/db/role.rs

@@ -1,4 +1,4 @@
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 
 #[derive(Clone, Debug)]
 pub enum Operation {
@@ -7,12 +7,11 @@ pub enum Operation {
     ListUsers(Option<String>),
 }
 
-#[derive(Clone, Debug, PartialEq, Serialize)]
+#[derive(Clone, Debug, PartialEq, Deserialize, Serialize)]
 pub enum Role {
     /// Can do anything
     Admin,
     /// Can only read data across all vhosts
-    #[expect(unused)]
     ReadonlyAdmin,
     /// Can do anything on a domain, except removing
     /// oneself as a domain admin.
@@ -20,7 +19,6 @@ pub enum Role {
     /// Can not give away roles other than DomainModerator/User
     DomainAdmin(String),
     /// Can create users and reset passwords on a domain
-    #[expect(unused)]
     DomainModerator(String),
     /// Can only edit own profile
     User,

src/db/user.rs

@@ -1,4 +1,4 @@
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 
 use std::fmt;
 
@@ -54,7 +54,7 @@ impl fmt::Display for UserRef {
     }
 }
 
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct User {
     /// Username, without the domain part. Once set, cannot be edited.
     pub username: String,

src/http/domain.rs

@@ -7,8 +7,8 @@ use serde::Deserialize;
 use crate::db::{DatabaseInterface, Operation};
 use crate::http::{HttpSession, HttpState};
 
-pub async fn get_domain<D: DatabaseInterface>(
-    State(state): State<HttpState<D>>,
+pub async fn get_domain(
+    State(state): State<HttpState>,
     session: HttpSession,
     Path(domain): Path<String>,
 ) -> Response {
@@ -53,8 +53,8 @@ pub struct DomainCreationForm {
     domainname: String,
 }
 
-pub async fn create_domain<D: DatabaseInterface>(
-    State(mut state): State<HttpState<D>>,
+pub async fn create_domain(
+    State(mut state): State<HttpState>,
     session: HttpSession,
     Form(form): Form<DomainCreationForm>,
 ) -> Response {

src/http/home.rs

@@ -6,8 +6,8 @@ use minijinja::context;
 use crate::db::{DatabaseInterface, Operation};
 use crate::http::{HttpSession, HttpState};
 
-pub async fn home<D: DatabaseInterface>(
-    State(state): State<HttpState<D>>,
+pub async fn home(
+    State(state): State<HttpState>,
     // Only logged in users are allowed here
     session: HttpSession,
 ) -> Response {

src/http/login.rs

@@ -20,8 +20,8 @@ pub enum LoginError {
     SessionInvalidated,
 }
 
-pub async fn login_page<D: DatabaseInterface>(
-    State(state): State<HttpState<D>>,
+pub async fn login_page(
+    State(state): State<HttpState>,
     login_error: Option<LoginError>,
 ) -> Response {
     let page = state
@@ -33,8 +33,8 @@ pub async fn login_page<D: DatabaseInterface>(
     (StatusCode::OK, Html(page)).into_response()
 }
 
-pub async fn get_login<D: DatabaseInterface>(
-    State(state): State<HttpState<D>>,
+pub async fn get_login(
+    State(state): State<HttpState>,
     maybe_session: Option<OptionalHttpSession>,
 ) -> Response {
     if maybe_session.is_some() {
@@ -44,8 +44,8 @@ pub async fn get_login<D: DatabaseInterface>(
     login_page(State(state), None).await
 }
 
-pub async fn post_login<D: DatabaseInterface>(
-    State(state): State<HttpState<D>>,
+pub async fn post_login(
+    State(state): State<HttpState>,
     session: Option<OptionalHttpSession>,
     cookies: CookieJar,
     Form(form): Form<LoginForm>,

src/http/logout.rs

@@ -2,12 +2,11 @@ use axum::extract::State;
 use axum::response::{IntoResponse, Redirect, Response};
 use axum_extra::extract::cookie::CookieJar;
 
-use crate::db::DatabaseInterface;
 use crate::http::login::{LoginError, login_page};
 use crate::http::{HttpState, OptionalHttpSession};
 
-pub async fn logout<D: DatabaseInterface>(
-    State(state): State<HttpState<D>>,
+pub async fn logout(
+    State(state): State<HttpState>,
     session: Option<OptionalHttpSession>,
     cookies: CookieJar,
 ) -> Response {

src/http/mod.rs

@@ -9,7 +9,7 @@ use static_serve::embed_assets;
 #[cfg(not(feature = "embed"))]
 use tower_http::services::ServeDir;
 
-use crate::db::{Database, DatabaseInterface};
+use crate::db::Database;
 use crate::listener::{Listener, ListenerKind};
 use crate::stream::{AbstractSocketAddr, AbstractStreamKind};
 
@@ -62,14 +62,14 @@ impl AxumListener for Listener {
 }
 
 #[derive(Clone)]
-pub struct HttpState<D: DatabaseInterface> {
-    pub db: Database<D>,
+pub struct HttpState {
+    pub db: Database,
     pub sessions: HttpSessionManager,
     pub templates: Environment<'static>,
 }
 
-impl<D: DatabaseInterface> HttpState<D> {
-    pub fn new(db: Database<D>) -> Self {
+impl HttpState {
+    pub fn new(db: Database) -> Self {
         let mut templates = Environment::new();
         #[cfg(feature = "embed")]
         minijinja_embed::load_templates!(&mut templates);
@@ -83,7 +83,7 @@ impl<D: DatabaseInterface> HttpState<D> {
     }
 }
 
-pub async fn http_listen<D: DatabaseInterface>(listener: Listener, db: Database<D>) {
+pub async fn http_listen(listener: Listener, db: Database) {
     #[cfg(all(feature = "embed", feature = "noembed"))]
     compile_error!("You cannot have `embed` and `noembed` features enabled at the same time.");
     #[cfg(not(any(feature = "embed", feature = "noembed")))]

src/http/session.rs

@@ -6,7 +6,7 @@ use uuid::Uuid;
 
 use std::sync::{Arc, RwLock};
 
-use crate::db::{DatabaseInterface, User};
+use crate::db::User;
 use crate::http::HttpState;
 
 pub const COOKIE_NAME: &str = "lldap_session";
@@ -83,12 +83,12 @@ impl PartialEq<HttpSession> for HttpSession {
     }
 }
 
-impl<D: DatabaseInterface> FromRequestParts<HttpState<D>> for HttpSession {
+impl FromRequestParts<HttpState> for HttpSession {
     type Rejection = Redirect;
 
     async fn from_request_parts(
         parts: &mut Parts,
-        state: &HttpState<D>,
+        state: &HttpState,
     ) -> Result<Self, Self::Rejection> {
         let cookies = CookieJar::from_request_parts(parts, state).await.unwrap();
         state
@@ -108,12 +108,12 @@ impl std::ops::Deref for OptionalHttpSession {
     }
 }
 
-impl<D: DatabaseInterface> OptionalFromRequestParts<HttpState<D>> for OptionalHttpSession {
+impl OptionalFromRequestParts<HttpState> for OptionalHttpSession {
     type Rejection = Redirect;
 
     async fn from_request_parts(
         parts: &mut Parts,
-        state: &HttpState<D>,
+        state: &HttpState,
     ) -> Result<Option<Self>, Self::Rejection> {
         let maybe_session = HttpSession::from_request_parts(parts, state)
             .await

src/http/user.rs

@@ -12,8 +12,8 @@ pub struct UserCreationForm {
     pub password: String,
 }
 
-pub async fn create_user<D: DatabaseInterface>(
-    State(mut state): State<HttpState<D>>,
+pub async fn create_user(
+    State(mut state): State<HttpState>,
     session: HttpSession,
     Form(form): Form<UserCreationForm>,
 ) -> Response {

src/ldap/handler.rs

@@ -1,13 +1,13 @@
 use ldap3_proto::LdapMsg;
 use ldap3_proto::proto::LdapOp;
 
-use crate::db::{Database, DatabaseInterface};
+use crate::db::Database;
 use crate::ldap::{
     LdapClientState, LdapStream, LdapStreamError, op_bind, op_ext, search_by_mail_filter,
 };
 
 #[tracing::instrument(name = "ldap", skip(stream, db), fields(session = %stream.session))]
-pub async fn ldap_handler<D: DatabaseInterface>(mut stream: LdapStream, mut db: Database<D>) {
+pub async fn ldap_handler(mut stream: LdapStream, mut db: Database) {
     tracing::info! {
         remote_addr = ?stream.remote_addr,
         "New client connection"
@@ -45,11 +45,11 @@ pub async fn ldap_handler<D: DatabaseInterface>(mut stream: LdapStream, mut db:
 
 /// Return true to keep the connection going, false to close it.
 #[tracing::instrument(name = "ldap-handler", skip(client_state, db, stream))]
-pub async fn ldap_handler_inner<D: DatabaseInterface>(
+pub async fn ldap_handler_inner(
     stream: &mut LdapStream,
     msg: LdapMsg,
     client_state: &mut LdapClientState,
-    db: &mut Database<D>,
+    db: &mut Database,
 ) -> Result<bool, LdapStreamError> {
     tracing::debug!(msg = ?msg, "Received LDAP message");
     match msg {

src/ldap/op/bind.rs

@@ -2,7 +2,7 @@ use ldap3_proto::proto::{LdapBindCred, LdapBindRequest, LdapBindResponse, LdapOp
 use ldap3_proto::{LdapMsg, LdapResultCode};
 
 use crate::db::error::BoxedError;
-use crate::db::{Database, DatabaseInterface, UserRef};
+use crate::db::{Database, UserRef};
 use crate::ldap::{Dn, LdapReturnError, LdapStream, LdapStreamError, MalformedDn};
 
 #[derive(Debug)]
@@ -165,9 +165,9 @@ pub async fn bind_success(stream: &mut LdapStream, msgid: i32) -> Result<(), Lda
 ///
 /// On success, returns `Ok(Some(bound_dn))`. `Ok(None)` means credentials failed,
 /// either because the account does not exist, or the password is wrong.
-pub async fn op_bind<D: DatabaseInterface>(
+pub async fn op_bind(
     stream: &mut LdapStream,
-    db: &Database<D>,
+    db: &Database,
     req: LdapBindRequest,
     msgid: i32,
 ) -> Result<Option<BindDn>, LdapStreamError> {

src/ldap/op/search.rs

@@ -174,9 +174,9 @@ fn search_entry_from_user(user: &User, req_attrs: &[String]) -> LdapSearchResult
     }
 }
 
-pub async fn search_by_mail_filter<D: DatabaseInterface>(
+pub async fn search_by_mail_filter(
     stream: &mut LdapStream,
-    db: &Database<D>,
+    db: &Database,
     sr: LdapSearchRequest,
     msgid: i32,
 ) -> Result<(), LdapStreamError> {

src/main.rs

@@ -12,12 +12,12 @@ mod stream;
 #[cfg(feature = "http")]
 use crate::http::http_listen;
 use cli::CliArgs;
-use db::{Database, DatabaseInterface, MemoryDatabase, Role, User};
+use db::{Database, DatabaseInterface, FilesystemDatabase, MemoryDatabase, Role, User};
 use error::GlobalError;
 use ldap::ldap_handler;
 use listener::ListenerPath;
 
-async fn create_dummy_users<D: DatabaseInterface>(db: &mut Database<D>) {
+async fn create_dummy_users(db: &mut Database) {
     db.create_user(User {
         username: "admin".to_string(),
         domain: None,
@@ -69,7 +69,11 @@ async fn main() -> Result<(), GlobalError> {
 
     let ldap_listener = ListenerPath::new(&cli.listen_ldap)?.listener().await?;
 
-    let mut db = MemoryDatabase::new();
+    let mut db = if let Some(db_path) = &cli.db {
+        FilesystemDatabase::from_path(db_path).await.unwrap()
+    } else {
+        MemoryDatabase::new()
+    };
     create_dummy_users(&mut db).await;
 
     #[cfg(feature = "http")]