feat: Type-erase Database backend for simpler code

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"
@@ -523,6 +534,7 @@ name = "llldap"
 version = "0.1.0"
 dependencies = [
  "argh",
+ "async-trait",
  "axum",
  "axum-extra",
  "camino",

Cargo.toml

@@ -5,6 +5,7 @@ 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 = { version = "1.2.5", features = ["serde1"] }

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 struct Database {
-    pub inner: Arc<RwLock<D>>,
+    pub inner: Arc<RwLock<Box<dyn DatabaseInterface>>>,
 }
 
-impl<D: DatabaseInterface> Database<D> {
+impl Database {
-    pub fn new(db: D) -> Self {
+    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/filesystem.rs

@@ -45,7 +45,7 @@ pub struct FilesystemDatabase {
 }
 
 impl FilesystemDatabase {
-    pub async fn from_path(path: impl AsRef<Utf8Path>) -> Result<Database<Self>, BoxedError> {
+    pub async fn from_path(path: impl AsRef<Utf8Path>) -> Result<Database, BoxedError> {
         let path = path.as_ref();
         let s = tokio::fs::read(path)
             .await
@@ -67,6 +67,7 @@ impl FilesystemDatabase {
     }
 }
 
+#[async_trait::async_trait]
 impl DatabaseInterface for FilesystemDatabase {
     async fn create_domain(
         &mut self,
@@ -84,15 +85,12 @@ impl DatabaseInterface for FilesystemDatabase {
         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> {
-        self.inner.get_domain(domain)
+        self.inner.get_domain(domain).await
     }
 
-    fn get_user(
+    async fn get_user(&self, req_user: &UserRef) -> Result<Option<User>, BoxedError> {
-        &self,
+        self.inner.get_user(req_user).await
-        req_user: &UserRef,
-    ) -> impl Future<Output = Result<Option<User>, BoxedError>> {
-        self.inner.get_user(req_user)
     }
 
     async fn create_user(
@@ -128,18 +126,15 @@ impl DatabaseInterface for FilesystemDatabase {
         Ok(Ok(()))
     }
 
-    fn list_all_domains(&self) -> impl Future<Output = Result<Vec<Domain>, BoxedError>> {
+    async fn list_all_domains(&self) -> Result<Vec<Domain>, BoxedError> {
-        self.inner.list_all_domains()
+        self.inner.list_all_domains().await
     }
 
-    fn list_all_users(&self) -> impl Future<Output = Result<Vec<User>, BoxedError>> {
+    async fn list_all_users(&self) -> Result<Vec<User>, BoxedError> {
-        self.inner.list_all_users()
+        self.inner.list_all_users().await
     }
 
-    fn list_domain_users(
+    async fn list_domain_users(&self, domain: Option<String>) -> Result<Vec<User>, BoxedError> {
-        &self,
+        self.inner.list_domain_users(domain).await
-        domain: Option<String>,
-    ) -> impl Future<Output = Result<Vec<User>, BoxedError>> {
-        self.inner.list_domain_users(domain)
     }
 }

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 {
+#[async_trait::async_trait]
-    fn create_domain(
+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;
+    ) -> Result<Result<(), DomainCreationError>, BoxedError>;
-    fn get_domain(
+    async fn get_domain(&self, domain: &str) -> Result<Option<Domain>, BoxedError>;
-        &self,
-        domain: &str,
-    ) -> impl Future<Output = Result<Option<Domain>, BoxedError>> + Send;
 
-    fn get_user(
+    async fn get_user(&self, user: &UserRef) -> Result<Option<User>, BoxedError>;
-        &self,
-        user: &UserRef,
-    ) -> impl Future<Output = Result<Option<User>, BoxedError>> + Send;
     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(
+    async fn list_domain_users(&self, domain: Option<String>) -> Result<Vec<User>, BoxedError>;
-        &self,
-        domain: Option<String>,
-    ) -> impl Future<Output = Result<Vec<User>, BoxedError>> + Send;
 }

src/db/memory.rs

@@ -1,7 +1,5 @@
 use serde::{Deserialize, Serialize};
 
-use std::future::ready;
-
 use crate::db::error::{BoxedError, DomainCreationError, UserCreationError};
 use crate::db::{Database, DatabaseInterface, Domain, Group, Operation, User, UserRef};
 
@@ -14,52 +12,49 @@ pub struct MemoryDatabase {
 }
 
 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(
+            return Ok(Err(DomainCreationError::InvalidDomain(domain.to_string())));
-                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(
+    async fn get_user(&self, req_user: &UserRef) -> Result<Option<User>, BoxedError> {
-        &self,
+        Ok(self
-        req_user: &UserRef,
-    ) -> impl Future<Output = Result<Option<User>, BoxedError>> {
-        ready(Ok(self
             .users
             .iter()
             .find(|u| u.username == req_user.username && u.domain == req_user.domain)
-            .cloned()))
+            .cloned())
     }
 
     async fn create_user(
@@ -104,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>> {
+    async fn list_all_domains(&self) -> Result<Vec<Domain>, BoxedError> {
-        ready(Ok(self.domains.clone()))
+        Ok(self.domains.clone())
     }
 
-    fn list_all_users(&self) -> impl Future<Output = Result<Vec<User>, BoxedError>> {
+    async fn list_all_users(&self) -> Result<Vec<User>, BoxedError> {
-        ready(Ok(self.users.clone()))
+        Ok(self.users.clone())
     }
 
-    fn list_domain_users(
+    async fn list_domain_users(&self, domain: Option<String>) -> Result<Vec<User>, BoxedError> {
-        &self,
+        Ok(self
-        domain: Option<String>,
-    ) -> impl Future<Output = Result<Vec<User>, BoxedError>> {
-        ready(Ok(self
             .users
             .iter()
             .filter(|u| u.domain == domain)
             .cloned()
-            .collect()))
+            .collect())
     }
 }

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>(
+pub async fn get_domain(
-    State(state): State<HttpState<D>>,
+    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>(
+pub async fn create_domain(
-    State(mut state): State<HttpState<D>>,
+    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>(
+pub async fn home(
-    State(state): State<HttpState<D>>,
+    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>(
+pub async fn login_page(
-    State(state): State<HttpState<D>>,
+    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>(
+pub async fn get_login(
-    State(state): State<HttpState<D>>,
+    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>(
+pub async fn post_login(
-    State(state): State<HttpState<D>>,
+    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>(
+pub async fn logout(
-    State(state): State<HttpState<D>>,
+    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 struct HttpState {
-    pub db: Database<D>,
+    pub db: Database,
     pub sessions: HttpSessionManager,
     pub templates: Environment<'static>,
 }
 
-impl<D: DatabaseInterface> HttpState<D> {
+impl HttpState {
-    pub fn new(db: Database<D>) -> Self {
+    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>(
+pub async fn create_user(
-    State(mut state): State<HttpState<D>>,
+    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

@@ -17,7 +17,7 @@ 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,12 +69,11 @@ async fn main() -> Result<(), GlobalError> {
 
     let ldap_listener = ListenerPath::new(&cli.listen_ldap)?.listener().await?;
 
-    // let mut db = if let Some(db_path) = &cli.db {
+    let mut db = if let Some(db_path) = &cli.db {
-    //     FilesystemDatabase::from_path(db_path).await.unwrap()
+        FilesystemDatabase::from_path(db_path).await.unwrap()
-    // } else {
+    } else {
-    //     MemoryDatabase::new()
+        MemoryDatabase::new()
-    // };
+    };
-    let mut db = MemoryDatabase::new();
     create_dummy_users(&mut db).await;
 
     #[cfg(feature = "http")]