reviewed changes

conduit-example.toml

@@ -56,10 +56,6 @@ enable_lightning_bolt = true
 # servers.)
 trusted_servers = ["matrix.org"]
 
-# Rooms listed here will be joined automatically after registration.
-# See examples for accepted identifiers.
-#join_by_default = ["#lounge:conduit.rs", "#lounge", "lounge", "!abc123:conduit.rs", "!abc123"]
-
 #max_concurrent_requests = 100 # How many requests Conduit sends to other servers at the same time
 
 # Controls the log verbosity. See also [here][0].

docs/configuration.md

@@ -43,9 +43,8 @@ The `global` section contains the following fields:
 | `allow_federation` | `boolean` | Allow federation with other servers | `true` |
 | `allow_room_creation` | `boolean` | Allow users to create rooms | `true` |
 | `allow_unstable_room_versions` | `boolean` | Allow users to create and join rooms with unstable versions | `true` |
+| `default_rooms` | `array` | The list of rooms that will be joined by default on registration | [] |
 | `default_room_version` | `string` | The default room version (`"6"`-`"10"`)| `"10"` |
-| `default_rooms` | `array` | The list of rooms that will be joined by default on registration | N/A |
-| `join_by_default` | `array` | Room aliases and IDs that will be joined by default at registration | N/A |
 | `allow_jaeger` | `boolean` | Allow Jaeger tracing | `false` |
 | `tracing_flame` | `boolean` | Enable flame tracing | `false` |
 | `proxy` | `table` | See the [Proxy configuration](#proxy) | N/A |

src/api/client_server/account.rs

@@ -1,5 +1,3 @@
-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},
@@ -17,7 +15,7 @@ use ruma::{
         uiaa::{AuthFlow, AuthType, UiaaInfo},
     },
     events::{room::message::RoomMessageEventContent, GlobalAccountDataEventType},
-    push, RoomId, UserId,
+    push, UserId,
 };
 use tracing::{info, warn};
 
@@ -66,7 +64,7 @@ pub async fn get_register_available_route(
     Ok(get_username_availability::v3::Response { available: true })
 }
 
-/// # `POST /_matrix/client/r0/register`
+/// # `POST /_matrix/client/r0/register
 ///
 /// Register an account on this homeserver.
 ///
@@ -293,30 +291,25 @@ pub async fn register_route(body: Ruma<register::v3::Request>) -> Result<registe
             }
         }
 
-        let _user_id = user_id.clone();
         let default_rooms = services().globals.default_rooms().await?;
         let servers: Vec<_> = default_rooms
             .iter()
-            .map(Deref::deref)
+            .filter_map(|r| r.server_name().map(ToOwned::to_owned))
-            .filter_map(RoomId::server_name)
-            .map(Into::into)
             .collect();
 
-        tokio::spawn(async move {
+        for room_id in &default_rooms {
-            for room_id in default_rooms {
+            if let Err(e) = join_room_by_id_helper(
-                if let Err(e) = join_room_by_id_helper(
+                Some(&user_id),
-                    Some(&_user_id),
+                room_id,
-                    room_id,
+                Some("All men are equal before fish.".to_owned()),
-                    Some("All men are equal before fish.".to_owned()),
+                &servers,
-                    &servers,
+                None,
-                    None,
+            )
-                )
+            .await
-                .await
+            {
-                {
+                warn!("Failed to join default room: {}", e);
-                    warn!("Failed to join default room: {}", e);
-                }
             }
-        });
+        }
     }
 
     Ok(register::v3::Response {

src/config/mod.rs

@@ -4,7 +4,7 @@ use std::{
     net::{IpAddr, Ipv4Addr},
 };
 
-use ruma::{OwnedServerName, RoomVersionId};
+use ruma::{OwnedRoomOrAliasId, OwnedServerName, RoomVersionId};
 use serde::{de::IgnoredAny, Deserialize};
 use tracing::warn;
 use url::Url;
@@ -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<String>,
+    pub default_rooms: Vec<OwnedRoomOrAliasId>,
     #[serde(default)]
     pub well_known: WellKnownConfig,
     #[serde(default = "false_fn")]

src/database/mod.rs

@@ -969,13 +969,6 @@ impl KeyValueDatabase {
         // This data is probably outdated
         db.presenceid_presence.clear()?;
 
-        // Can only return an error during the first call
-        // services().globals.default_rooms().await.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.")
-        // })?;
-
         services().admin.start_handler();
 
         // Set emergency access for the conduit user

src/service/globals/mod.rs

@@ -3,11 +3,10 @@ pub use data::{Data, SigningKeys};
 
 use ruma::{
     serde::Base64, MilliSecondsSinceUnixEpoch, OwnedDeviceId, OwnedEventId, OwnedRoomAliasId,
-    OwnedRoomId, OwnedServerName, OwnedUserId, RoomAliasId,
+    OwnedRoomId, OwnedRoomOrAliasId, OwnedServerName, OwnedUserId, RoomAliasId,
 };
-use tokio::sync::OnceCell;
 
-use crate::api::server_server::DestinationResponse;
+use crate::api::{client_server::get_alias_helper, server_server::DestinationResponse};
 
 use crate::{services, Config, Error, Result};
 use futures_util::FutureExt;
@@ -70,7 +69,6 @@ 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)>>,
-    default_rooms: OnceCell<BTreeSet<OwnedRoomId>>,
     server_user: OwnedUserId,
     admin_alias: OwnedRoomAliasId,
     pub stateres_mutex: Arc<Mutex<()>>,
@@ -224,7 +222,6 @@ impl Service {
             roomid_mutex_insert: RwLock::new(HashMap::new()),
             roomid_mutex_federation: RwLock::new(HashMap::new()),
             roomid_federationhandletime: RwLock::new(HashMap::new()),
-            default_rooms: OnceCell::new(),
             stateres_mutex: Arc::new(Mutex::new(())),
             sync_receivers: RwLock::new(HashMap::new()),
             rotate: RotationHandler::new(),
@@ -509,66 +506,32 @@ impl Service {
         self.config.well_known_client()
     }
 
-    pub async fn default_rooms(&self) -> Result<&BTreeSet<OwnedRoomId>> {
+    pub async fn default_rooms(&self) -> Result<BTreeSet<OwnedRoomId>> {
-        if let Some(default_rooms) = self.default_rooms.get() {
-            return Ok(default_rooms);
-        }
-
         let mut default_rooms = BTreeSet::new();
 
-        for mut alias_or_id in self.config.default_rooms.iter().cloned() {
+        for id_or_alias in &self.config.default_rooms {
-            // anything that does not start '!' should be considered an alias
+            // OwnedRoomOrAliasId always starts with a '#' or '!', presence of a ':' is not validated
-            // empty strings are ignored
+            let localpart = id_or_alias
-            let room_id = if alias_or_id.starts_with('!') {
+                .as_str()
-                if alias_or_id.split_once(':').is_none() {
+                .split_once(':')
-                    alias_or_id = format!("{}:{}", alias_or_id, self.config.server_name);
+                .map(|(localpart, _)| localpart)
-                }
+                .unwrap_or(id_or_alias.as_str());
+            let server_name = id_or_alias
+                .server_name()
+                .map(ToOwned::to_owned)
+                .unwrap_or(self.config.server_name.clone());
 
-                OwnedRoomId::from_str(&alias_or_id).map_err(|e| {
+            let room_id = match OwnedRoomOrAliasId::from_str(&format!("{localpart}:{server_name}"))
-                    warn!(
+                .expect("this should always be valid")
-                        "Invalid room ID ({}) for join-by-default rooms: {}",
+                .try_into()
-                        alias_or_id, e
+            {
-                    );
+                Ok(room_id) => room_id,
-
+                Err(room_alias) => get_alias_helper(room_alias).await.map(|res| res.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)?
-                }
             };
-
             default_rooms.insert(room_id);
         }
 
-        self.default_rooms
+        Ok(default_rooms)
-            .set(default_rooms)
-            .expect("default_rooms should not be set already");
-
-        Ok(self.default_rooms.get().unwrap())
     }
 
     pub fn shutdown(&self) {