From 9933990fd3e2cb1cc1b4325c4d43dfb55f703cf7 Mon Sep 17 00:00:00 2001 From: selfhoster1312 Date: Sat, 19 Sep 2026 14:17:41 +0200 Subject: [PATCH] feat: Implement JSON-backed database --- Cargo.lock | 4 ++ Cargo.toml | 3 +- src/cli.rs | 5 ++ src/db/domain.rs | 4 +- src/db/filesystem.rs | 145 +++++++++++++++++++++++++++++++++++++++++++ src/db/group.rs | 6 +- src/db/interface.rs | 4 +- src/db/memory.rs | 7 ++- src/db/mod.rs | 2 + src/db/role.rs | 6 +- src/db/user.rs | 4 +- src/main.rs | 7 ++- 12 files changed, 179 insertions(+), 18 deletions(-) create mode 100644 src/db/filesystem.rs diff --git a/Cargo.lock b/Cargo.lock index 0b55b38..642d24c 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -169,6 +169,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" @@ -530,6 +533,7 @@ dependencies = [ "minijinja", "minijinja-embed", "serde", + "serde_json", "static-serve", "tokio", "tokio-util", diff --git a/Cargo.toml b/Cargo.toml index 2a473bd..2d31050 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -7,7 +7,7 @@ edition = "2024" argh = "0.1.19" 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 +15,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"] } diff --git a/src/cli.rs b/src/cli.rs index 6867704..d70e141 100644 --- a/src/cli.rs +++ b/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, + /// address or socket to listen on for LDAP connections #[argh(option, default = "String::from(\"127.0.0.1:3389\")")] pub listen_ldap: String, diff --git a/src/db/domain.rs b/src/db/domain.rs index 59a1a94..9c7d7e6 100644 --- a/src/db/domain.rs +++ b/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, } diff --git a/src/db/filesystem.rs b/src/db/filesystem.rs new file mode 100644 index 0000000..71fef14 --- /dev/null +++ b/src/db/filesystem.rs @@ -0,0 +1,145 @@ +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) -> Result, BoxedError> { + let path = path.as_ref(); + 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)))?) + } +} + +impl DatabaseInterface for FilesystemDatabase { + async fn create_domain( + &mut self, + domain: &str, + ) -> Result, 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(())) + } + + fn get_domain(&self, domain: &str) -> impl Future, BoxedError>> { + self.inner.get_domain(domain) + } + + fn get_user( + &self, + req_user: &UserRef, + ) -> impl Future, BoxedError>> { + self.inner.get_user(req_user) + } + + async fn create_user( + &mut self, + user: User, + ) -> Result, 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, 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(())) + } + + fn list_all_domains(&self) -> impl Future, BoxedError>> { + self.inner.list_all_domains() + } + + fn list_all_users(&self) -> impl Future, BoxedError>> { + self.inner.list_all_users() + } + + fn list_domain_users( + &self, + domain: Option, + ) -> impl Future, BoxedError>> { + self.inner.list_domain_users(domain) + } +} diff --git a/src/db/group.rs b/src/db/group.rs index c07a891..6a2793f 100644 --- a/src/db/group.rs +++ b/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, } diff --git a/src/db/interface.rs b/src/db/interface.rs index ca84fd9..c434ec5 100644 --- a/src/db/interface.rs +++ b/src/db/interface.rs @@ -62,7 +62,7 @@ pub trait DatabaseInterface: Clone + Send + Sync + 'static { fn get_user( &self, user: &UserRef, - ) -> impl std::future::Future, BoxedError>> + Send; + ) -> impl Future, BoxedError>> + Send; async fn create_user( &mut self, user: User, @@ -83,5 +83,5 @@ pub trait DatabaseInterface: Clone + Send + Sync + 'static { fn list_domain_users( &self, domain: Option, - ) -> impl std::future::Future, BoxedError>> + Send; + ) -> impl Future, BoxedError>> + Send; } diff --git a/src/db/memory.rs b/src/db/memory.rs index e170db0..4ef39e4 100644 --- a/src/db/memory.rs +++ b/src/db/memory.rs @@ -1,13 +1,14 @@ -use std::future::{Future, ready}; +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}; -#[derive(Clone, Debug, Default)] +#[derive(Clone, Debug, Default, Deserialize, Serialize)] pub struct MemoryDatabase { // We store data in tables like in SQL pub domains: Vec, - #[expect(unused)] pub groups: Vec, pub users: Vec, } diff --git a/src/db/mod.rs b/src/db/mod.rs index c2544e0..902e89c 100644 --- a/src/db/mod.rs +++ b/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; diff --git a/src/db/role.rs b/src/db/role.rs index 102933b..37f6b51 100644 --- a/src/db/role.rs +++ b/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), } -#[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, diff --git a/src/db/user.rs b/src/db/user.rs index b7c8bcd..ba9e986 100644 --- a/src/db/user.rs +++ b/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, diff --git a/src/main.rs b/src/main.rs index cb6ee76..91a8415 100644 --- a/src/main.rs +++ b/src/main.rs @@ -12,7 +12,7 @@ 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; @@ -69,6 +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 { + // FilesystemDatabase::from_path(db_path).await.unwrap() + // } else { + // MemoryDatabase::new() + // }; let mut db = MemoryDatabase::new(); create_dummy_users(&mut db).await;