tokio::spawn does not run until completion of joins

src/api/client_server/account.rs

@@ -291,27 +291,29 @@ pub async fn register_route(body: Ruma<register::v3::Request>) -> Result<registe
             }
         }
 
-        let servers = [services().globals.server_name().to_owned()];
+        let default_rooms = services()
-        let join_by_default = services()
             .globals
-            .join_by_default()
+            .default_rooms()
-            .expect("validated on db startup");
+            .expect("default rooms should be validated on db startup");
 
-        for room_id in join_by_default {
+        let _user_id = user_id.clone();
-            join_room_by_id_helper(
+        let servers = [services().globals.server_name().to_owned()];
-                Some(&user_id),
-                room_id,
-                Some("All men are equal before fish.".to_owned()),
-                &servers,
-                None,
-            )
-            .await
-            .map_err(|e| {
-                tracing::error!("Failed to join default room: {e}");
 
-                Error::bad_config("Failed to join default room.")
+        tokio::spawn(async move {
-            })?;
+            for room_id in default_rooms {
-        }
+                let _ = join_room_by_id_helper(
+                    Some(&_user_id),
+                    room_id,
+                    Some("All men are equal before fish.".to_owned()),
+                    &servers,
+                    None,
+                )
+                .await
+                .inspect_err(|e| {
+                    tracing::warn!("Failed to join default room: {e}");
+                });
+            }
+        });
     }
 
     Ok(register::v3::Response {

src/config/mod.rs

@@ -60,7 +60,7 @@ pub struct Config {
     #[serde(default = "default_default_room_version")]
     pub default_room_version: RoomVersionId,
     #[serde(default = "Vec::new")]
-    pub default_rooms: Vec<OwnedRoomId>,
+    pub default_rooms: Vec<String>,
     #[serde(default)]
     pub well_known: WellKnownConfig,
     #[serde(default = "false_fn")]

src/database/mod.rs

@@ -970,7 +970,7 @@ impl KeyValueDatabase {
         db.presenceid_presence.clear()?;
 
         // Can only return an error during the first call
-        services().globals.join_by_default().map_err(|e| {
+        services().globals.default_rooms().map_err(|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.")

src/service/globals/mod.rs

@@ -70,7 +70,7 @@ pub struct Service {
     pub roomid_mutex_state: RwLock<HashMap<OwnedRoomId, Arc<Mutex<()>>>>,
     pub roomid_mutex_federation: RwLock<HashMap<OwnedRoomId, Arc<Mutex<()>>>>, // this lock will be held longer
     pub roomid_federationhandletime: RwLock<HashMap<OwnedRoomId, (OwnedEventId, Instant)>>,
-    join_by_default: OnceCell<BTreeSet<OwnedRoomId>>,
+    default_rooms: OnceCell<BTreeSet<OwnedRoomId>>,
     server_user: OwnedUserId,
     admin_alias: OwnedRoomAliasId,
     pub stateres_mutex: Arc<Mutex<()>>,
@@ -224,7 +224,7 @@ impl Service {
             roomid_mutex_insert: RwLock::new(HashMap::new()),
             roomid_mutex_federation: RwLock::new(HashMap::new()),
             roomid_federationhandletime: RwLock::new(HashMap::new()),
-            join_by_default: OnceCell::new(),
+            default_rooms: OnceCell::new(),
             stateres_mutex: Arc::new(Mutex::new(())),
             sync_receivers: RwLock::new(HashMap::new()),
             rotate: RotationHandler::new(),
@@ -509,47 +509,52 @@ impl Service {
         self.config.well_known_client()
     }
 
-    pub fn join_by_default(&self) -> Result<&BTreeSet<OwnedRoomId>> {
+    pub fn default_rooms(&self) -> Result<&BTreeSet<OwnedRoomId>> {
-        if let Some(set) = self.join_by_default.get() {
+        if let Some(set) = self.default_rooms.get() {
             return Ok(set);
         }
 
         let server_name = self.config.server_name.as_str();
-        let mut join_by_default = BTreeSet::new();
+        let mut default_rooms = BTreeSet::new();
 
-        for s in self.config.join_by_default.iter().cloned() {
+        for s in self.config.default_rooms.iter() {
             let next = s
                 .chars()
                 .next()
-                .ok_or_else(|| Error::bad_config("Invalid room ID for join-by-default."))?;
+                .ok_or_else(|| Error::bad_config("Invalid ID for join-by-default rooms."))?;
 
-            let room_id = if next == '!' {
+            // anything that does not start '!' should be considered an alias
-                let id = s.split(':').next().unwrap_or(&s);
+            let room_id = match next {
+                '!' => OwnedRoomId::from_str(&format!(
+                    "{}:{server_name}",
+                    s.split(':').next().unwrap_or(&s)
+                ))
+                .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.");
 
-                OwnedRoomId::from_str(&format!("{id}:{server_name}",))
+                        continue;
-                    .map_err(|_| Error::bad_config("Invalid room ID for join-by-default rooms."))?
+                    };
-            } else {
-                let id = s.split(':').next().unwrap_or(&s).trim_start_matches('#');
 
-                let alias = OwnedRoomAliasId::from_str(&format!("#{id}:{server_name}",))
+                    room_id
-                    .map_err(|_| Error::bad_config("Invalid room alias for join-by-default."))?;
+                }
-
-                let Some(room_id) = services().rooms.alias.resolve_local_alias(&alias)? else {
-                    warn!("Could not resolve Room ID for join-by-default rooms locally.");
-                    continue;
-                };
-
-                room_id
             };
 
-            join_by_default.insert(room_id);
+            default_rooms.insert(room_id);
         }
 
-        self.join_by_default
+        self.default_rooms
-            .set(join_by_default)
+            .set(default_rooms)
-            .expect("join_by_default should be set once");
+            .expect("default_rooms should be set once");
 
-        self.join_by_default()
+        self.default_rooms()
     }
 
     pub fn shutdown(&self) {