bugfix: ensure the SessionStore is cleared when regenerating the OlmMachine

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

@@ -220,7 +220,9 @@ impl BaseClient {
         tracing::debug!("regenerating OlmMachine");
         let session_meta = self.session_meta().ok_or(Error::OlmError(OlmError::MissingSession))?;
 
-        // Recreate it.
+        // Recreate the `OlmMachine` and wipe the in-memory cache in the store
+        // because we suspect it has stale data.
+        self.crypto_store.clear_caches().await;
         let olm_machine = OlmMachine::with_store(
             &session_meta.user_id,
             &session_meta.device_id,

crates/matrix-sdk-crypto/CHANGELOG.md

@@ -25,6 +25,9 @@ Breaking changes:
 
 Additions:
 
+- Expose new method `CryptoStore::clear_caches`.
+  ([#3338](https://github.com/matrix-org/matrix-rust-sdk/pull/3338))
+
 - Expose new method `OlmMachine::device_creation_time`.
   ([#3275](https://github.com/matrix-org/matrix-rust-sdk/pull/3275))
 

crates/matrix-sdk-crypto/src/store/caches.rs

@@ -48,6 +48,13 @@ impl SessionStore {
         Self::default()
     }
 
+    /// Clear all entries in the session store.
+    ///
+    /// This is intended to be used when regenerating olm machines.
+    pub fn clear(&self) {
+        self.entries.write().unwrap().clear()
+    }
+
     /// Add a session to the store.
     ///
     /// Returns true if the session was added, false if the session was

crates/matrix-sdk-crypto/src/store/memorystore.rs

@@ -145,6 +145,14 @@ type Result<T> = std::result::Result<T, Infallible>;
 impl CryptoStore for MemoryStore {
     type Error = Infallible;
 
+    async fn clear_caches(&self) {
+        // no-op: it makes no sense to delete fields here as we would forget our
+        // identity, etc Effectively we have no caches as the fields
+        // *are* the underlying store. Calling this method only makes
+        // sense if there is some other layer (e.g disk) persistence
+        // happening.
+    }
+
     async fn load_account(&self) -> Result<Option<Account>> {
         Ok(self.account.read().unwrap().as_ref().map(|acc| acc.deep_clone()))
     }
@@ -718,6 +726,10 @@ mod integration_tests {
     impl CryptoStore for PersistentMemoryStore {
         type Error = <MemoryStore as CryptoStore>::Error;
 
+        async fn clear_caches(&self) {
+            self.0.clear_caches().await
+        }
+
         async fn load_account(&self) -> Result<Option<Account>, Self::Error> {
             self.0.load_account().await
         }

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

@@ -303,6 +303,13 @@ pub trait CryptoStore: AsyncTraitDeps {
 
     /// Load the next-batch token for a to-device query, if any.
     async fn next_batch_token(&self) -> Result<Option<String>, Self::Error>;
+
+    /// Clear any in-memory caches because they may be out of sync with the
+    /// underlying data store.
+    ///
+    /// If the store does not have any underlying persistence (e.g in-memory
+    /// store) then this should be a no-op.
+    async fn clear_caches(&self);
 }
 
 #[repr(transparent)]
@@ -320,6 +327,10 @@ impl<T: fmt::Debug> fmt::Debug for EraseCryptoStoreError<T> {
 impl<T: CryptoStore> CryptoStore for EraseCryptoStoreError<T> {
     type Error = CryptoStoreError;
 
+    async fn clear_caches(&self) {
+        self.0.clear_caches().await
+    }
+
     async fn load_account(&self) -> Result<Option<Account>> {
         self.0.load_account().await.map_err(Into::into)
     }

crates/matrix-sdk-indexeddb/src/crypto_store/mod.rs

@@ -1273,6 +1273,12 @@ impl_crypto_store! {
             }
         }
     }
+
+    async fn clear_caches(&self) {
+        self.session_cache.clear()
+        // We don't need to clear static_account as it only contains immutable data
+        // therefore cannot get out of sync with the underlying store.
+    }
 }
 
 impl Drop for IndexeddbCryptoStore {

crates/matrix-sdk-sqlite/src/crypto_store.rs

@@ -682,6 +682,13 @@ impl SqliteObjectCryptoStoreExt for deadpool_sqlite::Object {}
 impl CryptoStore for SqliteCryptoStore {
     type Error = Error;
 
+    async fn clear_caches(&self) {
+        self.session_cache.clear()
+        // We don't need to clear static_account as it only contains immutable
+        // data therefore cannot get out of sync with the underlying
+        // store.
+    }
+
     async fn load_account(&self) -> Result<Option<Account>> {
         let conn = self.acquire().await?;
         if let Some(pickle) = conn.get_kv("account").await? {