fix: timed out fetching a new connection from the connection pool.

quaint/src/connector/postgres/native/mod.rs

@@ -36,6 +36,7 @@ use std::{
     sync::atomic::{AtomicBool, Ordering},
     time::Duration,
 };
+use tokio::sync::OnceCell;
 use tokio_postgres::{config::ChannelBinding, Client, Config, Statement};
 
 /// The underlying postgres driver. Only available with the `expose-drivers`
@@ -228,27 +229,10 @@ impl PostgresUrl {
 
 impl PostgreSql {
     /// Create a new connection to the database.
-    pub async fn new(url: PostgresUrl) -> crate::Result<Self> {
+    pub async fn new(url: PostgresUrl, tls_manager: &MakeTlsConnectorManager) -> crate::Result<Self> {
         let config = url.to_config();
 
-        let mut tls_builder = TlsConnector::builder();
-
-        {
-            let ssl_params = url.ssl_params();
-            let auth = ssl_params.to_owned().into_auth().await?;
-
-            if let Some(certificate) = auth.certificate.0 {
-                tls_builder.add_root_certificate(certificate);
-            }
-
-            tls_builder.danger_accept_invalid_certs(auth.ssl_accept_mode == SslAcceptMode::AcceptInvalidCerts);
-
-            if let Some(identity) = auth.identity.0 {
-                tls_builder.identity(identity);
-            }
-        }
-
-        let tls = MakeTlsConnector::new(tls_builder.build()?);
+        let tls = tls_manager.get_connector().await?;
         let (client, conn) = timeout::connect(url.connect_timeout(), config.connect(tls)).await?;
 
         let is_cockroachdb = conn.parameter("crdb_version").is_some();
@@ -907,6 +891,48 @@ fn is_safe_identifier(ident: &str) -> bool {
     true
 }
 
+pub struct MakeTlsConnectorManager {
+    url: PostgresUrl,
+    connector: OnceCell<MakeTlsConnector>,
+}
+
+impl MakeTlsConnectorManager {
+    pub fn new(url: PostgresUrl) -> Self {
+        MakeTlsConnectorManager {
+            url,
+            connector: OnceCell::new(),
+        }
+    }
+
+    pub async fn get_connector(&self) -> crate::Result<MakeTlsConnector> {
+        self.connector
+            .get_or_try_init(|| async {
+                let mut tls_builder = TlsConnector::builder();
+
+                {
+                    let ssl_params = self.url.ssl_params();
+                    let auth = ssl_params.to_owned().into_auth().await?;
+
+                    if let Some(certificate) = auth.certificate.0 {
+                        tls_builder.add_root_certificate(certificate);
+                    }
+
+                    tls_builder.danger_accept_invalid_certs(auth.ssl_accept_mode == SslAcceptMode::AcceptInvalidCerts);
+
+                    if let Some(identity) = auth.identity.0 {
+                        tls_builder.identity(identity);
+                    }
+                }
+
+                let tls_connector = MakeTlsConnector::new(tls_builder.build()?);
+
+                Ok(tls_connector)
+            })
+            .await
+            .cloned()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -925,7 +951,9 @@ mod tests {
             let mut pg_url = PostgresUrl::new(url).unwrap();
             pg_url.set_flavour(PostgresFlavour::Postgres);
 
-            let client = PostgreSql::new(pg_url).await.unwrap();
+            let tls_manager = MakeTlsConnectorManager::new(pg_url.clone());
+
+            let client = PostgreSql::new(pg_url, &tls_manager).await.unwrap();
 
             let result_set = client.query_raw("SHOW search_path", &[]).await.unwrap();
             let row = result_set.first().unwrap();
@@ -977,7 +1005,9 @@ mod tests {
             let mut pg_url = PostgresUrl::new(url).unwrap();
             pg_url.set_flavour(PostgresFlavour::Postgres);
 
-            let client = PostgreSql::new(pg_url).await.unwrap();
+            let tls_manager = MakeTlsConnectorManager::new(pg_url.clone());
+
+            let client = PostgreSql::new(pg_url, &tls_manager).await.unwrap();
 
             let result_set = client.query_raw("SHOW search_path", &[]).await.unwrap();
             let row = result_set.first().unwrap();
@@ -1028,7 +1058,9 @@ mod tests {
             let mut pg_url = PostgresUrl::new(url).unwrap();
             pg_url.set_flavour(PostgresFlavour::Cockroach);
 
-            let client = PostgreSql::new(pg_url).await.unwrap();
+            let tls_manager = MakeTlsConnectorManager::new(pg_url.clone());
+
+            let client = PostgreSql::new(pg_url, &tls_manager).await.unwrap();
 
             let result_set = client.query_raw("SHOW search_path", &[]).await.unwrap();
             let row = result_set.first().unwrap();
@@ -1079,7 +1111,9 @@ mod tests {
             let mut pg_url = PostgresUrl::new(url).unwrap();
             pg_url.set_flavour(PostgresFlavour::Unknown);
 
-            let client = PostgreSql::new(pg_url).await.unwrap();
+            let tls_manager = MakeTlsConnectorManager::new(pg_url.clone());
+
+            let client = PostgreSql::new(pg_url, &tls_manager).await.unwrap();
 
             let result_set = client.query_raw("SHOW search_path", &[]).await.unwrap();
             let row = result_set.first().unwrap();
@@ -1130,7 +1164,9 @@ mod tests {
             let mut pg_url = PostgresUrl::new(url).unwrap();
             pg_url.set_flavour(PostgresFlavour::Unknown);
 
-            let client = PostgreSql::new(pg_url).await.unwrap();
+            let tls_manager = MakeTlsConnectorManager::new(pg_url.clone());
+
+            let client = PostgreSql::new(pg_url, &tls_manager).await.unwrap();
 
             let result_set = client.query_raw("SHOW search_path", &[]).await.unwrap();
             let row = result_set.first().unwrap();

quaint/src/pooled.rs

@@ -156,7 +156,7 @@
 use crate::error::NativeErrorKind;
 
 use crate::{
-    connector::ConnectionInfo,
+    connector::{ConnectionInfo, MakeTlsConnectorManager},
     error::{Error, ErrorKind},
 };
 use mobc::Pool;
@@ -312,7 +312,11 @@
             url.set_flavour(flavour);
         }
 
-        if let QuaintManager::Postgres { ref mut url } = self.manager {
+        if let QuaintManager::Postgres {
+            ref mut url,
+            tls_manager: _,
+        } = self.manager
+        {
             url.set_flavour(flavour);
         }
     }
@@ -421,7 +425,8 @@
                 let max_connection_lifetime = url.max_connection_lifetime();
                 let max_idle_connection_lifetime = url.max_idle_connection_lifetime();
 
-                let manager = QuaintManager::Postgres { url };
+                let tls_manager = MakeTlsConnectorManager::new(url.clone());
+                let manager = QuaintManager::Postgres { url, tls_manager };
                 let mut builder = Builder::new(s, manager)?;
 
                 if let Some(limit) = connection_limit {

quaint/src/pooled/manager.rs

@@ -3,7 +3,7 @@ use crate::connector::MssqlUrl;
 #[cfg(feature = "mysql-native")]
 use crate::connector::MysqlUrl;
 #[cfg(feature = "postgresql-native")]
-use crate::connector::PostgresUrl;
+use crate::connector::{MakeTlsConnectorManager, PostgresUrl};
 use crate::{
     ast,
     connector::{self, impl_default_TransactionCapable, IsolationLevel, Queryable, Transaction, TransactionCapable},
@@ -85,7 +85,10 @@ pub enum QuaintManager {
     Mysql { url: MysqlUrl },
 
     #[cfg(feature = "postgresql")]
-    Postgres { url: PostgresUrl },
+    Postgres {
+        url: PostgresUrl,
+        tls_manager: MakeTlsConnectorManager,
+    },
 
     #[cfg(feature = "sqlite")]
     Sqlite { url: String, db_name: String },
@@ -117,9 +120,9 @@ impl Manager for QuaintManager {
             }
 
             #[cfg(feature = "postgresql-native")]
-            QuaintManager::Postgres { url } => {
+            QuaintManager::Postgres { url, tls_manager } => {
                 use crate::connector::PostgreSql;
-                Ok(Box::new(PostgreSql::new(url.clone()).await?) as Self::Connection)
+                Ok(Box::new(PostgreSql::new(url.clone(), tls_manager).await?) as Self::Connection)
             }
 
             #[cfg(feature = "mssql-native")]

quaint/src/single.rs

@@ -149,7 +149,8 @@ impl Quaint {
             #[cfg(feature = "postgresql-native")]
             s if s.starts_with("postgres") || s.starts_with("postgresql") => {
                 let url = connector::PostgresUrl::new(url::Url::parse(s)?)?;
-                let psql = connector::PostgreSql::new(url).await?;
+                let tls_manager = connector::MakeTlsConnectorManager::new(url.clone());
+                let psql = connector::PostgreSql::new(url, &tls_manager).await?;
                 Arc::new(psql) as Arc<dyn Queryable>
             }
             #[cfg(feature = "mssql-native")]

schema-engine/connectors/sql-schema-connector/src/flavour/postgres/connection.rs

@@ -4,7 +4,7 @@ use enumflags2::BitFlags;
 use indoc::indoc;
 use psl::PreviewFeature;
 use quaint::{
-    connector::{self, tokio_postgres::error::ErrorPosition, PostgresUrl},
+    connector::{self, tokio_postgres::error::ErrorPosition, MakeTlsConnectorManager, PostgresUrl},
     prelude::{ConnectionInfo, NativeConnectionInfo, Queryable},
 };
 use schema_connector::{ConnectorError, ConnectorResult, Namespaces};
@@ -22,8 +22,9 @@ impl Connection {
                 details: err.to_string(),
             })
         })?;
+        let tls_manager = MakeTlsConnectorManager::new(url.clone());
 
-        let quaint = connector::PostgreSql::new(url.clone())
+        let quaint = connector::PostgreSql::new(url.clone(), &tls_manager)
             .await
             .map_err(quaint_err(&url))?;