refactor: Adapt to use of SupportedVersions for endpoints

Signed-off-by: Kévin Commaille <zecakeh@tedomum.fr>

Author: zecakeh

crates/matrix-sdk-base/src/store/integration_tests.rs

@@ -476,9 +476,10 @@ impl StateStoreIntegrationTests for DynStateStore {
     }
 
     async fn test_server_info_saving(&self) {
-        let versions = &[MatrixVersion::V1_1, MatrixVersion::V1_2, MatrixVersion::V1_11];
+        let versions =
+            BTreeSet::from([MatrixVersion::V1_1, MatrixVersion::V1_2, MatrixVersion::V1_11]);
         let server_info = ServerInfo::new(
-            versions.iter().map(|version| version.to_string()).collect(),
+            versions.iter().map(|version| version.as_str().unwrap().to_owned()).collect(),
             [("org.matrix.experimental".to_owned(), true)].into(),
             Some(WellKnownResponse {
                 homeserver: HomeserverInfo::new("matrix.example.com".to_owned()),

crates/matrix-sdk-base/src/store/traits.rs

@@ -1008,10 +1008,10 @@ impl ServerInfo {
     ///
     /// Note: Matrix versions that Ruma cannot parse, or does not know about,
     /// are discarded.
-    pub fn known_versions(&self) -> Vec<MatrixVersion> {
+    pub fn known_versions(&self) -> BTreeSet<MatrixVersion> {
         get_supported_versions::Response::new(self.versions.clone())
-            .known_versions()
-            .collect::<Vec<_>>()
+            .as_supported_versions()
+            .versions
     }
 }
 

crates/matrix-sdk/src/authentication/matrix/mod.rs

@@ -105,20 +105,20 @@ impl MatrixAuth {
         idp_id: Option<&str>,
     ) -> Result<String> {
         let homeserver = self.client.homeserver();
-        let server_versions = self.client.server_versions().await?;
+        let supported_versions = self.client.supported_versions().await?;
 
         let request = if let Some(id) = idp_id {
             sso_login_with_provider::v3::Request::new(id.to_owned(), redirect_url.to_owned())
                 .try_into_http_request::<Vec<u8>>(
                     homeserver.as_str(),
                     SendAccessToken::None,
-                    &server_versions,
+                    &supported_versions,
                 )
         } else {
             sso_login::v3::Request::new(redirect_url.to_owned()).try_into_http_request::<Vec<u8>>(
                 homeserver.as_str(),
                 SendAccessToken::None,
-                &server_versions,
+                &supported_versions,
             )
         };
 

crates/matrix-sdk/src/authentication/oauth/qrcode/rendezvous_channel.rs

@@ -114,11 +114,20 @@ impl RendezvousChannel {
         client: HttpClient,
         rendezvous_server: &Url,
     ) -> Result<Self, HttpError> {
-        use ruma::api::client::rendezvous::create_rendezvous_session;
+        use std::collections::BTreeSet;
+
+        use ruma::api::{client::rendezvous::create_rendezvous_session, SupportedVersions};
 
         let request = create_rendezvous_session::unstable::Request::default();
         let response = client
-            .send(request, None, rendezvous_server.to_string(), None, &[], Default::default())
+            .send(
+                request,
+                None,
+                rendezvous_server.to_string(),
+                None,
+                &SupportedVersions { versions: BTreeSet::new(), features: vec![] },
+                Default::default(),
+            )
             .await?;
 
         let rendezvous_url = response.url;

crates/matrix-sdk/src/client/builder/homeserver_config.rs

@@ -15,7 +15,7 @@
 use ruma::{
     api::{
         client::discovery::{discover_homeserver, get_supported_versions},
-        MatrixVersion,
+        MatrixVersion, SupportedVersions,
     },
     OwnedServerName, ServerName,
 };
@@ -185,7 +185,7 @@ async fn discover_homeserver(
             Some(RequestConfig::short_retry()),
             server.to_string(),
             None,
-            &[MatrixVersion::V1_0],
+            &SupportedVersions { versions: [MatrixVersion::V1_0].into(), features: vec![] },
             Default::default(),
         )
         .await
@@ -209,7 +209,7 @@ pub(super) async fn get_supported_versions(
             Some(RequestConfig::short_retry()),
             homeserver_url.to_string(),
             None,
-            &[MatrixVersion::V1_0],
+            &SupportedVersions { versions: [MatrixVersion::V1_0].into(), features: vec![] },
             Default::default(),
         )
         .await

crates/matrix-sdk/src/client/builder/mod.rs

@@ -17,7 +17,7 @@ mod homeserver_config;
 
 #[cfg(feature = "sqlite")]
 use std::path::Path;
-use std::{fmt, sync::Arc};
+use std::{collections::BTreeSet, fmt, sync::Arc};
 
 use homeserver_config::*;
 #[cfg(feature = "e2e-encryption")]
@@ -101,7 +101,7 @@ pub struct ClientBuilder {
     store_config: BuilderStoreConfig,
     request_config: RequestConfig,
     respect_login_well_known: bool,
-    server_versions: Option<Box<[MatrixVersion]>>,
+    server_versions: Option<BTreeSet<MatrixVersion>>,
     handle_refresh_tokens: bool,
     base_client: Option<BaseClient>,
     #[cfg(feature = "e2e-encryption")]

crates/matrix-sdk/src/client/mod.rs

@@ -15,13 +15,14 @@
 // limitations under the License.
 
 use std::{
-    collections::{btree_map, BTreeMap},
+    collections::{btree_map, BTreeMap, BTreeSet},
     fmt::{self, Debug},
     future::{ready, Future},
     pin::Pin,
     sync::{Arc, Mutex as StdMutex, RwLock as StdRwLock, Weak},
 };
 
+use as_variant::as_variant;
 use caches::ClientCaches;
 use eyeball::{SharedObservable, Subscriber};
 use eyeball_im::{Vector, VectorDiff};
@@ -63,7 +64,7 @@ use ruma::{
             user_directory::search_users,
         },
         error::FromHttpResponseError,
-        MatrixVersion, OutgoingRequest,
+        MatrixVersion, OutgoingRequest, SupportedVersions,
     },
     assign,
     push::Ruleset,
@@ -1791,7 +1792,7 @@ impl Client {
                 config,
                 homeserver,
                 access_token.as_deref(),
-                &self.server_versions().await?,
+                &self.supported_versions().await?,
                 send_progress,
             )
             .await
@@ -1818,7 +1819,7 @@ impl Client {
                 request_config,
                 self.homeserver().to_string(),
                 None,
-                &[MatrixVersion::V1_0],
+                &SupportedVersions { versions: [MatrixVersion::V1_0].into(), features: vec![] },
                 Default::default(),
             )
             .await?;
@@ -1845,7 +1846,7 @@ impl Client {
                 Some(RequestConfig::short_retry()),
                 server_url_string,
                 None,
-                &[MatrixVersion::V1_0],
+                &SupportedVersions { versions: [MatrixVersion::V1_0].into(), features: vec![] },
                 Default::default(),
             )
             .await;
@@ -1928,10 +1929,10 @@ impl Client {
         // Fill both unstable features and server versions at once.
         let mut versions = server_info.known_versions();
         if versions.is_empty() {
-            versions.push(MatrixVersion::V1_0);
+            versions.insert(MatrixVersion::V1_0);
         }
 
-        guarded_server_info.server_versions = CachedValue::Cached(versions.into());
+        guarded_server_info.server_versions = CachedValue::Cached(versions);
         guarded_server_info.unstable_features = CachedValue::Cached(server_info.unstable_features);
         guarded_server_info.well_known = CachedValue::Cached(server_info.well_known);
 
@@ -1958,11 +1959,32 @@ impl Client {
     /// println!("The homeserver supports Matrix 1.1: {supports_1_1:?}");
     /// # anyhow::Ok(()) };
     /// ```
-    pub async fn server_versions(&self) -> HttpResult<Box<[MatrixVersion]>> {
+    pub async fn server_versions(&self) -> HttpResult<BTreeSet<MatrixVersion>> {
         self.get_or_load_and_cache_server_info(|server_info| server_info.server_versions.clone())
             .await
     }
 
+    pub(crate) async fn supported_versions(&self) -> HttpResult<SupportedVersions> {
+        self.get_or_load_and_cache_server_info(|server_info| {
+            match server_info
+                .server_versions
+                .as_cached_value()
+                .zip(server_info.unstable_features.as_cached_value())
+            {
+                Some((versions, features)) => CachedValue::Cached(SupportedVersions {
+                    versions: versions.iter().copied().collect(),
+                    features: features
+                        .iter()
+                        .filter(|(_, enabled)| **enabled)
+                        .map(|(feature, _)| feature.clone())
+                        .collect(),
+                }),
+                None => CachedValue::NotSet,
+            }
+        })
+        .await
+    }
+
     /// Get the unstable features supported by the homeserver by fetching them
     /// from the server or the cache.
     ///
@@ -2794,7 +2816,7 @@ impl WeakClient {
 #[derive(Clone)]
 struct ClientServerInfo {
     /// The Matrix versions the server supports (known ones only).
-    server_versions: CachedValue<Box<[MatrixVersion]>>,
+    server_versions: CachedValue<BTreeSet<MatrixVersion>>,
 
     /// The unstable features and their on/off state on the server.
     unstable_features: CachedValue<BTreeMap<String, bool>>,
@@ -2815,6 +2837,11 @@ enum CachedValue<Value> {
 }
 
 impl<Value> CachedValue<Value> {
+    /// Return the cached value, it if it exists.
+    fn as_cached_value(&self) -> Option<&Value> {
+        as_variant!(self, CachedValue::Cached)
+    }
+
     /// Unwraps the cached value, returning it if it exists.
     ///
     /// # Panics

crates/matrix-sdk/src/http_client/mod.rs

@@ -14,6 +14,7 @@
 
 use std::{
     any::type_name,
+    borrow::Cow,
     fmt::Debug,
     num::NonZeroUsize,
     sync::{
@@ -29,7 +30,7 @@ use eyeball::SharedObservable;
 use http::Method;
 use ruma::api::{
     error::{FromHttpResponseError, IntoHttpError},
-    AuthScheme, MatrixVersion, OutgoingRequest, SendAccessToken,
+    AuthScheme, OutgoingRequest, SendAccessToken, SupportedVersions,
 };
 use tokio::sync::{Semaphore, SemaphorePermit};
 use tracing::{debug, field::debug, instrument, trace};
@@ -101,17 +102,17 @@ impl HttpClient {
         config: RequestConfig,
         homeserver: String,
         access_token: Option<&str>,
-        server_versions: &[MatrixVersion],
+        supported_versions: &SupportedVersions,
     ) -> Result<http::Request<Bytes>, IntoHttpError>
     where
         R: OutgoingRequest + Debug,
     {
         trace!(request_type = type_name::<R>(), "Serializing request");
 
-        let server_versions = if config.force_matrix_version.is_some() {
-            config.force_matrix_version.as_slice()
+        let supported_versions = if let Some(matrix_version) = config.force_matrix_version {
+            Cow::Owned(SupportedVersions { versions: [matrix_version].into(), features: vec![] })
         } else {
-            server_versions
+            Cow::Borrowed(supported_versions)
         };
 
         let send_access_token = match access_token {
@@ -126,15 +127,15 @@ impl HttpClient {
         };
 
         let request = request
-            .try_into_http_request::<BytesMut>(&homeserver, send_access_token, server_versions)?
+            .try_into_http_request::<BytesMut>(&homeserver, send_access_token, &supported_versions)?
             .map(|body| body.freeze());
 
         Ok(request)
     }
 
     #[allow(clippy::too_many_arguments)]
     #[instrument(
-        skip(self, request, config, homeserver, access_token, server_versions, send_progress),
+        skip(self, request, config, homeserver, access_token, supported_versions, send_progress),
         fields(uri, method, request_size, request_id, status, response_size, sentry_event_id)
     )]
     pub async fn send<R>(
@@ -143,7 +144,7 @@ impl HttpClient {
         config: Option<RequestConfig>,
         homeserver: String,
         access_token: Option<&str>,
-        server_versions: &[MatrixVersion],
+        supported_versions: &SupportedVersions,
         send_progress: SharedObservable<TransmissionProgress>,
     ) -> Result<R::IncomingResponse, HttpError>
     where
@@ -177,7 +178,7 @@ impl HttpClient {
             }
 
             let request = self
-                .serialize_request(request, config, homeserver, access_token, server_versions)
+                .serialize_request(request, config, homeserver, access_token, supported_versions)
                 .map_err(HttpError::IntoHttp)?;
 
             let method = request.method();