refactor: improve database connection handling and organization

Cargo.lock

···
 ]
 
 [[package]]
+name = "arc-swap"
+version = "1.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69f7f8c3906b62b754cd5326047894316021dcfe5a194c8ea52bdd94934a3457"
+
+[[package]]
 name = "async-stream"
 version = "0.3.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
 
 [[package]]
+name = "backon"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cffb0e931875b666fc4fcb20fee52e9bbd1ef836fd9e9e04ec21555f9f85f7ef"
+dependencies = [
+ "fastrand",
+]
+
+[[package]]
 name = "backtrace"
 version = "0.3.74"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
 
 [[package]]
+name = "bb8"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d89aabfae550a5c44b43ab941844ffcd2e993cb6900b342debf59e9ea74acdb8"
+dependencies = [
+ "async-trait",
+ "futures-util",
+ "parking_lot",
+ "tokio",
+]
+
+[[package]]
+name = "bb8-postgres"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56ac82c42eb30889b5c4ee4763a24b8c566518171ebea648cd7e3bc532c60680"
+dependencies = [
+ "async-trait",
+ "bb8",
+ "tokio",
+ "tokio-postgres",
+]
+
+[[package]]
+name = "bb8-redis"
+version = "0.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1781f22daa0ae97d934fdf04a5c66646f154a164c4bdc157ec8d3c11166c05cc"
+dependencies = [
+ "async-trait",
+ "bb8",
+ "redis",
+]
+
+[[package]]
 name = "bcrypt"
 version = "0.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "ba5a308b75df32fe02788e748662718f03fde005016435c444eea572398219fd"
 dependencies = [
  "bytes",
+ "futures-core",
  "memchr",
+ "pin-project-lite",
+ "tokio",
+ "tokio-util",
 ]
 
 [[package]]
···
 dependencies = [
  "futures-channel",
  "futures-core",
+ "futures-executor",
  "futures-io",
  "futures-sink",
  "futures-task",
···
 version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e"
+
+[[package]]
+name = "futures-executor"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "futures-util",
+]
 
 [[package]]
 name = "futures-io"
···
  "httpdate",
  "itoa",
  "pin-project-lite",
- "socket2 0.5.9",
+ "socket2",
  "tokio",
  "tower-service",
  "tracing",
···
 ]
 
 [[package]]
+name = "itertools"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
+dependencies = [
+ "either",
+]
+
+[[package]]
 name = "itoa"
 version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 version = "0.1.0"
 dependencies = [
  "base64",
+ "bb8",
+ "bb8-postgres",
+ "bb8-redis",
  "bcrypt",
  "cynthia_con",
  "dotenv",
- "r2d2",
  "redis",
  "regex",
  "rocket",
···
 checksum = "74765f6d916ee2faa39bc8e68e4f3ed8949b48cccdac59983d287a7cb71ce9c5"
 
 [[package]]
-name = "r2d2"
-version = "0.8.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "51de85fb3fb6524929c8a2eb85e6b6d363de4e8c48f9e2c2eac4944abc181c93"
-dependencies = [
- "log",
- "parking_lot",
- "scheduled-thread-pool",
-]
-
-[[package]]
 name = "rand"
 version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 
 [[package]]
 name = "redis"
-version = "0.32.4"
+version = "0.27.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1f66bf4cac9733a23bcdf1e0e01effbaaad208567beba68be8f67e5f4af3ee1"
+checksum = "09d8f99a4090c89cc489a94833c901ead69bfbf3877b4867d5482e321ee875bc"
 dependencies = [
+ "arc-swap",
+ "async-trait",
+ "backon",
+ "bytes",
  "combine",
+ "futures",
+ "futures-util",
+ "itertools",
  "itoa",
  "num-bigint",
  "percent-encoding",
- "r2d2",
+ "pin-project-lite",
  "ryu",
  "sha1_smol",
- "socket2 0.6.0",
+ "socket2",
+ "tokio",
+ "tokio-util",
  "url",
 ]
 
···
 checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f"
 
 [[package]]
-name = "scheduled-thread-pool"
-version = "0.2.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3cbc66816425a074528352f5789333ecff06ca41b36b0b0efdfbb29edc391a19"
-dependencies = [
- "parking_lot",
-]
-
-[[package]]
 name = "scoped-tls"
 version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 dependencies = [
  "libc",
  "windows-sys 0.52.0",
-]
-
-[[package]]
-name = "socket2"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "233504af464074f9d066d7b5416c5f9b894a5862a6506e306f7b816cdd6f1807"
-dependencies = [
- "libc",
- "windows-sys 0.59.0",
 ]
 
 [[package]]
···
  "parking_lot",
  "pin-project-lite",
  "signal-hook-registry",
- "socket2 0.5.9",
+ "socket2",
  "tokio-macros",
  "windows-sys 0.52.0",
 ]
···
  "postgres-protocol",
  "postgres-types",
  "rand 0.9.1",
- "socket2 0.5.9",
+ "socket2",
  "tokio",
  "tokio-util",
  "whoami",

server/Cargo.toml

···
 dotenv = "0.15.0"
 tokio-postgres = { version = "0.7.13", features = ["with-uuid-1"] }
 bcrypt = "0.17.0"
-r2d2 = "0.8.10"
+bb8 = "0.8"
+bb8-postgres = "0.8"
+bb8-redis = "0.17"
 tabled = "0.20.0"
 regex = "1.10.5"
-redis = { version = "0.32.4", features = ["r2d2"] }
+redis = { version = "0.27", features = ["tokio-comp", "connection-manager"] }
 time = "0.3.20"
 base64 = "0.22"

server/src/client_communication.rs

···
 ) -> ws::Channel<'k> {
     let ev_log = {
         let appstate = state.0.clone();
-        appstate.event_logger.clone().await
+        appstate.event_logger.clone()
     };
     http_code_elog!(ev_log, 200, "/connection");
     use rocket::futures::{SinkExt, StreamExt};
···
                                                                                 "User created: {}",
                                                                                 user.clone().username.color_bright_cyan()
                                                                             );
-													match User::create_session(user, db, ev_log.clone().await).await {
+													match User::create_session(user, db, ev_log.clone()).await {
 														Ok((session_reference, user)) => {
 															client_session_data.user =
 																Some(user.clone());
···
 															match e {
 																LuminaError::Postgres(e) =>
 																	error_elog!(ev_log,"While creating session token: {:?}", e),
-																LuminaError::R2D2Pool(e) =>
-																	warn_elog!(ev_log,"There was an error creating session token: {:?}", e),
+																LuminaError::Bb8Pool(e) =>
+																	warn_elog!(ev_log,"There was an error creating session token: {}", e),
 																_ => {}
 															}
 															// I would return a more specific error message
···
 										} else {
 											let appstate = state.0.clone();
 											let db = &appstate.db.lock().await;
-											let msgback = match User::authenticate(email_username.clone(), password, db, ev_log.clone().await).await {
+											let msgback = match User::authenticate(email_username.clone(), password, db, ev_log.clone()).await {
 												Ok((session_reference, user)) => {
 													incoming_elog!(ev_log,"User {} authenticated to session with id {}.\n{}", user.username.clone().color_bright_cyan(), session_reference.session_id.to_string().color_pink(), format!("(User id: {})", user.id).style_dim());
 													client_session_data.user = Some(user.clone());
···
 										let db = &appstate.db.lock().await;
 										// Fetch post IDs for the requested timeline
 										match fetch_timeline_post_ids_by_timeline_name(
-											ev_log.clone().await,
+											ev_log.clone(),
 											db,
 											&name,
 											client_session_data.user.clone().unwrap(),

server/src/database.rs

···
 use crate::timeline;
 use crate::{info_elog, success_elog, warn_elog};
 use cynthia_con::{CynthiaColors, CynthiaStyles};
-use r2d2::Pool;
-use redis::Commands;
+use bb8::Pool;
+use bb8_postgres::PostgresConnectionManager;
+use bb8_redis::RedisConnectionManager;
 use tokio_postgres as postgres;
-use tokio_postgres::tls::NoTlsStream;
-use tokio_postgres::{Client, Connection, Socket};
+use tokio_postgres::NoTls;
+use std::time::Duration;    
 
-pub(crate) async fn setup() -> Result<DbConn, LuminaError> {
-    let ev_log = EventLogger::new(&None).await;
+pub(crate) async fn setup() -> Result<PgConn, LuminaError> {
+    let ev_log = EventLogger::new(&None);
     let redis_url =
         std::env::var("LUMINA_REDIS_URL").unwrap_or_else(|_| "redis://127.0.0.1/".into());
-    let redis_pool: Pool<redis::Client> = {
+    let redis_pool = {
         info_elog!(ev_log, "Setting up Redis connection to {}...", redis_url);
-        let client = redis::Client::open(redis_url.clone()).map_err(LuminaError::Redis)?;
-        Pool::builder().build(client).map_err(LuminaError::R2D2Pool)
-    }?;
-    success_elog!(
-        ev_log,
-        "Redis connection to {} created successfully.",
-        redis_url
-    );
+        let manager = RedisConnectionManager::new(redis_url.clone()).map_err(LuminaError::Redis)?;
+        // Configure pool sizes
+        let redis_pool = Pool::builder()
+            .max_size(50)
+            .connection_timeout(Duration::from_secs(5))
+            .idle_timeout(Some(Duration::from_secs(300)))
+            .build(manager).await?;
+        success_elog!(
+            ev_log,
+            "Redis connection to {} created successfully.",
+            redis_url
+        );
+
+        redis_pool
+    };
 
     {
         let pg_config: tokio_postgres::Config = {
···
             pg_config
         };
 
-        // Connect to the database
-        let conn: (Client, Connection<Socket, NoTlsStream>) = pg_config
-            .connect(postgres::tls::NoTls)
+        // Create Postgres connection pool
+        let pg_manager = PostgresConnectionManager::new(pg_config.clone(), NoTls);
+        let pg_pool = Pool::builder()
+            .build(pg_manager)
             .await
-            .map_err(LuminaError::Postgres)?;
-        tokio::spawn(conn.1);
-        // Create a second connection to the database for spawning the maintain function
-        let conn_two: (Client, Connection<Socket, NoTlsStream>) = pg_config
-            .connect(postgres::tls::NoTls)
-            .await
-            .map_err(LuminaError::Postgres)?;
-        tokio::spawn(conn_two.1);
+            .map_err(|e| LuminaError::Bb8Pool(e.to_string()))?;
         {
-            conn.0
+            let pg_conn = pg_pool.get().await.map_err(|e| LuminaError::Bb8Pool(e.to_string()))?;
+            pg_conn
                 .batch_execute(include_str!("../../SQL/create_pg.sql"))
                 .await
                 .map_err(LuminaError::Postgres)?;
 
             // Populate bloom filters
-            let mut redis_conn = redis_pool.get().map_err(LuminaError::R2D2Pool)?;
+            let mut redis_conn = redis_pool.get().await.map_err(|e| LuminaError::Bb8Pool(e.to_string()))?;
             let email_key = "bloom:email";
             let username_key = "bloom:username";
 
-            let rows = conn
-                .0
+            let rows = pg_conn
                 .query("SELECT email, username FROM users", &[])
                 .await
                 .map_err(LuminaError::Postgres)?;
···
                 let _: () = redis::cmd("BF.ADD")
                     .arg(email_key)
                     .arg(email)
-                    .query(&mut *redis_conn)
+                    .query_async(&mut *redis_conn)
+                    .await
                     .map_err(LuminaError::Redis)?;
                 let _: () = redis::cmd("BF.ADD")
                     .arg(username_key)
                     .arg(username)
-                    .query(&mut *redis_conn)
+                    .query_async(&mut *redis_conn)
+                    .await
                     .map_err(LuminaError::Redis)?;
             }
             info_elog!(ev_log, "Bloom filters populated from PostgreSQL.",);
         };
-        let conn_clone = conn_two.0;
-        let pg_config_clone = pg_config.clone();
+        let pg_pool_clone = pg_pool.clone();
         let redis_pool_clone = redis_pool.clone();
         tokio::spawn(async move {
-            maintain(DbConn::PgsqlConnection(
-                (conn_clone, pg_config_clone),
-                redis_pool_clone,
-            ))
+            maintain(PgConn {
+                postgres_pool: pg_pool_clone,
+                redis_pool: redis_pool_clone,
+            })
             .await
         });
-        Ok(DbConn::PgsqlConnection((conn.0, pg_config), redis_pool))
+        Ok(PgConn {
+            postgres_pool: pg_pool,
+            redis_pool,
+        })
     }
 }
 
 /// This enum contains the postgres and redis connection and pool respectively. It used to have more variants before, and maybe it will once again.
 #[derive()]
 pub enum DbConn {
-    // The config is also shared, so that for example the logger can set up its own connection, use this sparingly.
     /// The main database is a Postgres database in this variant.
-    PgsqlConnection((Client, postgres::Config), Pool<redis::Client>),
+    PgsqlConnection(Pool<PostgresConnectionManager<NoTls>>, Pool<RedisConnectionManager>),
 }
 
 pub(crate) trait DatabaseConnections {
···
     /// This is useful for functions that need to access redis but not the main database
     /// such as timeline cache management
     /// This returns a clone of the pool without recreating it entirely, so it is cheap to call
-    fn get_redis_pool(&self) -> Pool<redis::Client>;
+    fn get_redis_pool(&self) -> Pool<RedisConnectionManager>;
+
+    /// Get a reference to the Postgres pool
+    /// This returns a clone of the pool without recreating it entirely, so it is cheap to call
+    fn get_postgres_pool(&self) -> Pool<PostgresConnectionManager<NoTls>>;
 
     /// Recreate the database connection.
-    async fn recreate(&self) -> Result<Self, LuminaError>
+    async fn recreate(&self) -> PgConn
     where
         Self: Sized;
 }
 
 impl DatabaseConnections for DbConn {
     /// Recreate the database connection.
-    /// This clones the pool on sqlite and for redis, and creates a new connection on postgres.
-    async fn recreate(&self) -> Result<Self, LuminaError> {
+    /// This clones the pools - bb8 pools are cheap to clone as they share the underlying connections.
+      // This function converts a generic DbConn to the more concrete PgConn type. 
+      async fn recreate(&self) -> PgConn {
+        PgConn {
+            postgres_pool: self.get_postgres_pool(),
+            redis_pool: self.get_redis_pool(),
+        }
+    }
+
+    fn get_redis_pool(&self) -> Pool<RedisConnectionManager> {
         match self {
-            DbConn::PgsqlConnection((_, config), redis_pool) => {
-                let c = config
-                    .connect(tokio_postgres::tls::NoTls)
-                    .await
-                    .map_err(LuminaError::Postgres)?
-                    .0;
-                let r = redis_pool.clone();
-
-                Ok(DbConn::PgsqlConnection((c, config.to_owned()), r))
-            }
+            DbConn::PgsqlConnection(_, redis_pool) => redis_pool.clone(),
         }
     }
-
-    fn get_redis_pool(&self) -> Pool<redis::Client> {
+    fn get_postgres_pool(&self) -> Pool<PostgresConnectionManager<NoTls>> {
         match self {
-            DbConn::PgsqlConnection((_, _), redis_pool) => redis_pool.clone(),
+            DbConn::PgsqlConnection(pg_pool, _) => pg_pool.clone(),
         }
     }
 }
 
+
 impl DatabaseConnections for PgConn {
-    fn get_redis_pool(&self) -> Pool<redis::Client> {
+    fn get_redis_pool(&self) -> Pool<RedisConnectionManager> {
         self.redis_pool.clone()
     }
 
-    async fn recreate(&self) -> Result<Self, LuminaError> {
-        let postgres = self
-            .postgres_config
-            .connect(tokio_postgres::tls::NoTls)
-            .await
-            .map_err(LuminaError::Postgres)?
-            .0;
-        let postgres_config = self.postgres_config.to_owned();
-        let redis_pool = self.redis_pool.clone();
-        Ok(PgConn {
-            postgres,
-            postgres_config,
-            redis_pool,
-        })
+  
+    fn get_postgres_pool(&self) -> Pool<PostgresConnectionManager<NoTls>> {
+        self.postgres_pool.clone()
+    }
+
+     async fn recreate(&self) -> PgConn
+        where
+            Self: Sized {
+        self.clone()
     }
 }
 /// Simplified type only accounting for the Postgres struct, since the enum adds some future flexibility, but also a lot of overhead.
 /// If all goes well, this PgConn type will have replaced DbConn entirely after a few iterations of improvement over the years.
 pub struct PgConn {
-    pub(crate) postgres: Client,
-    postgres_config: postgres::Config,
-    pub(crate) redis_pool: Pool<redis::Client>,
+    pub(crate) postgres_pool: Pool<PostgresConnectionManager<NoTls>>,
+    pub(crate) redis_pool: Pool<RedisConnectionManager>,
 }
 
-impl DbConn {
-    /// Converts/unwraps the generic DbConn type to it's more concrete PgConn counterpart.
-    pub(crate) fn to_pgconn(db: Self) -> PgConn {
-        match db {
-            Self::PgsqlConnection((a, b), c) => PgConn {
-                postgres: a,
-                postgres_config: b,
-                redis_pool: c,
-            },
+impl From<PgConn> for DbConn {
+    /// Converts/unwraps the more concrete PgConn type to the generic DbConn counterpart.
+    fn from(db: PgConn) -> Self {
+        Self::PgsqlConnection(db.postgres_pool, db.redis_pool)
+    }
+}
+
+impl Clone for PgConn {
+    fn clone(&self) -> Self {
+        PgConn {
+            postgres_pool: self.postgres_pool.clone(),
+            redis_pool: self.redis_pool.clone(),
         }
     }
 }
+
 
 // This function will be used to maintain the database, such as deleting old sessions
 // and managing timeline caches
-pub async fn maintain(db: DbConn) {
+pub async fn maintain(db: PgConn) {
+    let db = DbConn::from(db);
     match db {
-        DbConn::PgsqlConnection((client, _), redis_pool) => {
+        DbConn::PgsqlConnection(pg_pool, redis_pool) => {
             let mut session_interval = tokio::time::interval(std::time::Duration::from_secs(60));
             let mut cache_interval = tokio::time::interval(std::time::Duration::from_secs(300)); // 5 minutes
 
···
                 tokio::select! {
                     _ = session_interval.tick() => {
                         // Delete any sessions older than 20 days
-                        let _ = client
-                            .execute(
-                                "DELETE FROM sessions WHERE created_at < NOW() - INTERVAL '20 days'",
-                                &[],
-                            )
-                            .await;
+                        if let Ok(client) = pg_pool.get().await {
+                            let _ = client
+                                .execute(
+                                    "DELETE FROM sessions WHERE created_at < NOW() - INTERVAL '20 days'",
+                                    &[],
+                                )
+                                .await;
+                        }
                     }
                     _ = cache_interval.tick() => {
                         // Clean up expired timeline caches and manage cache invalidation
-                        if let Ok(mut redis_conn) = redis_pool.get() {
+                        if let Ok(mut redis_conn) = redis_pool.get().await {
                             let _ = cleanup_timeline_caches(&mut redis_conn).await;
-                            let _ = check_timeline_invalidations(&mut redis_conn, &client).await;
+                            if let Ok(pg_conn) = pg_pool.get().await {
+                                let _ = check_timeline_invalidations(&mut redis_conn, &pg_conn).await;
+                            }
                         }
                     }
                 }
···
 }
 
 // Clean up expired timeline cache entries
-async fn cleanup_timeline_caches(redis_conn: &mut redis::Connection) -> Result<(), LuminaError> {
+async fn cleanup_timeline_caches(redis_conn: &mut bb8::PooledConnection<'_, RedisConnectionManager>) -> Result<(), LuminaError> {
     let pattern = "timeline_cache:*";
     let mut cursor = 0;
 
···
             .cursor_arg(cursor)
             .arg("MATCH")
             .arg(pattern)
-            .query(redis_conn)
+            .query_async(&mut **redis_conn)
+            .await
             .map_err(LuminaError::Redis)?;
 
         cursor = result.0;
···
 
         for key in keys {
             // Check TTL, if -1 or 0, it should be cleaned up
-            let ttl: i64 = redis_conn.ttl(&key).map_err(LuminaError::Redis)?;
+            let ttl: i64 = redis::cmd("TTL")
+                .arg(&key)
+                .query_async(&mut **redis_conn)
+                .await
+                .map_err(LuminaError::Redis)?;
             if ttl == -1 || ttl == 0 {
                 expired_keys.push(key);
             }
         }
 
         if !expired_keys.is_empty() {
-            let _: () = redis_conn.del(&expired_keys).map_err(LuminaError::Redis)?;
+            let _: () = redis::cmd("DEL")
+                .arg(&expired_keys)
+                .query_async(&mut **redis_conn)
+                .await
+                .map_err(LuminaError::Redis)?;
         }
 
         if cursor == 0 {
···
 
 // Check for timeline changes and invalidate caches accordingly (PostgreSQL)
 async fn check_timeline_invalidations(
-    redis_conn: &mut redis::Connection,
-    client: &Client,
+    redis_conn: &mut bb8::PooledConnection<'_, RedisConnectionManager>,
+    client: &bb8::PooledConnection<'_, PostgresConnectionManager<NoTls>>,
 ) -> Result<(), LuminaError> {
     // Get the last check timestamp
-    let last_check: Option<String> = redis_conn.get("timeline_cache_last_check").unwrap_or(None);
+    let last_check: Option<String> = redis::cmd("GET")
+        .arg("timeline_cache_last_check")
+        .query_async(&mut **redis_conn)
+        .await
+        .unwrap_or(None);
 
     let query = if let Some(timestamp) = last_check {
         client
···
             .await
     } else {
         // First run, don't invalidate anything
-        let _: () = redis_conn
-            .set(
-                "timeline_cache_last_check",
-                time::OffsetDateTime::now_utc()
-                    .format(&time::format_description::well_known::Rfc3339)
-                    .unwrap(),
-            )
+        let _: () = redis::cmd("SET")
+            .arg("timeline_cache_last_check")
+            .arg(time::OffsetDateTime::now_utc()
+                .format(&time::format_description::well_known::Rfc3339)
+                .unwrap())
+            .query_async(&mut **redis_conn)
+            .await
             .map_err(LuminaError::Redis)?;
         return Ok(());
     };
···
             }
 
             // Update last check timestamp
-            let _: () = redis_conn
-                .set(
-                    "timeline_cache_last_check",
-                    time::OffsetDateTime::now_utc()
-                        .format(&time::format_description::well_known::Rfc3339)
-                        .unwrap(),
-                )
+            let _: () = redis::cmd("SET")
+                .arg("timeline_cache_last_check")
+                .arg(time::OffsetDateTime::now_utc()
+                    .format(&time::format_description::well_known::Rfc3339)
+                    .unwrap())
+                .query_async(&mut **redis_conn)
+                .await
                 .map_err(LuminaError::Redis)?;
         }
         Err(_) => {
             // If query fails, just update timestamp to avoid repeated failures
-            let _: () = redis_conn
-                .set(
-                    "timeline_cache_last_check",
-                    time::OffsetDateTime::now_utc()
-                        .format(&time::format_description::well_known::Rfc3339)
-                        .unwrap(),
-                )
+            let _: () = redis::cmd("SET")
+                .arg("timeline_cache_last_check")
+                .arg(time::OffsetDateTime::now_utc()
+                    .format(&time::format_description::well_known::Rfc3339)
+                    .unwrap())
+                .query_async(&mut **redis_conn)
+                .await
                 .map_err(LuminaError::Redis)?;
         }
     }

server/src/errors.rs

···
 #[derive(Debug)]
 pub(crate) enum LuminaError {
     ConfInvalid(String),
-    R2D2Pool(r2d2::Error),
+    Bb8Pool(String),
     Postgres(crate::postgres::Error),
     Unknown,
-    /// Rocket failure wrapper, due to size, we only store the error source here. Construct with:
-    /// ```rust
-    /// (LuminaError::RocketFaillure, Some<rocket::Error>)
-    /// ```
-    RocketFaillure,
+    RocketFaillure(Box<rocket::Error>),
     BcryptError,
     RegisterEmailInUse,
     RegisterUsernameInUse,
···
     SerializationError(String),
     JoinFaillure,
 }
+impl From<rocket::Error> for LuminaError {
+    fn from(err: rocket::Error) -> Self {
+        LuminaError::RocketFaillure(Box::new(err))
+    }
+}
+
+impl From<crate::postgres::Error> for LuminaError {
+    fn from(err: crate::postgres::Error) -> Self {
+        LuminaError::Postgres(err)
+    }
+}
+
+impl From<redis::RedisError> for LuminaError {
+    fn from(err: redis::RedisError) -> Self {
+        LuminaError::Redis(err)
+    }
+}

server/src/helpers/events.rs

···
  */
 
 use crate::LuminaError;
-use crate::database::{DatabaseConnections, PgConn};
+use crate::database::{PgConn};
 use cynthia_con::{CynthiaColors, CynthiaStyles};
 use time::OffsetDateTime;
 
···
     OnlyStdout,
 }
 
+impl From<&PgConn> for EventLogger {
+    fn from(db: &PgConn) -> Self {
+        EventLogger::WithDatabase(Box::new(db.clone()))
+    }
+}
+
+impl Clone for EventLogger {
+    fn clone(&self) -> Self {
+        match self {
+            EventLogger::WithDatabase(db) => EventLogger::WithDatabase(Box::new((**db).clone())),
+            EventLogger::OnlyStdout => EventLogger::OnlyStdout,
+        }
+    }
+}
+
 impl EventLogger {
     /// Creates a new logger instance.
     /// The `db` parameter can be `None` if the database isn't connected.
-    pub async fn new(db: &Option<PgConn>) -> Self {
+    pub fn new(db: &Option<PgConn>) -> Self {
         // For quick implementation we'll just check if not none and that's all.
         match db {
-            Some(d) => Self::from_db(d).await,
+            Some(d) => Self::from(d),
             None => Self::OnlyStdout,
-        }
-    }
-
-    pub async fn from_db(db_: &PgConn) -> Self {
-        match db_.recreate().await {
-            Ok(new_db) => Self::WithDatabase(Box::new(new_db)),
-            Err(error) => {
-                let n = Self::OnlyStdout;
-                n.error(
-                    format!("Could not connect the logger to the database! {:?}", error).as_str(),
-                )
-                .await;
-                n
-            }
-        }
-    }
-
-    pub async fn clone(&self) -> Self {
-        match self {
-            EventLogger::WithDatabase(db) => Self::from_db(db).await,
-            EventLogger::OnlyStdout => Self::OnlyStdout,
         }
     }
 
···
                     .format(&time::format_description::well_known::Rfc3339)
                     .unwrap();
 
-                let _ = db_conn
-                    .postgres
-                    .execute(
-                        "INSERT INTO logs (type, message, timestamp) VALUES ($1, $2, $3)",
-                        &[&level_str, &message_db, &ts],
-                    )
-                    .await;
+                if let Ok(pg_conn) = db_conn.postgres_pool.get().await {
+                    let _ = pg_conn
+                        .execute(
+                            "INSERT INTO logs (type, message, timestamp) VALUES ($1, $2, $3)",
+                            &[&level_str, &message_db, &ts],
+                        )
+                        .await;
+                }
             }
             EventLogger::OnlyStdout => {
                 // Log to stdout with the prefix.

server/src/main.rs

···
 pub mod errors;
 pub mod helpers;
 mod staticroutes;
+#[cfg(test)]
 mod tests;
 mod timeline;
 use helpers::events::EventLogger;
···
     port: u16,
     host: IpAddr,
 }
-use crate::database::DatabaseConnections;
+use crate::database::{DatabaseConnections, PgConn};
 use crate::errors::LuminaError;
 use cynthia_con::{CynthiaColors, CynthiaStyles};
 use dotenv::dotenv;
···
 #[rocket::main]
 async fn main() {
     let me = format!("Lumina Server, version {}", env!("CARGO_PKG_VERSION"));
-    let ev_log: EventLogger = EventLogger::new(&None).await;
+    let ev_log: EventLogger = EventLogger::new(&None);
     let args: Vec<String> = std::env::args().skip(1).collect();
     match (
         args.is_empty(),
···
                 Ok(config) => {
                     let mut interval =
                         tokio::time::interval(std::time::Duration::from_millis(3000));
-                    let mut db_mut: Option<DbConn> = None;
-                    let ev_log: EventLogger = EventLogger::new(&None).await;
+                    let mut db_mut: Option<PgConn> = None;
+                    let ev_log: EventLogger = EventLogger::new(&None);
 
                     let mut db_tries: usize = 0;
                     while db_mut.is_none() {
···
                                 error_elog!(ev_log, "While connecting to postgres database: {}", a);
                                 None
                             }
-                            Err(LuminaError::R2D2Pool(a)) => {
+                            Err(LuminaError::Bb8Pool(a)) => {
                                 error_elog!(ev_log, "While setting up database pool: {}", a);
                                 None
                             }
···
                     }
                     // If we got here, we have a database connection.
 
-                    let db = db_mut.unwrap();
-                    let pg = DbConn::to_pgconn(db.recreate().await.unwrap());
-                    let ev_log = EventLogger::from_db(&pg).await;
+                    let pg = db_mut.unwrap();
+                    let db: DbConn = pg.clone().into();
+                    let ev_log: EventLogger = EventLogger::new(&Some(pg));
                     success_elog!(ev_log, "Database connected.");
 
                     if cfg!(debug_assertions) {
-                        let mut redis_conn = db.get_redis_pool().get().unwrap();
+                        let redis_pool = db.get_redis_pool();
+                        let mut redis_conn = redis_pool.get().await.unwrap();
                         timeline::invalidate_timeline_cache(
                             &mut redis_conn,
                             "00000000-0000-0000-0000-000000000000",
···
                         .await
                         .unwrap();
                         let global = timeline::fetch_timeline_post_ids(
-                            ev_log.clone().await,
+                            ev_log.clone(),
                             &db,
                             "00000000-0000-0000-0000-000000000000",
                             None,
···
                             let generated_uuid = Uuid::new_v4();
                             let hello_content = "Hello world";
 
-                            match db.recreate().await.unwrap() {
-                                DbConn::PgsqlConnection((client, _), _) => {
+                            match db.recreate().await.into() {
+                                DbConn::PgsqlConnection(pg_pool, _) => {
+                                    let client = pg_pool.get().await.unwrap();
                                     // Insert Hello World post and timeline entry if not exists
                                     let user_1_: Result<user::User, LuminaError> =
                                         match user::User::create_user(
···
 													&[&generated_uuid, &user_1.id, &hello_content],
 												)
 												.await;
-                                            let add_clone = ev_log.clone().await;
+                                            let add_clone = ev_log.clone();
                                             timeline::add_to_timeline(
                                                 add_clone,
                                                 &db,
···
                     let appstate = AppState(Arc::from(InnerAppState {
                         config: config.clone(),
                         db: Mutex::from(db),
-                        event_logger: ev_log.clone().await,
+                        event_logger: ev_log.clone(),
                     }));
 
                     // Create a simple in-memory IP-based rate limiter.
···
                     let result = {
                         let g = s.await;
                         match g {
-                            Ok(x) => x.map_err(|e| (LuminaError::RocketFaillure, Some(e))),
-                            Err(..) => Err((LuminaError::JoinFaillure, None)),
+                            Ok(x) => x.map_err(|e| LuminaError::RocketFaillure(Box::new(e))),
+                            Err(..) => Err(LuminaError::JoinFaillure),
                         }
                     };
                     match result {
                         Ok(_) => {}
-                        Err((LuminaError::RocketFaillure, Some(e))) => {
+                        Err(LuminaError::RocketFaillure(e)) => {
                             // This handling should slowly expand as I run into newer ones, the 'defh' (default handling) is good enough, but for the most-bumped into errors, I'd like to give more human responses.
                             let defh =
                                 async || error_elog!(ev_log, "Error starting server: {:?}", e);

server/src/staticroutes.rs

···
 pub(crate) async fn index(state: &State<AppState>) -> RawHtml<String> {
     let ev_log = {
         let appstate = state.0.clone();
-        appstate.event_logger.clone().await
+        appstate.event_logger.clone()
     };
     http_code_elog!(ev_log, 200, "/");
     let js = if cfg!(debug_assertions) {
···
 pub(crate) async fn lumina_js(state: &State<AppState>) -> RawJavaScript<String> {
     let ev_log = {
         let appstate = state.0.clone();
-        appstate.event_logger.clone().await
+        appstate.event_logger.clone()
     };
     http_code_elog!(ev_log, 200, "/static/lumina.min.mjs");
 
···
 pub(crate) async fn lumina_d_js(state: &State<AppState>) -> RawJavaScript<String> {
     let ev_log = {
         let appstate = state.0.clone();
-        appstate.event_logger.clone().await
+        appstate.event_logger.clone()
     };
     http_code_elog!(ev_log, 200, "/static/lumina.mjs");
 
···
 pub(crate) async fn lumina_css(state: &State<AppState>) -> RawCss<String> {
     let ev_log = {
         let appstate = state.0.clone();
-        appstate.event_logger.clone().await
+        appstate.event_logger.clone()
     };
     http_code_elog!(ev_log, 200, "/static/lumina.css");
 
···
 pub(crate) async fn licence(state: &State<AppState>) -> RawText<String> {
     let ev_log = {
         let appstate = state.0.clone();
-        appstate.event_logger.clone().await
+        appstate.event_logger.clone()
     };
     http_code_elog!(ev_log, 200, "/licence");
 
···
 pub(crate) async fn logo_svg(state: &State<AppState>) -> (ContentType, &'static str) {
     let ev_log = {
         let appstate = state.0.clone();
-        appstate.event_logger.clone().await
+        appstate.event_logger.clone()
     };
     http_code_elog!(ev_log, 200, "/static/logo.svg");
 
···
 pub(crate) async fn favicon(state: &State<AppState>) -> (ContentType, &'static [u8]) {
     let ev_log = {
         let appstate = state.0.clone();
-        appstate.event_logger.clone().await
+        appstate.event_logger.clone()
     };
     http_code_elog!(ev_log, 200, "/favicon.ico");
     produce_logo_png()
···
 pub(crate) async fn logo_png(state: &State<AppState>) -> (ContentType, &'static [u8]) {
     let ev_log = {
         let appstate = state.0.clone();
-        appstate.event_logger.clone().await
+        appstate.event_logger.clone()
     };
     http_code_elog!(ev_log, 200, "/static/logo.png");
     produce_logo_png()

server/src/tests.rs

···
  *     along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-#[cfg(test)]
-mod tests {
-    use crate::database::{self, DatabaseConnections};
-    use crate::timeline;
+use crate::database::{self, DatabaseConnections};
+use crate::timeline;
 
-    #[tokio::test]
-    async fn test_database_setup() {
-        let result = database::setup().await;
-        assert!(result.is_ok(), "Database setup should succeed");
-    }
+#[tokio::test]
+async fn test_database_setup() {
+    let result = database::setup().await;
+    assert!(result.is_ok(), "Database setup should succeed");
+}
 
-    #[tokio::test]
-    async fn test_redis_bloom_filter() {
-        let db = database::setup().await.expect("DB setup");
-        let redis_pool = db.get_redis_pool();
-        let mut conn = redis_pool.get().await.expect("Redis conn");
-        let email_key = "test_bloom:email";
-        let test_email = "[e-mail]";
-        
-        // Add to bloom filter
-        let _: () = redis::cmd("BF.ADD")
-            .arg(email_key)
-            .arg(test_email)
-            .query_async(&mut *conn)
-            .await
-            .expect("BF.ADD");
-        
-        // Check if exists
-        let exists: bool = redis::cmd("BF.EXISTS")
-            .arg(email_key)
-            .arg(test_email)
-            .query_async(&mut *conn)
-            .await
-            .expect("BF.EXISTS");
-        
-        assert!(exists, "Bloom filter should contain the test email");
-        
-        // Clean up
-        let _: () = redis::cmd("DEL")
-            .arg(email_key)
-            .query_async(&mut *conn)
-            .await
-            .unwrap_or(());
-    }
+#[tokio::test]
+async fn test_redis_bloom_filter() {
+    let db = database::setup().await.expect("DB setup");
+    let redis_pool = db.get_redis_pool();
+    let mut conn = redis_pool.get().await.expect("Redis conn");
+    let email_key = "test_bloom:email";
+    let test_email = "[e-mail]";
 
-    #[tokio::test]
-    async fn test_timeline_invalidation() {
-        let db = database::setup().await.expect("DB setup");
-        let redis_pool = db.get_redis_pool();
-        let mut conn = redis_pool.get().await.expect("Redis conn");
-        let timeline_id = "test-timeline-invalidation";
-        
-        // Set a test cache key
-        let cache_key = format!("timeline_cache:{}:page:0", timeline_id);
-        let _: () = redis::cmd("SET")
-            .arg(&cache_key)
-            .arg("test_data")
-            .query_async(&mut *conn)
-            .await
-            .expect("SET");
-        
-        // Invalidate the timeline
-        timeline::invalidate_timeline_cache(&mut conn, timeline_id)
-            .await
-            .expect("Invalidate cache");
-        
-        // Verify cache was cleared
-        let result: Option<String> = redis::cmd("GET")
-            .arg(&cache_key)
-            .query_async(&mut *conn)
-            .await
-            .unwrap_or(None);
-        
-        assert!(result.is_none(), "Cache should be invalidated");
-    }
+    // Add to bloom filter
+    let _: () = redis::cmd("BF.ADD")
+        .arg(email_key)
+        .arg(test_email)
+        .query_async(&mut *conn)
+        .await
+        .expect("BF.ADD");
+
+    // Check if exists
+    let exists: bool = redis::cmd("BF.EXISTS")
+        .arg(email_key)
+        .arg(test_email)
+        .query_async(&mut *conn)
+        .await
+        .expect("BF.EXISTS");
+
+    assert!(exists, "Bloom filter should contain the test email");
+
+    // Clean up
+    let _: () = redis::cmd("DEL")
+        .arg(email_key)
+        .query_async(&mut *conn)
+        .await
+        .unwrap_or(());
 }
 
+#[tokio::test]
+async fn test_timeline_invalidation() {
+    let db = database::setup().await.expect("DB setup");
+    let redis_pool = db.get_redis_pool();
+    let mut conn = redis_pool.get().await.expect("Redis conn");
+    let timeline_id = "test-timeline-invalidation";
+
+    // Set a test cache key
+    let cache_key = format!("timeline_cache:{}:page:0", timeline_id);
+    let _: () = redis::cmd("SET")
+        .arg(&cache_key)
+        .arg("test_data")
+        .query_async(&mut *conn)
+        .await
+        .expect("SET");
+
+    // Invalidate the timeline
+    timeline::invalidate_timeline_cache(&mut conn, timeline_id)
+        .await
+        .expect("Invalidate cache");
+
+    // Verify cache was cleared
+    let result: Option<String> = redis::cmd("GET")
+        .arg(&cache_key)
+        .query_async(&mut *conn)
+        .await
+        .unwrap_or(None);
+
+    assert!(result.is_none(), "Cache should be invalidated");
+}

server/src/tests/tests.rs

···
+use crate::database::{self, DatabaseConnections};
+use crate::timeline;
+
+#[tokio::test]
+async fn test_database_setup() {
+    let result = database::setup().await;
+    assert!(result.is_ok(), "Database setup should succeed");
+}
+
+#[tokio::test]
+async fn test_redis_bloom_filter() {
+    let db = database::setup().await.expect("DB setup");
+    let redis_pool = db.get_redis_pool();
+    let mut conn = redis_pool.get().await.expect("Redis conn");
+    let email_key = "test_bloom:email";
+    let test_email = "[e-mail]";
+    
+    // Add to bloom filter
+    let _: () = redis::cmd("BF.ADD")
+        .arg(email_key)
+        .arg(test_email)
+        .query_async(&mut *conn)
+        .await
+        .expect("BF.ADD");
+    
+    // Check if exists
+    let exists: bool = redis::cmd("BF.EXISTS")
+        .arg(email_key)
+        .arg(test_email)
+        .query_async(&mut *conn)
+        .await
+        .expect("BF.EXISTS");
+    
+    assert!(exists, "Bloom filter should contain the test email");
+    
+    // Clean up
+    let _: () = redis::cmd("DEL")
+        .arg(email_key)
+        .query_async(&mut *conn)
+        .await
+        .unwrap_or(());
+}
+
+#[tokio::test]
+async fn test_timeline_invalidation() {
+    let db = database::setup().await.expect("DB setup");
+    let redis_pool = db.get_redis_pool();
+    let mut conn = redis_pool.get().await.expect("Redis conn");
+    let timeline_id = "test-timeline-invalidation";
+    
+    // Set a test cache key
+    let cache_key = format!("timeline_cache:{}:page:0", timeline_id);
+    let _: () = redis::cmd("SET")
+        .arg(&cache_key)
+        .arg("test_data")
+        .query_async(&mut *conn)
+        .await
+        .expect("SET");
+    
+    // Invalidate the timeline
+    timeline::invalidate_timeline_cache(&mut conn, timeline_id)
+        .await
+        .expect("Invalidate cache");
+    
+    // Verify cache was cleared
+    let result: Option<String> = redis::cmd("GET")
+        .arg(&cache_key)
+        .query_async(&mut *conn)
+        .await
+        .unwrap_or(None);
+    
+    assert!(result.is_none(), "Cache should be invalidated");
+}

server/src/timeline.rs

···
 use crate::errors::LuminaError;
 use crate::helpers::events::EventLogger;
 use crate::{DbConn, error_elog, info_elog, user};
-use redis::Commands;
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
···
 
 /// Check if a timeline should be cached based on traffic
 async fn is_high_traffic_timeline(
-    redis_conn: &mut redis::Connection,
+    redis_conn: &mut bb8::PooledConnection<'_, bb8_redis::RedisConnectionManager>,
     timeline_id: &str,
 ) -> Result<bool, LuminaError> {
     // Global timeline is always high traffic
···
     }
 
     // Check lookup count for other timelines
-    let lookup_count: i64 = redis_conn
-        .get(format!("timeline_lookup:{}", timeline_id))
+    let lookup_count: i64 = redis::cmd("GET")
+        .arg(format!("timeline_lookup:{}", timeline_id))
+        .query_async(&mut **redis_conn)
+        .await
         .unwrap_or(0);
 
     Ok(lookup_count >= HIGH_TRAFFIC_THRESHOLD)
···
 
 /// Store timeline page in Redis cache
 async fn cache_timeline_page(
-    redis_conn: &mut redis::Connection,
+    redis_conn: &mut bb8::PooledConnection<'_, bb8_redis::RedisConnectionManager>,
     timeline_id: &str,
     page: usize,
     post_ids: &[String],
···
         .arg(cache_key)
         .arg(CACHE_TTL)
         .arg(serialized)
-        .query(redis_conn)
+        .query_async(&mut **redis_conn)
+        .await
         .map_err(LuminaError::Redis)?;
 
     // Also cache metadata
···
         .arg(meta_key)
         .arg(CACHE_TTL)
         .arg(total_count)
-        .query(redis_conn)
+        .query_async(&mut **redis_conn)
+        .await
         .map_err(LuminaError::Redis)?;
 
     Ok(())
···
 
 /// Retrieve timeline page from Redis cache
 async fn get_cached_timeline_page(
-    redis_conn: &mut redis::Connection,
+    redis_conn: &mut bb8::PooledConnection<'_, bb8_redis::RedisConnectionManager>,
     timeline_id: &str,
     page: usize,
 ) -> Result<Option<CachedTimelinePage>, LuminaError> {
     let cache_key = get_cache_key(timeline_id, page);
 
-    let cached_data: Option<String> = redis_conn.get(cache_key).map_err(LuminaError::Redis)?;
+    let cached_data: Option<String> = redis::cmd("GET")
+        .arg(cache_key)
+        .query_async(&mut **redis_conn)
+        .await
+        .map_err(LuminaError::Redis)?;
 
     match cached_data {
         Some(data) => {
···
 
 /// Invalidate all cache entries for a timeline
 pub async fn invalidate_timeline_cache(
-    redis_conn: &mut redis::Connection,
+    redis_conn: &mut bb8::PooledConnection<'_, bb8_redis::RedisConnectionManager>,
     timeline_id: &str,
 ) -> Result<(), LuminaError> {
     // Use SCAN to find all cache keys for this timeline
···
             .cursor_arg(cursor)
             .arg("MATCH")
             .arg(&pattern)
-            .query(redis_conn)
+            .query_async(&mut **redis_conn)
+            .await
             .map_err(LuminaError::Redis)?;
 
         cursor = result.0;
         let keys = result.1;
 
         if !keys.is_empty() {
-            let _: () = redis_conn.del(&keys).map_err(LuminaError::Redis)?;
+            let _: () = redis::cmd("DEL")
+                .arg(&keys)
+                .query_async(&mut **redis_conn)
+                .await
+                .map_err(LuminaError::Redis)?;
         }
 
         if cursor == 0 {
···
 /// Fetch total count for a timeline from database
 async fn fetch_timeline_total_count(db: &DbConn, timeline_id: &str) -> Result<usize, LuminaError> {
     match db {
-        DbConn::PgsqlConnection((client, _pg_config), _redis_pool) => {
+        DbConn::PgsqlConnection(pg_pool, _redis_pool) => {
+            let client = pg_pool.get().await.map_err(|e| LuminaError::Bb8Pool(e.to_string()))?;
             let timeline_uuid = Uuid::parse_str(timeline_id).map_err(|_| LuminaError::UUidError)?;
             let row = client
                 .query_one(
···
     limit: usize,
 ) -> Result<Vec<String>, LuminaError> {
     match db {
-        DbConn::PgsqlConnection((client, _pg_config), _redis_pool) => {
+        DbConn::PgsqlConnection(pg_pool, _redis_pool) => {
+            let client = pg_pool.get().await.map_err(|e| LuminaError::Bb8Pool(e.to_string()))?;
             let timeline_uuid = Uuid::parse_str(timeline_id).map_err(|_| LuminaError::UUidError)?;
             let rows = client
 				.query(
···
     // Get Redis connection
     let mut redis_conn = match db {
         DbConn::PgsqlConnection(_, redis_pool) => {
-            redis_pool.get().map_err(LuminaError::R2D2Pool)?
+            redis_pool.get().await.map_err(|e| LuminaError::Bb8Pool(e.to_string()))?
         }
     };
 
     // Log the requested timeline id for tracking
-    let _: () = redis_conn
-        .incr(format!("timeline_lookup:{}", timeline_id), 1)
+    let _: () = redis::cmd("INCR")
+        .arg(format!("timeline_lookup:{}", timeline_id))
+        .query_async(&mut *redis_conn)
+        .await
         .map_err(LuminaError::Redis)?;
 
     // Check if this timeline should be cached
···
 ) -> Result<(), LuminaError> {
     // Add to database
     match db {
-        DbConn::PgsqlConnection((client, _pg_config), redis_pool) => {
+        DbConn::PgsqlConnection(pg_pool, redis_pool) => {
+            let client = pg_pool.get().await.map_err(|e| LuminaError::Bb8Pool(e.to_string()))?;
             let timeline_uuid = Uuid::parse_str(timeline_id).map_err(|_| LuminaError::UUidError)?;
             let item_uuid = Uuid::parse_str(item_id).map_err(|_| LuminaError::UUidError)?;
             client
···
                 .map_err(LuminaError::Postgres)?;
 
             // Invalidate cache
-            let mut redis_conn = redis_pool.get().map_err(LuminaError::R2D2Pool)?;
+            let mut redis_conn = redis_pool.get().await.map_err(|e| LuminaError::Bb8Pool(e.to_string()))?;
             if let Err(e) = invalidate_timeline_cache(&mut redis_conn, timeline_id).await {
                 error_elog!(
                     event_logger,
···
 ) -> Result<(), LuminaError> {
     // Remove from database
     match db {
-        DbConn::PgsqlConnection((client, _pg_config), redis_pool) => {
+        DbConn::PgsqlConnection(pg_pool, redis_pool) => {
+            let client = pg_pool.get().await.map_err(|e| LuminaError::Bb8Pool(e.to_string()))?;
             let timeline_uuid = Uuid::parse_str(timeline_id).map_err(|_| LuminaError::UUidError)?;
             let item_uuid = Uuid::parse_str(item_id).map_err(|_| LuminaError::UUidError)?;
             client
···
                 .map_err(LuminaError::Postgres)?;
 
             // Invalidate cache
-            let mut redis_conn = redis_pool.get().map_err(LuminaError::R2D2Pool)?;
+            let mut redis_conn = redis_pool.get().await.map_err(|e| LuminaError::Bb8Pool(e.to_string()))?;
             if let Err(e) = invalidate_timeline_cache(&mut redis_conn, timeline_id).await {
                 error_elog!(
                     event_logger,

server/src/user.rs

···
     }
     async fn get_hashed_password(self, database: &DbConn) -> Result<String, LuminaError> {
         match database {
-            DbConn::PgsqlConnection((client, _), _) => {
+            DbConn::PgsqlConnection(pg_pool, _) => {
+                let client = pg_pool.get().await.map_err(|e| LuminaError::Bb8Pool(e.to_string()))?;
                 let row = client
                     .query_one("SELECT password FROM users WHERE id = $1", &[&self.id])
                     .await
···
         let password =
             bcrypt::hash(password, bcrypt::DEFAULT_COST).map_err(|_| LuminaError::BcryptError)?;
         match db {
-            DbConn::PgsqlConnection((client, _), _) => {
+            DbConn::PgsqlConnection(pg_pool, _) => {
+                let client = pg_pool.get().await.map_err(|e| LuminaError::Bb8Pool(e.to_string()))?;
                 // Some username and email validation should be done here
                 // Check if the email is already in use
                 let email_exists = client
···
             "username"
         };
         match db {
-            DbConn::PgsqlConnection((client, _), _) => {
+            DbConn::PgsqlConnection(pg_pool, _) => {
+                let client = pg_pool.get().await.map_err(|e| LuminaError::Bb8Pool(e.to_string()))?;
                 let user = client
 					.query_one(
 						&format!("SELECT id, email, username, COALESCE(foreign_instance_id, '') FROM users WHERE {} = $1", identifyer_type),
···
         let user = self;
         let user_id = user.id;
         match db {
-            DbConn::PgsqlConnection((client, _), _) => {
+            DbConn::PgsqlConnection(pg_pool, _) => {
+                let client = pg_pool.get().await.map_err(|e| LuminaError::Bb8Pool(e.to_string()))?;
                 let session_key = Uuid::new_v4().to_string();
                 let id = client
                     .query_one(
···
         db: &DbConn,
     ) -> Result<User, LuminaError> {
         match db {
-            DbConn::PgsqlConnection((client, _), _) => {
+            DbConn::PgsqlConnection(pg_pool, _) => {
+                let client = pg_pool.get().await.map_err(|e| LuminaError::Bb8Pool(e.to_string()))?;
                 let user = client
 					.query_one("SELECT users.id, users.email, users.username FROM users JOIN sessions ON users.id = sessions.user_id WHERE sessions.session_key = $1", &[&token])
 					.await
···
     {
         // Check if the email or username is already in use using fastbloom algorithm with Redis, and fallback to DB check if not found. If not in either, we can go on.
         match db {
-            DbConn::PgsqlConnection((client, _), redis_pool) => {
-                let mut redis_conn = redis_pool.get().map_err(LuminaError::R2D2Pool)?;
+            DbConn::PgsqlConnection(pg_pool, redis_pool) => {
+                let client = pg_pool.get().await.map_err(|e| LuminaError::Bb8Pool(e.to_string()))?;
+                let mut redis_conn = redis_pool.get().await.map_err(|e| LuminaError::Bb8Pool(e.to_string()))?;
                 // fastbloom_rs expects bytes, so we use the string as bytes
                 let email_key = String::from("bloom:email");
                 let username_key = String::from("bloom:username");
                 let email_exists: bool = redis::cmd("BF.EXISTS")
                     .arg(&email_key)
                     .arg(&email)
-                    .query(&mut *redis_conn)
+                    .query_async(&mut *redis_conn)
+                    .await
                     .unwrap_or(false);
                 if email_exists {
                     // Fallback to DB check if in bloom filter
···
                 let username_exists: bool = redis::cmd("BF.EXISTS")
                     .arg(&username_key)
                     .arg(&username)
-                    .query(&mut *redis_conn)
+                    .query_async(&mut *redis_conn)
+                    .await
                     .unwrap_or(false);
                 if username_exists {
                     // Fallback to DB check if in bloom filter
···
                     let _: () = redis::cmd("BF.ADD")
                         .arg(&email_key)
                         .arg(&email)
-                        .query(&mut *redis_conn)
+                        .query_async(&mut *redis_conn)
+                        .await
                         .unwrap_or(());
                     return Err(LuminaError::RegisterEmailInUse);
                 }
···
                     let _: () = redis::cmd("BF.ADD")
                         .arg(&username_key)
                         .arg(&username)
-                        .query(&mut *redis_conn)
+                        .query_async(&mut *redis_conn)
+                        .await
                         .unwrap_or(());
                     return Err(LuminaError::RegisterUsernameInUse);
                 }