db: Convert DieselPool enum to simpler struct

Author: Turbo87

src/db.rs

@@ -13,14 +13,9 @@ pub mod sql_types;
 pub type ConnectionPool = r2d2::Pool<ConnectionManager<PgConnection>>;
 
 #[derive(Clone)]
-pub enum DieselPool {
-    Pool {
-        pool: ConnectionPool,
-        time_to_obtain_connection_metric: Histogram,
-    },
-    BackgroundJobPool {
-        pool: ConnectionPool,
-    },
+pub struct DieselPool {
+    pool: ConnectionPool,
+    time_to_obtain_connection_metric: Option<Histogram>,
 }
 
 impl DieselPool {
@@ -43,9 +38,9 @@ impl DieselPool {
         // serving errors for the first connections until the pool is initialized) and if we can't
         // establish any connection continue booting up the application. The database pool will
         // automatically be marked as unhealthy and the rest of the application will adapt.
-        let pool = DieselPool::Pool {
+        let pool = DieselPool {
             pool: r2d2_config.build_unchecked(manager),
-            time_to_obtain_connection_metric,
+            time_to_obtain_connection_metric: Some(time_to_obtain_connection_metric),
         };
         match pool.wait_until_healthy(Duration::from_secs(5)) {
             Ok(()) => {}
@@ -57,50 +52,43 @@ impl DieselPool {
     }
 
     pub fn new_background_worker(pool: r2d2::Pool<ConnectionManager<PgConnection>>) -> Self {
-        Self::BackgroundJobPool { pool }
+        Self {
+            pool,
+            time_to_obtain_connection_metric: None,
+        }
     }
 
     #[instrument(name = "db.connect", skip_all)]
     pub fn get(&self) -> Result<DieselPooledConn, PoolError> {
-        match self {
-            DieselPool::Pool {
-                pool,
-                time_to_obtain_connection_metric,
-            } => time_to_obtain_connection_metric.observe_closure_duration(|| {
-                if let Some(conn) = pool.try_get() {
-                    Ok(conn)
-                } else if !self.is_healthy() {
-                    Err(PoolError::UnhealthyPool)
-                } else {
-                    Ok(pool.get()?)
-                }
-            }),
-            DieselPool::BackgroundJobPool { pool } => Ok(pool.get()?),
+        match self.time_to_obtain_connection_metric.as_ref() {
+            Some(time_to_obtain_connection_metric) => time_to_obtain_connection_metric
+                .observe_closure_duration(|| {
+                    if let Some(conn) = self.pool.try_get() {
+                        Ok(conn)
+                    } else if !self.is_healthy() {
+                        Err(PoolError::UnhealthyPool)
+                    } else {
+                        Ok(self.pool.get()?)
+                    }
+                }),
+            None => Ok(self.pool.get()?),
         }
     }
 
     pub fn state(&self) -> PoolState {
-        match self {
-            DieselPool::Pool { pool, .. } | DieselPool::BackgroundJobPool { pool } => {
-                let state = pool.state();
-                PoolState {
-                    connections: state.connections,
-                    idle_connections: state.idle_connections,
-                }
-            }
+        let state = self.pool.state();
+        PoolState {
+            connections: state.connections,
+            idle_connections: state.idle_connections,
         }
     }
 
     #[instrument(skip_all)]
     pub fn wait_until_healthy(&self, timeout: Duration) -> Result<(), PoolError> {
-        match self {
-            DieselPool::Pool { pool, .. } | DieselPool::BackgroundJobPool { pool } => {
-                match pool.get_timeout(timeout) {
-                    Ok(_) => Ok(()),
-                    Err(_) if !self.is_healthy() => Err(PoolError::UnhealthyPool),
-                    Err(err) => Err(PoolError::R2D2(err)),
-                }
-            }
+        match self.pool.get_timeout(timeout) {
+            Ok(_) => Ok(()),
+            Err(_) if !self.is_healthy() => Err(PoolError::UnhealthyPool),
+            Err(err) => Err(PoolError::R2D2(err)),
         }
     }