refactor: use r2d2 connection pool for DB connections

src-tauri/Cargo.toml

@@ -16,7 +16,7 @@ tauri-build = { version = "2.0.0", features = [] }
 
 [dependencies]
 chrono = { version = "0.4", features = ["serde"] }
-diesel = { version = "2.0.0", features = ["sqlite", "chrono"] }
+diesel = { version = "2.0.0", features = ["sqlite", "chrono", "r2d2"] }
 diesel_migrations = "2.0"
 git-version = "0.3.9"
 glowmarkt = { version = "0.5.3" }

src-tauri/src/commands/app.rs

@@ -129,10 +129,7 @@ pub async fn reset(app_handle: AppHandle, app_state: State<'_, AppState>) -> Res
 }
 
 fn reset_database(app_state: &AppState) -> Result<(), ApiError> {
-    let mut conn = app_state
-        .db
-        .lock()
-        .map_err(|_| ApiError::MutexPoisonedError { name: "db".into() })?;
+    let mut conn = app_state.db_pool.get()?;
 
     revert_all_migrations(&mut conn);
     db::run_migrations(&mut conn);

src-tauri/src/commands/electricity.rs

@@ -50,10 +50,10 @@ pub async fn get_raw_electricity_consumption(
     let start = parse_iso_string_to_naive_date(&start_date)?;
     let end = parse_iso_string_to_naive_date(&end_date)?;
 
-    let db_connection_clone = app_state.db.clone();
+    let connection_pool_clone = app_state.db_pool.clone();
 
     let result = async_runtime::spawn_blocking(move || {
-        let repository = SqliteElectricityConsumptionRepository::new(db_connection_clone);
+        let repository = SqliteElectricityConsumptionRepository::new(connection_pool_clone);
 
         repository.get_raw(start, end)
     })
@@ -93,10 +93,10 @@ pub async fn get_daily_electricity_consumption(
     let start = parse_iso_string_to_naive_date(&start_date)?;
     let end = parse_iso_string_to_naive_date(&end_date)?;
 
-    let db_connection_clone = app_state.db.clone();
+    let connection_pool_clone = app_state.db_pool.clone();
 
     let daily_consumption = async_runtime::spawn_blocking(move || {
-        let repository = SqliteElectricityConsumptionRepository::new(db_connection_clone);
+        let repository = SqliteElectricityConsumptionRepository::new(connection_pool_clone);
 
         repository.get_daily(start, end)
     })
@@ -127,10 +127,10 @@ pub async fn get_monthly_electricity_consumption(
     let start = parse_iso_string_to_naive_date(&start_date)?;
     let end = parse_iso_string_to_naive_date(&end_date)?;
 
-    let db_connection_clone = app_state.db.clone();
+    let connection_pool_clone = app_state.db_pool.clone();
 
     let monthly_consumption = async_runtime::spawn_blocking(move || {
-        let repository = SqliteElectricityConsumptionRepository::new(db_connection_clone);
+        let repository = SqliteElectricityConsumptionRepository::new(connection_pool_clone);
 
         repository.get_monthly(start, end)
     })
@@ -151,21 +151,21 @@ pub async fn get_monthly_electricity_consumption(
 pub async fn get_electricity_tariff_history(
     app_state: State<'_, AppState>,
 ) -> Result<TariffHistoryResponse, ApiError> {
-    let db_connection_clone = app_state.db.clone();
+    let connection_pool_clone = app_state.db_pool.clone();
 
     let standing_charge_history = async_runtime::spawn_blocking(move || {
-        let repository = SqliteElectricityTariffRepository::new(db_connection_clone);
+        let repository = SqliteElectricityTariffRepository::new(connection_pool_clone);
 
         repository.get_standing_charge_history()
     })
     .await
     .map_err(|e| ApiError::Custom(format!("Error: {}", e)))?
     .map_err(ApiError::RepositoryError)?;
 
-    let db_connection_clone = app_state.db.clone();
+    let connection_pool_clone = app_state.db_pool.clone();
 
     let unit_price_history = async_runtime::spawn_blocking(move || {
-        let repository = SqliteElectricityTariffRepository::new(db_connection_clone);
+        let repository = SqliteElectricityTariffRepository::new(connection_pool_clone);
 
         repository.get_unit_price_history()
     })
@@ -206,10 +206,10 @@ pub async fn get_electricity_cost_history(
     let start = parse_iso_string_to_naive_date(&start_date)?;
     let end = parse_iso_string_to_naive_date(&end_date)?;
 
-    let db_connection_clone = app_state.db.clone();
+    let connection_pool_clone = app_state.db_pool.clone();
 
     let mut consumption = async_runtime::spawn_blocking(move || {
-        let repository = SqliteElectricityConsumptionRepository::new(db_connection_clone);
+        let repository = SqliteElectricityConsumptionRepository::new(connection_pool_clone);
 
         repository.get_daily(start, end)
     })

src-tauri/src/commands/gas.rs

@@ -46,10 +46,10 @@ pub async fn get_raw_gas_consumption(
     let start = parse_iso_string_to_naive_date(&start_date)?;
     let end = parse_iso_string_to_naive_date(&end_date)?;
 
-    let db_connection_clone = app_state.db.clone();
+    let connection_pool_clone = app_state.db_pool.clone();
 
     let raw_consumption = async_runtime::spawn_blocking(move || {
-        let repository = SqliteGasConsumptionRepository::new(db_connection_clone);
+        let repository = SqliteGasConsumptionRepository::new(connection_pool_clone);
 
         repository.get_raw(start, end)
     })
@@ -77,10 +77,10 @@ pub async fn get_daily_gas_consumption(
     let start = parse_iso_string_to_naive_date(&start_date)?;
     let end = parse_iso_string_to_naive_date(&end_date)?;
 
-    let db_connection_clone = app_state.db.clone();
+    let connection_pool_clone = app_state.db_pool.clone();
 
     let daily_consumption = async_runtime::spawn_blocking(move || {
-        let repository = SqliteGasConsumptionRepository::new(db_connection_clone);
+        let repository = SqliteGasConsumptionRepository::new(connection_pool_clone);
 
         repository.get_daily(start, end)
     })
@@ -108,10 +108,10 @@ pub async fn get_monthly_gas_consumption(
     let start = parse_iso_string_to_naive_date(&start_date)?;
     let end = parse_iso_string_to_naive_date(&end_date)?;
 
-    let db_connection_clone = app_state.db.clone();
+    let connection_pool_clone = app_state.db_pool.clone();
 
     let monthly_consumption = async_runtime::spawn_blocking(move || {
-        let repository = SqliteGasConsumptionRepository::new(db_connection_clone);
+        let repository = SqliteGasConsumptionRepository::new(connection_pool_clone);
 
         repository.get_monthly(start, end)
     })
@@ -132,21 +132,21 @@ pub async fn get_monthly_gas_consumption(
 pub async fn get_gas_tariff_history(
     app_state: State<'_, AppState>,
 ) -> Result<TariffHistoryResponse, ApiError> {
-    let db_connection_clone = app_state.db.clone();
+    let connection_pool_clone = app_state.db_pool.clone();
 
     let standing_charge_history = async_runtime::spawn_blocking(move || {
-        let repository = SqliteGasTariffRepository::new(db_connection_clone);
+        let repository = SqliteGasTariffRepository::new(connection_pool_clone);
 
         repository.get_standing_charge_history()
     })
     .await
     .map_err(|e| ApiError::Custom(format!("Error: {}", e)))?
     .map_err(ApiError::RepositoryError)?;
 
-    let db_connection_clone = app_state.db.clone();
+    let connection_pool_clone = app_state.db_pool.clone();
 
     let unit_price_history = async_runtime::spawn_blocking(move || {
-        let repository = SqliteGasTariffRepository::new(db_connection_clone);
+        let repository = SqliteGasTariffRepository::new(connection_pool_clone);
 
         repository.get_unit_price_history()
     })
@@ -187,10 +187,10 @@ pub async fn get_gas_cost_history(
     let start = parse_iso_string_to_naive_date(&start_date)?;
     let end = parse_iso_string_to_naive_date(&end_date)?;
 
-    let db_connection_clone = app_state.db.clone();
+    let connection_pool_clone = app_state.db_pool.clone();
 
     let mut consumption = async_runtime::spawn_blocking(move || {
-        let repository = SqliteGasConsumptionRepository::new(db_connection_clone);
+        let repository = SqliteGasConsumptionRepository::new(connection_pool_clone);
 
         repository.get_daily(start, end)
     })

src-tauri/src/commands/mod.rs

@@ -26,6 +26,8 @@ pub enum ApiError {
     JoinError(#[from] tokio::task::JoinError),
     #[error("Mutex '{name}' is poisoned")]
     MutexPoisonedError { name: String },
+    #[error("Error with DB connection pool: {0}")]
+    ConnectionPoolError(#[from] diesel::r2d2::PoolError),
 }
 
 impl serde::Serialize for ApiError {

src-tauri/src/commands/profiles.rs

@@ -21,7 +21,7 @@ pub struct EnergyProfileUpdateParam {
 
 #[tauri::command]
 pub fn get_energy_profiles(app_state: State<'_, AppState>) -> Result<Vec<EnergyProfile>, ApiError> {
-    let repository = SqliteEnergyProfileRepository::new(app_state.db.clone());
+    let repository = SqliteEnergyProfileRepository::new(app_state.db_pool.clone());
 
     repository
         .get_all_energy_profiles()
@@ -45,7 +45,7 @@ pub async fn update_energy_profile_settings(
         })
         .collect();
 
-    let repository = SqliteEnergyProfileRepository::new(app_state.db.clone());
+    let repository = SqliteEnergyProfileRepository::new(app_state.db_pool.clone());
 
     for (energy_profile_id, is_active, start) in update_settings? {
         debug!("Updating {}, {}, {}", energy_profile_id, is_active, start);

src-tauri/src/data/consumption.rs

@@ -1,14 +1,16 @@
-use std::sync::{Arc, Mutex, MutexGuard};
-
 use chrono::{NaiveDate, NaiveDateTime};
 use diesel::dsl::sql;
 use diesel::insert_into;
+use diesel::r2d2::ConnectionManager;
+use diesel::r2d2::Pool;
+use diesel::r2d2::PooledConnection;
 use diesel::SqliteConnection;
 use diesel::{prelude::*, upsert::excluded};
 use log::error;
 use rust_decimal::prelude::ToPrimitive;
 use rust_decimal::Decimal;
 
+use crate::db::SqliteConnectionPool;
 use crate::schema::{electricity_consumption, gas_consumption};
 use crate::utils::london_date_id_to_naive_date;
 use crate::utils::{
@@ -84,18 +86,18 @@ pub trait ConsumptionRepository<T, U> {
 }
 
 pub struct SqliteElectricityConsumptionRepository {
-    conn: Arc<Mutex<SqliteConnection>>,
+    connection_pool: Pool<ConnectionManager<SqliteConnection>>,
 }
 
 impl SqliteElectricityConsumptionRepository {
-    pub fn new(conn: Arc<Mutex<SqliteConnection>>) -> Self {
-        Self { conn }
+    pub fn new(connection_pool: Pool<ConnectionManager<SqliteConnection>>) -> Self {
+        Self { connection_pool }
     }
 
-    fn get_connection(&self) -> RepositoryResult<MutexGuard<'_, SqliteConnection>> {
-        self.conn
-            .lock()
-            .map_err(|_| RepositoryError::SqliteConnectionMutexPoisonedError())
+    fn get_connection(
+        &self,
+    ) -> RepositoryResult<PooledConnection<ConnectionManager<SqliteConnection>>> {
+        Ok(self.connection_pool.get()?)
     }
 }
 
@@ -220,18 +222,18 @@ impl ConsumptionRepository<ElectricityConsumptionValue, ElectricityConsumptionRe
 }
 
 pub struct SqliteGasConsumptionRepository {
-    connection: Arc<Mutex<SqliteConnection>>,
+    connection_pool: SqliteConnectionPool,
 }
 
 impl SqliteGasConsumptionRepository {
-    pub fn new(connection: Arc<Mutex<SqliteConnection>>) -> Self {
-        Self { connection }
+    pub fn new(connection_pool: SqliteConnectionPool) -> Self {
+        Self { connection_pool }
     }
 
-    fn get_connection(&self) -> RepositoryResult<MutexGuard<'_, SqliteConnection>> {
-        self.connection
-            .lock()
-            .map_err(|_| RepositoryError::SqliteConnectionMutexPoisonedError())
+    fn get_connection(
+        &self,
+    ) -> RepositoryResult<PooledConnection<ConnectionManager<SqliteConnection>>> {
+        Ok(self.connection_pool.get()?)
     }
 }
 

src-tauri/src/data/energy_profile.rs

@@ -1,10 +1,11 @@
-use std::sync::{Arc, Mutex, MutexGuard};
-
 use chrono::{Datelike, Local, NaiveDateTime};
 use diesel::dsl::*;
 use diesel::prelude::*;
+use diesel::r2d2::ConnectionManager;
+use diesel::r2d2::PooledConnection;
 use serde::Serialize;
 
+use crate::db::SqliteConnectionPool;
 use crate::schema::energy_profile;
 
 #[derive(Serialize, Queryable, Debug)]
@@ -47,32 +48,30 @@ pub trait EnergyProfileRepository {
 }
 
 pub struct SqliteEnergyProfileRepository {
-    conn: Arc<Mutex<SqliteConnection>>,
+    connection_pool: SqliteConnectionPool,
 }
 
 impl SqliteEnergyProfileRepository {
-    pub fn new(conn: Arc<Mutex<SqliteConnection>>) -> Self {
-        Self { conn }
+    pub fn new(connection_pool: SqliteConnectionPool) -> Self {
+        Self { connection_pool }
     }
 
-    fn connection(&self) -> MutexGuard<'_, SqliteConnection> {
-        self.conn
-            .lock()
-            .expect("Could not acquire lock on SqliteConnection")
+    fn get_connection(&self) -> PooledConnection<ConnectionManager<SqliteConnection>> {
+        self.connection_pool.get().unwrap()
     }
 }
 
 impl EnergyProfileRepository for SqliteEnergyProfileRepository {
     fn get_energy_profile(&self, name: &str) -> QueryResult<EnergyProfile> {
-        let mut conn = self.connection();
+        let mut conn = self.get_connection();
 
         energy_profile::table
             .filter(energy_profile::name.eq(name))
             .get_result(&mut *conn)
     }
 
     fn get_all_energy_profiles(&self) -> QueryResult<Vec<EnergyProfile>> {
-        let mut conn = self.connection();
+        let mut conn = self.get_connection();
         energy_profile::table.load::<EnergyProfile>(&mut *conn)
     }
 
@@ -89,7 +88,7 @@ impl EnergyProfileRepository for SqliteEnergyProfileRepository {
             base_unit,
         };
 
-        let mut conn = self.connection();
+        let mut conn = self.get_connection();
 
         diesel::insert_into(energy_profile::table)
             .values(&new_profile)
@@ -109,7 +108,7 @@ impl EnergyProfileRepository for SqliteEnergyProfileRepository {
     ) -> QueryResult<EnergyProfile> {
         use crate::schema::energy_profile::dsl::*;
 
-        let mut conn = self.connection();
+        let mut conn = self.get_connection();
 
         diesel::update(energy_profile.find(energy_profile_id_param))
             .set((
@@ -136,7 +135,7 @@ impl EnergyProfileRepository for SqliteEnergyProfileRepository {
     ) -> QueryResult<EnergyProfile> {
         use crate::schema::energy_profile::dsl::*;
 
-        let mut conn = self.connection();
+        let mut conn = self.get_connection();
 
         diesel::update(energy_profile.find(energy_profile_id_param))
             .set((