add async connection pool (#58)

Cargo.lock

···
 
 [[package]]
 name = "async-trait"
-version = "0.1.60"
+version = "0.1.61"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "677d1d8ab452a3936018a687b20e6f7cf5363d713b732b8884001317b0e48aa3"
+checksum = "705339e0e4a9690e2908d2b3d049d85682cf19fbd5782494498fbf7003a6a282"
 dependencies = [
  "proc-macro2",
  "quote",
···
 
 [[package]]
 name = "clap"
-version = "4.0.32"
+version = "4.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7db700bc935f9e43e88d00b0850dae18a63773cfbec6d8e070fccf7fef89a39"
+checksum = "4ec7a4128863c188deefe750ac1d1dfe66c236909f845af04beed823638dc1b2"
 dependencies = [
  "bitflags",
  "clap_lex",
···
 
 [[package]]
 name = "clap_lex"
-version = "0.3.0"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d4198f73e42b4936b35b5bb248d81d2b595ecb170da0bac7655c54eedfa8da8"
+checksum = "783fe232adfca04f90f56201b26d79682d4cd2625e0bc7290b95123afe558ade"
 dependencies = [
  "os_str_bytes",
 ]
···
 version = "0.2.0"
 dependencies = [
  "binascii",
+ "deadpool-postgres",
  "futures-util",
  "log",
  "native-tls",
  "postgres-native-tls",
  "serde",
  "tokio",
- "tokio-postgres",
  "toml",
  "warp",
 ]
···
 dependencies = [
  "generic-array",
  "typenum",
+]
+
+[[package]]
+name = "deadpool"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "421fe0f90f2ab22016f32a9881be5134fdd71c65298917084b0c7477cbc3856e"
+dependencies = [
+ "async-trait",
+ "deadpool-runtime",
+ "num_cpus",
+ "retain_mut",
+ "tokio",
+]
+
+[[package]]
+name = "deadpool-postgres"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "051c50d234dab03bd29a537859bb7f50cca718c90b05e5c5746b9ae2a73f7278"
+dependencies = [
+ "deadpool",
+ "log",
+ "tokio",
+ "tokio-postgres",
+]
+
+[[package]]
+name = "deadpool-runtime"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eaa37046cc0f6c3cc6090fbdbf73ef0b8ef4cfcc37f6befc0020f63e8cf121e1"
+dependencies = [
+ "tokio",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "io-lifetimes"
-version = "1.0.3"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46112a93252b123d31a119a8d1a1ac19deac4fac6e0e8b0df58f0d4e5870e63c"
+checksum = "e7d6c6f8c91b4b9ed43484ad1a938e393caf35960fce7f82a040497207bd8e9e"
 dependencies = [
  "libc",
- "windows-sys 0.42.0",
+ "windows-sys",
 ]
 
 [[package]]
···
  "hermit-abi 0.2.6",
  "io-lifetimes",
  "rustix",
- "windows-sys 0.42.0",
+ "windows-sys",
 ]
 
 [[package]]
···
  "libc",
  "log",
  "wasi",
- "windows-sys 0.42.0",
+ "windows-sys",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "once_cell"
-version = "1.16.0"
+version = "1.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86f0b0d4bf799edbc74508c1e8bf170ff5f41238e5f8225603ca7caaae2b7860"
+checksum = "6f61fba1741ea2b3d6a1e3178721804bb716a68a6aeba1149b5d52e3d464ea66"
 
 [[package]]
 name = "openssl"
···
 
 [[package]]
 name = "parking_lot_core"
-version = "0.9.5"
+version = "0.9.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ff9f3fef3968a3ec5945535ed654cb38ff72d7495a25619e2247fb15a2ed9ba"
+checksum = "ba1ef8814b5c993410bb3adfad7a5ed269563e4a2f90c41f5d85be7fb47133bf"
 dependencies = [
  "cfg-if",
  "libc",
  "redox_syscall",
  "smallvec",
- "windows-sys 0.42.0",
+ "windows-sys",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.49"
+version = "1.0.50"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57a8eca9f9c4ffde41714334dee777596264c7825420f521abc92b5b5deb63a5"
+checksum = "6ef7d57beacfaf2d8aee5937dab7b7f28de3cb8b1828479bb5de2a7106f2bae2"
 dependencies = [
  "unicode-ident",
 ]
···
 
 [[package]]
 name = "regex"
-version = "1.7.0"
+version = "1.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e076559ef8e241f2ae3479e36f97bd5741c0330689e217ad51ce2c76808b868a"
+checksum = "48aaa5748ba571fb95cd2c85c09f629215d3a6ece942baa100950af03a34f733"
 dependencies = [
  "aho-corasick",
  "memchr",
···
 ]
 
 [[package]]
+name = "retain_mut"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4389f1d5789befaf6029ebd9f7dac4af7f7e3d61b69d4f30e2ac02b57e7712b0"
+
+[[package]]
 name = "rustix"
-version = "0.36.6"
+version = "0.36.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4feacf7db682c6c329c4ede12649cd36ecab0f3be5b7d74e6a20304725db4549"
+checksum = "d4fdebc4b395b7fbb9ab11e462e20ed9051e7b16e42d24042c776eca0ac81b03"
 dependencies = [
  "bitflags",
  "errno",
  "io-lifetimes",
  "libc",
  "linux-raw-sys",
- "windows-sys 0.42.0",
+ "windows-sys",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "schannel"
-version = "0.1.20"
+version = "0.1.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88d6731146462ea25d9244b2ed5fd1d716d25c52e4d54aa4fb0f3c4e9854dbe2"
+checksum = "713cfb06c7059f3588fb8044c0fad1d09e3c01d225e25b9220dbfdcf16dbb1b3"
 dependencies = [
- "lazy_static",
- "windows-sys 0.36.1",
+ "windows-sys",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "termcolor"
-version = "1.1.3"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bab24d30b911b2376f3a13cc2cd443142f0c81dda04c118693e35b3835757755"
+checksum = "be55cf8942feac5c765c2c993422806843c9a9a45d4d5c407ad6dd2ea95eb9b6"
 dependencies = [
  "winapi-util",
 ]
···
 
 [[package]]
 name = "tokio"
-version = "1.23.1"
+version = "1.24.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38a54aca0c15d014013256222ba0ebed095673f89345dd79119d912eb561b7a8"
+checksum = "597a12a59981d9e3c38d216785b0c37399f6e415e8d0712047620f189371b0bb"
 dependencies = [
  "autocfg",
  "bytes",
···
  "signal-hook-registry",
  "socket2",
  "tokio-macros",
- "windows-sys 0.42.0",
+ "windows-sys",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "try-lock"
-version = "0.2.3"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59547bce71d9c38b83d9c0e92b6066c4253371f15005def0c30d9657f50c7642"
+checksum = "3528ecfd12c466c6f163363caf2d02a71161dd5e1cc6ae7b34207ea2d42d81ed"
 
 [[package]]
 name = "tungstenite"
···
 
 [[package]]
 name = "windows-sys"
-version = "0.36.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ea04155a16a59f9eab786fe12a4a450e75cdb175f9e0d80da1e17db09f55b8d2"
-dependencies = [
- "windows_aarch64_msvc 0.36.1",
- "windows_i686_gnu 0.36.1",
- "windows_i686_msvc 0.36.1",
- "windows_x86_64_gnu 0.36.1",
- "windows_x86_64_msvc 0.36.1",
-]
-
-[[package]]
-name = "windows-sys"
 version = "0.42.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5a3e1820f08b8513f676f7ab6c1f99ff312fb97b553d30ff4dd86f9f15728aa7"
 dependencies = [
  "windows_aarch64_gnullvm",
- "windows_aarch64_msvc 0.42.0",
- "windows_i686_gnu 0.42.0",
- "windows_i686_msvc 0.42.0",
- "windows_x86_64_gnu 0.42.0",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
  "windows_x86_64_gnullvm",
- "windows_x86_64_msvc 0.42.0",
+ "windows_x86_64_msvc",
 ]
 
 [[package]]
 name = "windows_aarch64_gnullvm"
-version = "0.42.0"
+version = "0.42.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41d2aa71f6f0cbe00ae5167d90ef3cfe66527d6f613ca78ac8024c3ccab9a19e"
+checksum = "8c9864e83243fdec7fc9c5444389dcbbfd258f745e7853198f365e3c4968a608"
 
 [[package]]
 name = "windows_aarch64_msvc"
-version = "0.36.1"
+version = "0.42.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9bb8c3fd39ade2d67e9874ac4f3db21f0d710bee00fe7cab16949ec184eeaa47"
-
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.42.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd0f252f5a35cac83d6311b2e795981f5ee6e67eb1f9a7f64eb4500fbc4dcdb4"
+checksum = "4c8b1b673ffc16c47a9ff48570a9d85e25d265735c503681332589af6253c6c7"
 
 [[package]]
 name = "windows_i686_gnu"
-version = "0.36.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "180e6ccf01daf4c426b846dfc66db1fc518f074baa793aa7d9b9aaeffad6a3b6"
-
-[[package]]
-name = "windows_i686_gnu"
-version = "0.42.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fbeae19f6716841636c28d695375df17562ca208b2b7d0dc47635a50ae6c5de7"
-
-[[package]]
-name = "windows_i686_msvc"
-version = "0.36.1"
+version = "0.42.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2e7917148b2812d1eeafaeb22a97e4813dfa60a3f8f78ebe204bcc88f12f024"
+checksum = "de3887528ad530ba7bdbb1faa8275ec7a1155a45ffa57c37993960277145d640"
 
 [[package]]
 name = "windows_i686_msvc"
-version = "0.42.0"
+version = "0.42.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "84c12f65daa39dd2babe6e442988fc329d6243fdce47d7d2d155b8d874862246"
+checksum = "bf4d1122317eddd6ff351aa852118a2418ad4214e6613a50e0191f7004372605"
 
 [[package]]
 name = "windows_x86_64_gnu"
-version = "0.36.1"
+version = "0.42.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4dcd171b8776c41b97521e5da127a2d86ad280114807d0b2ab1e462bc764d9e1"
-
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.42.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf7b1b21b5362cbc318f686150e5bcea75ecedc74dd157d874d754a2ca44b0ed"
+checksum = "c1040f221285e17ebccbc2591ffdc2d44ee1f9186324dd3e84e99ac68d699c45"
 
 [[package]]
 name = "windows_x86_64_gnullvm"
-version = "0.42.0"
+version = "0.42.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09d525d2ba30eeb3297665bd434a54297e4170c7f1a44cad4ef58095b4cd2028"
+checksum = "628bfdf232daa22b0d64fdb62b09fcc36bb01f05a3939e20ab73aaf9470d0463"
 
 [[package]]
 name = "windows_x86_64_msvc"
-version = "0.36.1"
+version = "0.42.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c811ca4a8c853ef420abd8592ba53ddbbac90410fab6903b3e79972a631f7680"
-
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.42.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f40009d85759725a34da6d89a94e63d7bdc50a862acf0dbc7c8e488f1edcb6f5"
+checksum = "447660ad36a13288b1db4d4248e857b510e8c3a225c822ba4fb748c0aafecffd"

common/Cargo.toml

···
 tokio = {version = "1.23", features = ["full"], optional = true}
 log = {version = "0.4", features = ["release_max_level_debug"]}
 serde = {version = "1.0", features = ["derive"]}
-tokio-postgres = {version = "0.7", optional = true}
 postgres-native-tls = {version = "0.5", optional = true}
 native-tls = {version = "0.2", optional = true}
 futures-util = "0.3"
 toml = "0.5"
 warp = {version = "0.3", optional = true}
 binascii = "0.1"
+deadpool-postgres = {version = "0.10", optional = true}
 
 [features]
 default = ["web", "db"]
 web = ["warp"]
-db = ["tokio", "tokio-postgres", "postgres-native-tls", "native-tls"]
+db = ["tokio", "postgres-native-tls", "native-tls", "deadpool-postgres"]

common/src/db/mod.rs

···
 use log::*;
-use tokio_postgres::{Client, NoTls};
+use postgres_native_tls::MakeTlsConnector;
+use deadpool_postgres::{tokio_postgres::NoTls, Manager, Pool};
 use serde::Serialize;
-use std::{collections::HashMap, sync::Arc};
-use tokio::sync::RwLock;
+use std::{collections::HashMap, sync::Arc, str::FromStr};
 use crate::config::Config;
 
 pub type DynConfig = dyn crate::config::HasConfig + Send + Sync;
 
 pub struct Database {
-    config: Arc<DynConfig>,
-    conn: RwLock<Client>,
-    cache: RwLock<HashMap<String, tokio_postgres::Statement>>,
+    pool: deadpool_postgres::Pool,
 }
 
 pub struct FunctionInfo {
···
 }
 
 impl Database {
-    pub async fn open(config: Arc<DynConfig>) -> Result<Self, tokio_postgres::Error> {
-        let client = Self::connect(config.get_config()).await?;
+    pub async fn open(config: Arc<DynConfig>) -> Result<Self, deadpool_postgres::tokio_postgres::Error> {
+        let connection_string = config.get_config().database.connection_info.as_str();
+        let pg_config = deadpool_postgres::tokio_postgres::Config::from_str(connection_string)?;
+
+        let mgr_config = deadpool_postgres::ManagerConfig {
+            recycling_method: deadpool_postgres::RecyclingMethod::Verified
+        };
+
+        let manager = if config.get_config().database.use_tls { 
+            let tls = Self::make_tls(config.get_config()).await;
+            Manager::from_config(pg_config, tls, mgr_config)
+        } else {
+            Manager::from_config(pg_config, NoTls, mgr_config)
+        };
+
+        let pool = Pool::builder(manager)
+            .build()
+            .expect("failed to build pool");
 
         Ok(Database{
-            config,
-            conn: RwLock::new(client),
-            cache: RwLock::new(HashMap::new()),
+            pool,
         })
     }
 
-    pub async fn get_conn(&self) -> tokio::sync::RwLockReadGuard<'_, Client> {
-        self.conn.read().await
-    }
-
-    async fn connect_tls(conn_info: &Config) -> Result<tokio_postgres::Client, tokio_postgres::Error> {
-        use postgres_native_tls::MakeTlsConnector;
+    async fn make_tls(conn_info: &Config) -> MakeTlsConnector {
         use native_tls::{TlsConnector, Certificate, Identity};
 
         let mut tls_connector = TlsConnector::builder();
···
             .build()
             .expect("failed to build TlsConnector");
 
-        let connector = MakeTlsConnector::new(tls_connector);
-
-        let (client, conn) = tokio_postgres::connect(&conn_info.database.connection_info, connector).await?;
-        info!("database connected (tls).");
-        
-        tokio::spawn(async {
-            if let Err(e) = conn.await {
-                error!("db connection error: {}", e);
-            }
-        });
-
-        Ok(client)
-    }
-
-    async fn connect_plain(conn_info: &str) -> Result<tokio_postgres::Client, tokio_postgres::Error> {
-        let (client, conn) = tokio_postgres::connect(conn_info, NoTls).await?;
-        info!("database connected.");
-
-        tokio::spawn(async {
-            if let Err(e) = conn.await {
-                error!("db connection error: {}", e);
-            }
-        });
-
-        Ok(client)
-    }
-
-    async fn connect(conn_info: &Config) -> Result<tokio_postgres::Client, tokio_postgres::Error> {
-        if conn_info.database.use_tls {
-            info!("connecting with TLS...");
-            Self::connect_tls(conn_info).await
-        }
-        else {
-            info!("connecting plain...");
-            Self::connect_plain(&conn_info.database.connection_info).await
-        }
-    }
-
-    async fn prepare_cached<'a, 'b>(&'a self, sql: &'b str) -> Result<tokio_postgres::Statement, tokio_postgres::Error> {
-        {
-            let rd = self.cache.read().await;
-            if let Some(v) = rd.get(sql) {
-                return Ok(v.clone());
-            }
-        }
-        {
-            let stmt = self.conn.read().await.prepare(sql).await?;
-            let mut wr = self.cache.write().await;
-            wr.insert(sql.to_string(), stmt);
-
-            let v = wr.get(sql).expect("failed to get recently added value");
-            Ok(v.clone())
-        }
+        MakeTlsConnector::new(tls_connector)
     }
 
-    pub async fn get_funcs(&self, funcs: &[crate::rpc::PullMetadataFunc<'_>]) -> Result<Vec<Option<FunctionInfo>>, tokio_postgres::Error> {
-        let stmt = self.prepare_cached(r#"
+    pub async fn get_funcs(&self, funcs: &[crate::rpc::PullMetadataFunc<'_>]) -> Result<Vec<Option<FunctionInfo>>, deadpool_postgres::PoolError> {
+        let conn = self.pool.get().await?;
+        let stmt = conn
+            .prepare_cached(r#"
         WITH best AS (
             select chksum,MAX(rank) as maxrank from funcs f1
             WHERE chksum = ANY($1)
···
         SELECT f2.name,f2.len,f2.metadata,f2.chksum FROM best
         LEFT JOIN funcs f2 ON (best.chksum=f2.chksum AND best.maxrank=f2.rank)
         "#).await?;
-
-        let conn = self.conn.read().await;
 
         let chksums: Vec<&[u8]> = funcs.iter().map(|v| v.mb_hash).collect();
 
···
         Ok(res)
     }
 
-    pub async fn get_or_create_user<'a>(&self, user: &'a crate::rpc::RpcHello<'a>, funcs: Option<&'a crate::rpc::PushMetadata<'a>>) -> Result<i32, tokio_postgres::Error> {
-        let stmt = self.prepare_cached(
+    pub async fn get_or_create_user<'a>(&self, user: &'a crate::rpc::RpcHello<'a>, funcs: Option<&'a crate::rpc::PushMetadata<'a>>) -> Result<i32, deadpool_postgres::PoolError> {
+        let conn = self.pool.get().await?;
+        let stmt = conn.prepare_cached(
             r#"
             WITH ins AS (
                 INSERT INTO users(lic_id, lic_data, hostname)
···
         let lic_data = user.license_data;
         let hostname = funcs.map(|v| v.hostname);
 
-        let row = self.conn.read().await.query(&stmt, &[&lic_id, &hostname, &lic_data]).await?;
+        let row = conn.query(&stmt, &[&lic_id, &hostname, &lic_data]).await?;
         if !row.is_empty() {
             let id = row[0].get(0);
             if row.len() > 1 {
···
         }
     }
 
-    async fn get_or_create_file<'a>(&self, funcs: &'a crate::rpc::PushMetadata<'a>) -> Result<i32, tokio_postgres::Error> {
-        let stmt = self.prepare_cached(r#"
+    async fn get_or_create_file<'a>(&self, funcs: &'a crate::rpc::PushMetadata<'a>) -> Result<i32, deadpool_postgres::PoolError> {
+        let conn = self.pool.get().await?;
+        let stmt = conn.prepare_cached(r#"
         WITH ins AS (
             INSERT INTO files(chksum)
             VALUES ($1)
···
 
         let hash = &funcs.md5[..];
 
-        let id: i32 = self.conn.read().await
-            .query_one(&stmt, &[&hash]).await?
+        let id: i32 = conn.query_one(&stmt, &[&hash]).await?
             .get(0);
         Ok(id)
     }
 
-    async fn get_or_create_db<'a>(&self, user: &'a crate::rpc::RpcHello<'a>, funcs: &'a crate::rpc::PushMetadata<'a>) -> Result<i32, tokio_postgres::Error> {
+    async fn get_or_create_db<'a>(&self, user: &'a crate::rpc::RpcHello<'a>, funcs: &'a crate::rpc::PushMetadata<'a>) -> Result<i32, deadpool_postgres::PoolError> {
         let file_id = self.get_or_create_file(funcs);
         let user_id = self.get_or_create_user(user, Some(funcs));
 
         let (file_id, user_id): (i32, i32) = futures_util::try_join!(file_id, user_id)?;
 
-        let stmt = self.prepare_cached(r#"
+        let conn = self.pool.get().await?;
+        let stmt = conn.prepare_cached(r#"
         WITH ins AS (
             INSERT INTO dbs (user_id, file_id, file_path, idb_path)
             VALUES ($1, $2, $3, $4)
···
         let file_path = funcs.file_path;
 
         trace!("fid={}; uid={}", file_id, user_id);
-        let row = self.conn.read().await
-            .query_one(&stmt, &[&user_id, &file_id, &file_path, &idb_path]).await?;
+        let row = conn.query_one(&stmt, &[&user_id, &file_id, &file_path, &idb_path]).await?;
 
         let db_id = row.get(0);
 
         Ok(db_id)
     }
 
-    pub async fn push_funcs<'a, 'b>(&'b self, user: &'a crate::rpc::RpcHello<'a>, funcs: &'a crate::rpc::PushMetadata<'a>, scores: &[u32]) -> Result<Vec<bool>, tokio_postgres::Error> {
+    pub async fn push_funcs<'a, 'b>(&'b self, user: &'a crate::rpc::RpcHello<'a>, funcs: &'a crate::rpc::PushMetadata<'a>, scores: &[u32]) -> Result<Vec<bool>, deadpool_postgres::PoolError> {
         let db_id = self.get_or_create_db(user, funcs).await?;
         
-        let stmt = self.prepare_cached(r#"
+        let mut conn = self.pool.get().await?;
+        let stmt = conn.prepare_cached(r#"
         INSERT INTO funcs AS f (name, len, chksum, metadata, db_id, rank)
         VALUES ($1, $2, $3, $4, $5, $6)
         ON CONFLICT (db_id,chksum) DO UPDATE 
···
 
         // NOTE: Do not access self.conn/prepare_cached before dropping tx - it will deadlock!
         {
-            let mut tx = self.conn.write().await;
-            let tx = tx.transaction().await?;
+            let tx = conn.transaction().await?;
 
             for (func, &score) in funcs.funcs.iter().zip(scores.iter()) {
                 let name = func.name;
···
     }
 
     pub async fn is_online(&self) -> bool {
-        let read = self.conn.read().await;
-        !read.is_closed()
-    }
-
-    pub async fn reconnect(&self) -> Result<(), tokio_postgres::Error> {
-        let connection = Self::connect(self.config.get_config()).await?;
-        
-        let conn = &mut *self.conn.write().await;
-
-        self.cache.write().await.clear();
-
-        *conn = connection;
-        Ok(())
+        !self.pool.is_closed()
     }
 
-    pub async fn get_stats(&self) -> Result<DbStats, tokio_postgres::Error> {
-        let stmt = self.prepare_cached(r#"
+    pub async fn get_stats(&self) -> Result<DbStats, deadpool_postgres::PoolError> {
+        let conn = self.pool.get().await?;
+        let stmt = conn.prepare_cached(r#"
         SELECT 
             (SELECT COUNT(*)::int FROM users) as users,
             (SELECT COUNT(distinct lic_id)::int FROM users) as hosts,
···
             (SELECT COUNT(*)::int FROM dbs) as dbs,
             (SELECT COUNT(*)::int FROM files) as files
         "#).await?;
-        let db = self.conn.read().await;
-        let row = db.query_one(&stmt, &[]).await?;
+        let row = conn.query_one(&stmt, &[]).await?;
 
         Ok(DbStats {
             unique_lics: row.try_get(0)?,
···
         })
     }
 
-    pub async fn get_file_funcs(&self, md5: &[u8], offset: i64, limit: i64) -> Result<Vec<(String, u32, [u8; 16])>, tokio_postgres::Error> {
-        let stmt = self.prepare_cached(r#"
+    pub async fn get_file_funcs(&self, md5: &[u8], offset: i64, limit: i64) -> Result<Vec<(String, u32, [u8; 16])>, deadpool_postgres::PoolError> {
+        let conn = self.pool.get().await?;
+        let stmt = conn.prepare_cached(r#"
         SELECT fns.name, fns.len, fns.chksum FROM funcs AS fns
         LEFT JOIN dbs AS d ON (d.id=fns.db_id)
         LEFT JOIN files AS f ON (d.file_id=f.id)
···
         LIMIT $2
         OFFSET $3
         "#).await?;
-        let db = self.conn.read().await;
-        let rows = db.query(&stmt, &[&md5, &limit, &offset]).await?;
+        let rows = conn.query(&stmt, &[&md5, &limit, &offset]).await?;
 
         let res = rows.into_iter()
             .map(|row| {
···
         Ok(res)
     }
 
-    pub async fn get_files_with_func(&self, func: &[u8]) -> Result<Vec<[u8; 16]>, tokio_postgres::Error> {
-        let stmt = self.prepare_cached(r#"
+    pub async fn get_files_with_func(&self, func: &[u8]) -> Result<Vec<[u8; 16]>, deadpool_postgres::PoolError> {
+        let conn = self.pool.get().await?;
+        let stmt = conn.prepare_cached(r#"
         SELECT DISTINCT f.chksum FROM files f
         LEFT JOIN dbs d ON (d.file_id = f.id)
         LEFT JOIN funcs fns ON (fns.db_id = d.id)
         WHERE
             fns.chksum = $1
         "#).await?;
-        let db = self.conn.read().await;
-        let rows = db.query(&stmt, &[&func]).await?;
+        let rows = conn.query(&stmt, &[&func]).await?;
 
         let res = rows
             .into_iter()

common/src/rpc/mod.rs

···
     Utf8Error(std::str::Utf8Error),
     IOError(std::io::Error),
     Serde(String),
-    DbError(tokio_postgres::Error),
     InvalidData,
     OutOfMemory,
     Todo,
···
 impl From<std::str::Utf8Error> for Error {
     fn from(v: std::str::Utf8Error) -> Self {
         Error::Utf8Error(v)
-    }
-}
-impl From<tokio_postgres::Error> for Error {
-    fn from(v: tokio_postgres::Error) -> Self {
-        Error::DbError(v)
     }
 }
 impl From<std::collections::TryReserveError> for Error {

lumen/src/main.rs

···
     }
 }
 
-async fn maintenance(state: std::sync::Weak<SharedState_>) {
-    let mut timer = tokio::time::interval(std::time::Duration::from_secs(10));
-
-    loop {
-        timer.tick().await;
-
-        if let Some(state) = state.upgrade() {
-            
-            if !state.db.is_online().await {
-                warn!("db is offline; attempting to reconnect...");
-                match state.db.reconnect().await {
-                    Ok(_) => info!("reconnected."),
-                    Err(err) => error!("failed to reconnect: {}", err),
-                }
-            }
-
-        } else {
-            warn!("shared state is not available");
-            break;
-        }
-    }
-}
-
 fn main() {
     setup_logger();
     let matches = clap::Command::new("lumen")
···
         config,
         server_name,
     });
-
-    rt.spawn(maintenance(Arc::downgrade(&state)));
 
     let tls_acceptor;