Clone server URL - subdomain support #502

Author: joepio

.dagger/.gitattributes

@@ -1 +1,2 @@
 /sdk/** linguist-generated
+tar

lib/src/db.rs

@@ -48,7 +48,6 @@ use self::{
     },
     val_prop_sub_index::add_atom_to_valpropsub_index,
 };
-
 use sled::{transaction::TransactionError, Transactional};
 
 // A function called by the Store when a Commit is accepted
@@ -86,9 +85,9 @@ pub struct Db {
     /// The address where the db will be hosted, e.g. http://localhost/
     server_url: String,
     /// Endpoints are checked whenever a resource is requested. They calculate (some properties of) the resource and return it.
-    endpoints: Vec<Endpoint>,
+    endpoints: Arc<Vec<Endpoint>>,
     /// List of class extenders.
-    class_extenders: Vec<ClassExtender>,
+    class_extenders: Arc<Vec<ClassExtender>>,
     /// Function called whenever a Commit is applied.
     on_commit: Option<Arc<HandleCommit>>,
     /// Where the DB is stored on disk.
@@ -118,8 +117,8 @@ impl Db {
             prop_val_sub_index,
             server_url,
             watched_queries,
-            endpoints: plugins::default_endpoints(),
-            class_extenders: plugins::default_class_extenders(),
+            endpoints: Arc::new(plugins::default_endpoints()),
+            class_extenders: Arc::new(plugins::default_class_extenders()),
             on_commit: None,
         };
         migrate_maybe(&store).map(|e| format!("Error during migration of database: {:?}", e))?;
@@ -128,6 +127,15 @@ impl Db {
         Ok(store)
     }
 
+    /// Creates a clone of the store with a different server_url.
+    /// This is useful for multi-tenant applications.
+    /// Cloning is very cheap, as it only clones the pointers to the Sled trees.
+    pub fn clone_with_url(&self, server_url: String) -> Db {
+        let mut clone = self.clone();
+        clone.server_url = server_url;
+        clone
+    }
+
     /// Create a temporary Db in `.temp/db/{id}`. Useful for testing.
     /// Populates the database, creates a default agent, and sets the server_url to "http://localhost/".
     pub fn init_temp(id: &str) -> AtomicResult<Db> {

lib/src/plugins/bookmark.rs

@@ -339,7 +339,7 @@ impl Parser {
         })]
     }
 
-    fn resolve_relative_path_handler(&self) -> Handler {
+    fn resolve_relative_path_handler(&self) -> Handler<'_, '_> {
         vec![element!("*[src], *[href]", |el| {
             if let Some(src) = el.get_attribute("src") {
                 el.set_attribute("src", &self.resolve_url(&src))?;
@@ -353,7 +353,7 @@ impl Parser {
         })]
     }
 
-    fn convert_svg_to_image_handler(&self) -> Handler {
+    fn convert_svg_to_image_handler(&self) -> Handler<'_, '_> {
         vec![element!("svg", |el| {
             let id = el.get_attribute("id").ok_or("no id in SVG")?;
             let svg = self.svg_map.get(&id).ok_or("no SVG found with id")?;
@@ -370,7 +370,7 @@ impl Parser {
         })]
     }
 
-    fn simplify_link_text_handler(&self) -> Handler {
+    fn simplify_link_text_handler(&self) -> Handler<'_, '_> {
         vec![element!("a *", |el| {
             let tag_name = el.tag_name().to_lowercase();
             if tag_name != "img" && tag_name != "picture" {
@@ -381,28 +381,28 @@ impl Parser {
         })]
     }
 
-    fn transform_figures_handler(&self) -> Handler {
+    fn transform_figures_handler(&self) -> Handler<'_, '_> {
         vec![element!("figure", |el| {
             el.remove_and_keep_content();
             Ok(())
         })]
     }
 
-    fn transform_figcaptions_handler(&self) -> Handler {
+    fn transform_figcaptions_handler(&self) -> Handler<'_, '_> {
         vec![element!("figcaption", |el| {
             el.set_tag_name("P")?;
             Ok(())
         })]
     }
 
-    fn unfold_sup_elements_handler(&self) -> Handler {
+    fn unfold_sup_elements_handler(&self) -> Handler<'_, '_> {
         vec![element!("sup", |el| {
             el.remove_and_keep_content();
             Ok(())
         })]
     }
 
-    fn trim_link_text_handler(&self) -> Handler {
+    fn trim_link_text_handler(&self) -> Handler<'_, '_> {
         vec![
             element!("a", |el| {
                 self.anchor_text_buffer.borrow_mut().clear();

lib/src/resources.rs

@@ -606,6 +606,7 @@ impl Resource {
         atoms
     }
 
+    #[cfg(feature = "rdf")]
     pub fn vec_to_n_triples(
         resources: &Vec<Resource>,
         store: &impl Storelike,

lib/src/storelike.rs

@@ -76,6 +76,7 @@ impl ResourceResponse {
         }
     }
 
+    #[cfg(feature = "rdf")]
     pub fn to_n_triples(&self, store: &impl Storelike) -> AtomicResult<String> {
         match self {
             ResourceResponse::Resource(resource) => Ok(resource.to_n_triples(store)?),

server/src/config.rs

@@ -98,6 +98,11 @@ pub struct Opts {
     /// Introduces random delays in the server, to simulate a slow connection. Useful for testing.
     #[clap(long, env = "ATOMIC_SLOW_MODE")]
     pub slow_mode: bool,
+
+    /// The base domain for multi-tenant hosting.
+    /// If set, the server will allow serving subdomains of this domain (e.g. *.atomicserver.eu).
+    #[clap(long, env = "ATOMIC_BASE_DOMAIN")]
+    pub base_domain: Option<String>,
 }
 
 #[derive(clap::ValueEnum, Clone, Debug)]
@@ -196,6 +201,35 @@ pub struct Config {
     pub search_index_path: PathBuf,
     /// If true, the initialization scripts will be ran (create first Drive, Agent, indexing, etc)
     pub initialize: bool,
+    /// The base domain for multi-tenant hosting.
+    pub base_domain: Option<String>,
+}
+
+impl Config {
+    /// Returns the server URL for a given request.
+    /// If multi-tenancy is enabled and the host matches a subdomain of the base domain, it returns the host URL.
+    pub fn get_server_url_for_request(&self, req: &actix_web::HttpRequest) -> String {
+        if let Some(base) = &self.base_domain {
+            if let Some(host) = req.head().headers.get("Host") {
+                if let Ok(host_str) = host.to_str() {
+                    // Remove port if present
+                    let domain = host_str.split(':').next().unwrap_or(host_str);
+                    if domain.ends_with(base) {
+                        let schema =
+                            if let Some(proto) = req.head().headers.get("X-Forwarded-Proto") {
+                                proto.to_str().unwrap_or("http")
+                            } else if self.opts.https {
+                                "https"
+                            } else {
+                                "http"
+                            };
+                        return format!("{}://{}", schema, host_str);
+                    }
+                }
+            }
+        }
+        self.server_url.clone()
+    }
 }
 
 /// Parse .env and CLI options
@@ -289,6 +323,8 @@ pub fn build_config(opts: Opts) -> AtomicServerResult<Config> {
         format!("{}://{}:{}", schema, opts.domain, opts.port)
     };
 
+    let base_domain = opts.base_domain.clone();
+
     Ok(Config {
         initialize,
         opts,
@@ -302,5 +338,6 @@ pub fn build_config(opts: Opts) -> AtomicServerResult<Config> {
         store_path,
         search_index_path,
         uploads_path,
+        base_domain,
     })
 }

server/src/errors.rs

@@ -31,11 +31,6 @@ impl std::fmt::Debug for AtomicServerError {
     }
 }
 
-#[derive(Serialize)]
-pub struct AppErrorResponse {
-    pub error: String,
-}
-
 impl Error for AtomicServerError {}
 
 impl ResponseError for AtomicServerError {

server/src/handlers/commit.rs

@@ -7,6 +7,7 @@ use atomic_lib::{commit::CommitOpts, parse::parse_json_ad_commit_resource, Commi
 #[tracing::instrument(skip(appstate))]
 pub async fn post_commit(
     appstate: web::Data<AppState>,
+    req: actix_web::HttpRequest,
     body: String,
 ) -> AtomicServerResult<HttpResponse> {
     if appstate.config.opts.slow_mode {
@@ -15,9 +16,11 @@ pub async fn post_commit(
         let random_number = rng.gen_range(100..1000);
         tokio::time::sleep(tokio::time::Duration::from_millis(random_number)).await;
     }
-    let store = &appstate.store;
+    let server_url = appstate.config.get_server_url_for_request(&req);
+    let store = appstate.store.clone_with_url(server_url);
     let mut builder = HttpResponse::Ok();
-    let incoming_commit_resource = parse_json_ad_commit_resource(&body, store)?;
+
+    let incoming_commit_resource = parse_json_ad_commit_resource(&body, &store)?;
     let incoming_commit = Commit::from_resource(incoming_commit_resource)?;
     if !incoming_commit.subject.contains(
         &store

server/src/handlers/download.rs

@@ -24,8 +24,8 @@ pub async fn handle_download(
     req: actix_web::HttpRequest,
 ) -> AtomicServerResult<HttpResponse> {
     let headers = req.headers();
-    let server_url = &appstate.config.server_url;
-    let store = &appstate.store;
+    let server_url = appstate.config.get_server_url_for_request(&req);
+    let store = appstate.store.clone_with_url(server_url.clone());
 
     // We replace `/download` with `/` to get the subject of the Resource.
     let subject = if let Some(pth) = path {

server/src/handlers/export.rs

@@ -29,7 +29,8 @@ pub async fn handle_export(
     req: actix_web::HttpRequest,
 ) -> AtomicServerResult<HttpResponse> {
     let headers = req.headers();
-    let store = &appstate.store;
+    let server_url = appstate.config.get_server_url_for_request(&req);
+    let store = appstate.store.clone_with_url(server_url);
 
     let Some(subject) = params.subject.clone() else {
         return Err("No subject provided".into());
@@ -45,7 +46,7 @@ pub async fn handle_export(
     match format.as_str() {
         "csv" => {
             let exporter = CSVExporter {
-                store,
+                store: &store,
                 agent: &for_agent,
                 display_refs_as_name,
             };