joining remote rooms works too now

src/api/client_server/account.rs

@@ -1,3 +1,5 @@
+use std::ops::Deref;
+
 use super::{DEVICE_ID_LENGTH, SESSION_ID_LENGTH, TOKEN_LENGTH};
 use crate::{
     api::client_server::{self, membership::join_room_by_id_helper},
@@ -15,7 +17,7 @@ use ruma::{
         uiaa::{AuthFlow, AuthType, UiaaInfo},
     },
     events::{room::message::RoomMessageEventContent, GlobalAccountDataEventType},
-    push, UserId,
+    push, RoomId, UserId,
 };
 use tracing::{info, warn};
 
@@ -291,29 +293,27 @@ pub async fn register_route(body: Ruma<register::v3::Request>) -> Result<registe
             }
         }
 
-        let default_rooms = services()
+        let default_rooms = services().globals.default_rooms().await?;
-            .globals
+        let servers: Vec<_> = default_rooms
-            .default_rooms()
+            .iter()
-            .expect("default rooms should be validated on db startup");
+            .map(Deref::deref)
+            .filter_map(RoomId::server_name)
+            .map(Into::into)
+            .collect();
 
-        let _user_id = user_id.clone();
+        for room_id in default_rooms {
-        let servers = [services().globals.server_name().to_owned()];
+            if let Err(e) = join_room_by_id_helper(
-
+                Some(&user_id),
-        tokio::spawn(async move {
+                room_id,
-            for room_id in default_rooms {
+                Some("All men are equal before fish.".to_owned()),
-                let _ = join_room_by_id_helper(
+                &servers,
-                    Some(&_user_id),
+                None,
-                    room_id,
+            )
-                    Some("All men are equal before fish.".to_owned()),
+            .await
-                    &servers,
+            {
-                    None,
+                warn!("Failed to join default room: {}", e);
-                )
-                .await
-                .inspect_err(|e| {
-                    tracing::warn!("Failed to join default room: {e}");
-                });
             }
-        });
+        }
     }
 
     Ok(register::v3::Response {

src/database/mod.rs

@@ -970,11 +970,11 @@ impl KeyValueDatabase {
         db.presenceid_presence.clear()?;
 
         // Can only return an error during the first call
-        services().globals.default_rooms().map_err(|e| {
+        // services().globals.default_rooms().await.map_err(|e| {
-            tracing::error!("Invalid room ID or alias in join-by-default rooms: {}", e);
+        //     tracing::error!("Invalid room ID or alias in join-by-default rooms: {}", e);
 
-            Error::bad_config("Invalid room ID or alias in join-by-default rooms.")
+        //     Error::bad_config("Invalid room ID or alias in join-by-default rooms.")
-        })?;
+        // })?;
 
         services().admin.start_handler();
 

src/service/globals/mod.rs

@@ -10,7 +10,7 @@ use tokio::sync::OnceCell;
 use crate::api::server_server::DestinationResponse;
 
 use crate::{services, Config, Error, Result};
-use futures_util::FutureExt;
+use futures_util::{FutureExt, TryFutureExt};
 use hickory_resolver::TokioAsyncResolver;
 use hyper_util::client::legacy::connect::dns::{GaiResolver, Name as HyperName};
 use reqwest::dns::{Addrs, Name, Resolve, Resolving};
@@ -509,41 +509,55 @@ impl Service {
         self.config.well_known_client()
     }
 
-    pub fn default_rooms(&self) -> Result<&BTreeSet<OwnedRoomId>> {
+    pub async fn default_rooms(&self) -> Result<&BTreeSet<OwnedRoomId>> {
-        if let Some(set) = self.default_rooms.get() {
+        if let Some(default_rooms) = self.default_rooms.get() {
-            return Ok(set);
+            return Ok(default_rooms);
         }
 
-        let server_name = self.config.server_name.as_str();
         let mut default_rooms = BTreeSet::new();
 
-        for s in self.config.default_rooms.iter() {
+        for mut alias_or_id in self.config.default_rooms.iter().cloned() {
-            let next = s
-                .chars()
-                .next()
-                .ok_or_else(|| Error::bad_config("Invalid ID for join-by-default rooms."))?;
-
             // anything that does not start '!' should be considered an alias
-            let room_id = match next {
+            // empty strings are ignored
-                '!' => OwnedRoomId::from_str(&format!(
+            let room_id = if Some('!') == alias_or_id.chars().next() {
-                    "{}:{server_name}",
+                if alias_or_id.split_once(':').is_none() {
-                    s.split(':').next().unwrap_or(&s)
+                    alias_or_id = format!("{}:{}", alias_or_id, self.config.server_name);
-                ))
+                }
-                .map_err(|_| Error::bad_config("Invalid ID for join-by-default rooms."))?,
-                _ => {
-                    let Some(room_id) = OwnedRoomAliasId::from_str(&format!(
-                        "#{}:{server_name}",
-                        s.split(':').next().unwrap_or(&s).trim_start_matches('#')
-                    ))
-                    .map_err(|_| Error::bad_config("Invalid alias for join-by-default rooms."))
-                    .and_then(|alias| services().rooms.alias.resolve_local_alias(&alias))?
-                    else {
-                        warn!("Could not resolve Room ID for join-by-default rooms locally.");
 
-                        continue;
+                OwnedRoomId::from_str(&alias_or_id).map_err(|e| {
-                    };
+                    warn!(
+                        "Invalid room ID ({}) for join-by-default rooms: {}",
+                        alias_or_id, e
+                    );
 
-                    room_id
+                    Error::bad_config("Invalid room ID for join-by-default rooms.")
+                })?
+            } else {
+                if alias_or_id.split_once(':').is_none() {
+                    alias_or_id = format!("#{}:{}", alias_or_id, self.config.server_name);
+                }
+
+                let room_alias = OwnedRoomAliasId::from_str(&alias_or_id).map_err(|e| {
+                    warn!(
+                        "Invalid room alias ({}) for join-by-default rooms: {}",
+                        alias_or_id, e
+                    );
+
+                    Error::bad_config("Invalid room alias for join-by-default rooms.")
+                })?;
+
+                if room_alias.server_name() == &self.config.server_name {
+                    services()
+                        .rooms
+                        .alias
+                        .resolve_local_alias(&room_alias)?
+                        .ok_or_else(|| {
+                            Error::bad_config("Unknown alias for join-by-default rooms.")
+                        })?
+                } else {
+                    get_alias_helper(room_alias.clone())
+                        .await
+                        .map(|res| res.room_id)?
                 }
             };
 
@@ -552,9 +566,9 @@ impl Service {
 
         self.default_rooms
             .set(default_rooms)
-            .expect("default_rooms should be set once");
+            .expect("default_rooms should not be set already");
 
-        self.default_rooms()
+        Ok(self.default_rooms.get().unwrap())
     }
 
     pub fn shutdown(&self) {