chore(sqlite): Remove connection::Config.

This patch removes the `connection::Config` type. It was “inspired”
from `deadpool_sqlite`, but we can clearly remove it by using our own
`SqliteStoreConfig` type. It simplifies the way we open a database.

Author: Hywan

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

@@ -67,44 +67,11 @@
 use std::{convert::Infallible, path::PathBuf};
 
 pub use deadpool::managed::reexports::*;
-use deadpool::managed::{self, Metrics, PoolConfig, RecycleError};
+use deadpool::managed::{self, Metrics, RecycleError};
 use deadpool_sync::SyncWrapper;
 
 /// The default runtime used by `matrix-sdk-sqlite` for `deadpool`.
-const RUNTIME: Runtime = Runtime::Tokio1;
-
-/// The configuration of a connection.
-#[derive(Clone, Debug)]
-pub struct Config {
-    path: PathBuf,
-    pool_config: PoolConfig,
-}
-
-impl Config {
-    /// Create a new [`Config`].
-    ///
-    /// `path` represents the path to the database. `pool_config` represents the
-    /// [`PoolConfig`].
-    #[must_use]
-    pub fn new(path: impl Into<PathBuf>, pool_config: PoolConfig) -> Self {
-        Self { path: path.into(), pool_config }
-    }
-
-    /// Creates a new [`Pool`].
-    ///
-    /// # Errors
-    ///
-    /// See [`CreatePoolError`] for details.
-    pub fn create_pool(&self) -> Result<Pool, managed::CreatePoolError<Infallible>> {
-        let manager = Manager::from_config(self);
-
-        Pool::builder(manager)
-            .config(self.pool_config)
-            .runtime(RUNTIME)
-            .build()
-            .map_err(CreatePoolError::Build)
-    }
-}
+pub const RUNTIME: Runtime = Runtime::Tokio1;
 
 deadpool::managed_reexports!(
     "matrix-sdk-sqlite",
@@ -121,15 +88,14 @@ pub type Connection = Object;
 /// [`Connection`]s.
 #[derive(Debug)]
 pub struct Manager {
-    config: Config,
+    database_path: PathBuf,
 }
 
 impl Manager {
-    /// Creates a new [`Manager`] using the given [`Config`] backed by the
-    /// specified [`Runtime`].
+    /// Creates a new [`Manager`] for a database.
     #[must_use]
-    fn from_config(config: &Config) -> Self {
-        Self { config: config.clone() }
+    pub fn new(database_path: PathBuf) -> Self {
+        Self { database_path }
     }
 }
 
@@ -138,7 +104,7 @@ impl managed::Manager for Manager {
     type Error = rusqlite::Error;
 
     async fn create(&self) -> Result<Self::Type, Self::Error> {
-        let path = self.config.path.clone();
+        let path = self.database_path.clone();
         SyncWrapper::new(RUNTIME, move || rusqlite::Connection::open(path)).await
     }
 

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

@@ -46,7 +46,7 @@ use tracing::{debug, instrument, warn};
 use vodozemac::Curve25519PublicKey;
 
 use crate::{
-    connection::{self, Connection as SqliteAsyncConn, Pool as SqlitePool},
+    connection::{Connection as SqliteAsyncConn, Pool as SqlitePool},
     error::{Error, Result},
     utils::{
         repeat_vars, EncryptableStore, Key, SqliteAsyncConnExt, SqliteKeyValueStoreAsyncConnExt,
@@ -103,15 +103,12 @@ impl SqliteCryptoStore {
 
     /// Open the SQLite-based crypto store with the config open config.
     pub async fn open_with_config(config: SqliteStoreConfig) -> Result<Self, OpenStoreError> {
-        let SqliteStoreConfig { path, pool_config, runtime_config, secret } = config;
+        fs::create_dir_all(&config.path).await.map_err(OpenStoreError::CreateDir)?;
 
-        fs::create_dir_all(&path).await.map_err(OpenStoreError::CreateDir)?;
+        let pool = config.build_pool_of_connections(DATABASE_NAME)?;
 
-        let config = connection::Config::new(path.join(DATABASE_NAME), pool_config);
-        let pool = config.create_pool()?;
-
-        let this = Self::open_with_pool(pool, secret).await?;
-        this.pool.get().await?.apply_runtime_config(runtime_config).await?;
+        let this = Self::open_with_pool(pool, config.secret).await?;
+        this.pool.get().await?.apply_runtime_config(config.runtime_config).await?;
 
         Ok(this)
     }

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

@@ -130,15 +130,12 @@ impl SqliteEventCacheStore {
 
         let _timer = timer!("open_with_config");
 
-        let SqliteStoreConfig { path, pool_config, runtime_config, secret } = config;
+        fs::create_dir_all(&config.path).await.map_err(OpenStoreError::CreateDir)?;
 
-        fs::create_dir_all(&path).await.map_err(OpenStoreError::CreateDir)?;
+        let pool = config.build_pool_of_connections(DATABASE_NAME)?;
 
-        let config = crate::connection::Config::new(path.join(DATABASE_NAME), pool_config);
-        let pool = config.create_pool()?;
-
-        let this = Self::open_with_pool(pool, secret).await?;
-        this.write().await?.apply_runtime_config(runtime_config).await?;
+        let this = Self::open_with_pool(pool, config.secret).await?;
+        this.write().await?.apply_runtime_config(config.runtime_config).await?;
 
         Ok(this)
     }

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

@@ -207,6 +207,21 @@ impl SqliteStoreConfig {
         self.runtime_config.journal_size_limit = limit;
         self
     }
+
+    /// Build a pool of active connections to a particular database.
+    pub fn build_pool_of_connections(
+        &self,
+        database_name: &str,
+    ) -> Result<connection::Pool, connection::CreatePoolError> {
+        let path = self.path.join(database_name);
+        let manager = connection::Manager::new(path);
+
+        connection::Pool::builder(manager)
+            .config(self.pool_config)
+            .runtime(connection::RUNTIME)
+            .build()
+            .map_err(connection::CreatePoolError::Build)
+    }
 }
 
 /// This type represents values to set at runtime when a database is opened.

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

@@ -38,7 +38,7 @@ use tokio::{
 use tracing::{debug, instrument, trace};
 
 use crate::{
-    connection::{self, Connection as SqliteAsyncConn, Pool as SqlitePool},
+    connection::{Connection as SqliteAsyncConn, Pool as SqlitePool},
     error::{Error, Result},
     utils::{
         repeat_vars, time_to_timestamp, EncryptableStore, SqliteAsyncConnExt,
@@ -122,15 +122,12 @@ impl SqliteMediaStore {
 
         let _timer = timer!("open_with_config");
 
-        let SqliteStoreConfig { path, secret, pool_config, runtime_config } = config;
+        fs::create_dir_all(&config.path).await.map_err(OpenStoreError::CreateDir)?;
 
-        fs::create_dir_all(&path).await.map_err(OpenStoreError::CreateDir)?;
+        let pool = config.build_pool_of_connections(DATABASE_NAME)?;
 
-        let config = connection::Config::new(path.join(DATABASE_NAME), pool_config);
-        let pool = config.create_pool()?;
-
-        let this = Self::open_with_pool(pool, secret).await?;
-        this.write().await?.apply_runtime_config(runtime_config).await?;
+        let this = Self::open_with_pool(pool, config.secret).await?;
+        this.write().await?.apply_runtime_config(config.runtime_config).await?;
 
         Ok(this)
     }

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

@@ -45,7 +45,7 @@ use tokio::{
 use tracing::{debug, instrument, trace, warn};
 
 use crate::{
-    connection::{self, Connection as SqliteAsyncConn, Pool as SqlitePool},
+    connection::{Connection as SqliteAsyncConn, Pool as SqlitePool},
     error::{Error, Result},
     utils::{
         repeat_vars, EncryptableStore, Key, SqliteAsyncConnExt, SqliteKeyValueStoreAsyncConnExt,
@@ -123,15 +123,12 @@ impl SqliteStateStore {
 
     /// Open the SQLite-based state store with the config open config.
     pub async fn open_with_config(config: SqliteStoreConfig) -> Result<Self, OpenStoreError> {
-        let SqliteStoreConfig { path, pool_config, runtime_config, secret } = config;
+        fs::create_dir_all(&config.path).await.map_err(OpenStoreError::CreateDir)?;
 
-        fs::create_dir_all(&path).await.map_err(OpenStoreError::CreateDir)?;
+        let pool = config.build_pool_of_connections(DATABASE_NAME)?;
 
-        let config = connection::Config::new(path.join(DATABASE_NAME), pool_config);
-        let pool = config.create_pool()?;
-
-        let this = Self::open_with_pool(pool, secret).await?;
-        this.pool.get().await?.apply_runtime_config(runtime_config).await?;
+        let this = Self::open_with_pool(pool, config.secret).await?;
+        this.pool.get().await?.apply_runtime_config(config.runtime_config).await?;
 
         Ok(this)
     }
@@ -2407,10 +2404,9 @@ mod migration_tests {
 
     use super::{init, keys, SqliteStateStore, DATABASE_NAME};
     use crate::{
-        connection,
         error::{Error, Result},
         utils::{EncryptableStore as _, SqliteAsyncConnExt, SqliteKeyValueStoreAsyncConnExt},
-        OpenStoreError, PoolConfig, Secret,
+        OpenStoreError, Secret, SqliteStoreConfig,
     };
 
     static TMP_DIR: Lazy<TempDir> = Lazy::new(|| tempdir().unwrap());
@@ -2423,10 +2419,11 @@ mod migration_tests {
     }
 
     async fn create_fake_db(path: &Path, version: u8) -> Result<SqliteStateStore> {
-        fs::create_dir_all(&path).await.map_err(OpenStoreError::CreateDir).unwrap();
+        let config = SqliteStoreConfig::new(path);
+
+        fs::create_dir_all(&config.path).await.map_err(OpenStoreError::CreateDir).unwrap();
 
-        let config = connection::Config::new(path.join(DATABASE_NAME), PoolConfig::default());
-        let pool = config.create_pool().unwrap();
+        let pool = config.build_pool_of_connections(DATABASE_NAME).unwrap();
         let conn = pool.get().await?;
 
         init(&conn).await?;