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()),
@@ -504,7 +505,7 @@ impl StateStoreIntegrationTests for DynStateStore {
         let decoded_server_info = stored_info.maybe_decode().unwrap();
         let stored_supported = decoded_server_info.supported_versions();
 
-        assert_eq!(stored_supported.versions.as_ref(), versions);
+        assert_eq!(stored_supported.versions, versions);
         assert_eq!(stored_supported.features.len(), 1);
         assert!(stored_supported.features.contains(&FeatureFlag::from("org.matrix.experimental")));
 

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,18 @@ impl RendezvousChannel {
         client: HttpClient,
         rendezvous_server: &Url,
     ) -> Result<Self, HttpError> {
-        use ruma::api::client::rendezvous::create_rendezvous_session;
+        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: Default::default(), features: Default::default() },
+                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,10 @@ async fn discover_homeserver(
             Some(RequestConfig::short_retry()),
             server.to_string(),
             None,
-            &[MatrixVersion::V1_0],
+            &SupportedVersions {
+                versions: [MatrixVersion::V1_0].into(),
+                features: Default::default(),
+            },
             Default::default(),
         )
         .await
@@ -209,7 +212,10 @@ 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: Default::default(),
+            },
             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

@@ -1790,7 +1790,7 @@ impl Client {
                 config,
                 homeserver,
                 access_token.as_deref(),
-                &self.server_versions().await?,
+                &self.supported_versions().await?,
                 send_progress,
             )
             .await
@@ -1817,7 +1817,10 @@ impl Client {
                 request_config,
                 self.homeserver().to_string(),
                 None,
-                &[MatrixVersion::V1_0],
+                &SupportedVersions {
+                    versions: [MatrixVersion::V1_0].into(),
+                    features: Default::default(),
+                },
                 Default::default(),
             )
             .await?;
@@ -1844,7 +1847,10 @@ impl Client {
                 Some(RequestConfig::short_retry()),
                 server_url_string,
                 None,
-                &[MatrixVersion::V1_0],
+                &SupportedVersions {
+                    versions: [MatrixVersion::V1_0].into(),
+                    features: Default::default(),
+                },
                 Default::default(),
             )
             .await;
@@ -1988,7 +1994,7 @@ 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.supported_versions.as_ref().map(|supported| supported.versions.clone())
         })

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,20 @@ 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: Default::default(),
+            })
         } else {
-            server_versions
+            Cow::Borrowed(supported_versions)
         };
 
         let send_access_token = match access_token {
@@ -126,15 +130,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 +147,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 +181,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();