fix: Make connection Arced

Author: chriswk

src/lib.rs

@@ -88,7 +88,7 @@ impl Default for CacheConfiguration {
 
 #[derive(Clone)]
 pub struct SqlxPostgresqlSessionStore {
-    client_pool: Pool<Postgres>,
+    client_pool: Arc<Pool<Postgres>>,
     configuration: CacheConfiguration,
 }
 
@@ -117,7 +117,7 @@ impl SqlxPostgresqlSessionStore {
         Self::builder(connection_string).build().await
     }
 
-    pub async fn from_pool(pool: Pool<Postgres>) -> SqlxPostgresqlSessionStoreBuilder {
+    pub async fn from_pool(pool: Arc<Pool<Postgres>>) -> SqlxPostgresqlSessionStoreBuilder {
         SqlxPostgresqlSessionStoreBuilder {
             connection_data: ConnectionPool(pool),
             configuration: CacheConfiguration::default(),
@@ -127,7 +127,7 @@ impl SqlxPostgresqlSessionStore {
 
 pub enum ConnectionData {
     ConnectionString(String),
-    ConnectionPool(Pool<Postgres>),
+    ConnectionPool(Arc<Pool<Postgres>>),
 }
 
 #[must_use]
@@ -145,7 +145,7 @@ impl SqlxPostgresqlSessionStoreBuilder {
                 .await
                 .map_err(Into::into)
                 .map(|pool| SqlxPostgresqlSessionStore {
-                    client_pool: pool,
+                    client_pool: Arc::new(pool),
                     configuration: self.configuration,
                 }),
             ConnectionPool(pool) => Ok(SqlxPostgresqlSessionStore {
@@ -164,7 +164,7 @@ impl SessionStore for SqlxPostgresqlSessionStore {
         let row =
             sqlx::query("SELECT session_state FROM sessions WHERE key = $1 AND expires > NOW()")
                 .bind(key)
-                .fetch_optional(&self.client_pool)
+                .fetch_optional(self.client_pool.as_ref())
                 .await
                 .map_err(Into::into)
                 .map_err(LoadError::Other)?;
@@ -195,7 +195,7 @@ impl SessionStore for SqlxPostgresqlSessionStore {
             .bind(cache_key)
             .bind(body)
             .bind(expires)
-            .execute(&self.client_pool)
+            .execute(self.client_pool.as_ref())
             .await
             .map_err(Into::into)
             .map_err(SaveError::Other)?;
@@ -217,7 +217,7 @@ impl SessionStore for SqlxPostgresqlSessionStore {
             .bind(body)
             .bind(new_expires)
             .bind(cache_key)
-            .execute(&self.client_pool)
+            .execute(self.client_pool.as_ref())
             .await
             .map_err(Into::into)
             .map_err(UpdateError::Other)?;
@@ -234,7 +234,7 @@ impl SessionStore for SqlxPostgresqlSessionStore {
         sqlx::query("UPDATE sessions SET expires = $1 WHERE key = $2")
             .bind(new_expires)
             .bind(key)
-            .execute(&self.client_pool)
+            .execute(self.client_pool.as_ref())
             .await
             .map_err(Into::into)
             .map_err(UpdateError::Other)?;
@@ -245,7 +245,7 @@ impl SessionStore for SqlxPostgresqlSessionStore {
         let key = (self.configuration.cache_keygen)(session_key.as_ref());
         sqlx::query("DELETE FROM sessions WHERE key = $1")
             .bind(key)
-            .execute(&self.client_pool)
+            .execute(self.client_pool.as_ref())
             .await
             .map_err(Into::into)
             .map_err(UpdateError::Other)?;

tests/session_store.rs

@@ -1,57 +1,54 @@
 mod test_helpers;
-#[cfg(test)]
-pub mod tests {
-    use actix_session::storage::SessionStore;
-    use actix_session_sqlx_postgres::SqlxPostgresqlSessionStore;
-    use sqlx::postgres::PgPoolOptions;
-    use std::collections::HashMap;
-    use testcontainers::clients;
-    use testcontainers::core::WaitFor;
-    use testcontainers::images::generic;
+use actix_session::storage::SessionStore;
+use actix_session_sqlx_postgres::SqlxPostgresqlSessionStore;
+use sqlx::postgres::PgPoolOptions;
+use std::collections::HashMap;
+use testcontainers::clients;
+use testcontainers::core::WaitFor;
+use testcontainers::images::generic;
 
-    async fn postgres_store(url: String) -> SqlxPostgresqlSessionStore {
-        SqlxPostgresqlSessionStore::new(url).await.expect("")
-    }
+async fn postgres_store(url: String) -> SqlxPostgresqlSessionStore {
+    SqlxPostgresqlSessionStore::new(url).await.expect("")
+}
 
-    #[actix_web::test]
-    async fn test_session_workflow() {
-        let docker = clients::Cli::default();
-        let postgres = docker.run(
-            generic::GenericImage::new("postgres", "14-alpine")
-                .with_wait_for(WaitFor::message_on_stderr(
-                    "database system is ready to accept connections",
-                ))
-                .with_env_var("POSTGRES_DB", "sessions")
-                .with_env_var("POSTGRES_PASSWORD", "example")
-                .with_env_var("POSTGRES_HOST_AUTH_METHOD", "trust")
-                .with_env_var("POSTGRES_USER", "tests"),
-        );
-        let url = format!(
-            "postgres://tests:example@localhost:{}/sessions",
-            postgres.get_host_port_ipv4(5432)
-        );
+#[actix_web::test]
+async fn test_session_workflow() {
+    let docker = clients::Cli::default();
+    let postgres = docker.run(
+        generic::GenericImage::new("postgres", "15-alpine")
+            .with_wait_for(WaitFor::message_on_stderr(
+                "database system is ready to accept connections",
+            ))
+            .with_env_var("POSTGRES_DB", "sessions")
+            .with_env_var("POSTGRES_PASSWORD", "example")
+            .with_env_var("POSTGRES_HOST_AUTH_METHOD", "trust")
+            .with_env_var("POSTGRES_USER", "tests"),
+    );
+    let url = format!(
+        "postgres://tests:example@localhost:{}/sessions",
+        postgres.get_host_port_ipv4(5432)
+    );
 
-        let postgres_store = postgres_store(url.clone()).await;
-        let pool = PgPoolOptions::new()
-            .max_connections(1)
-            .connect(url.as_str())
-            .await
-            .expect("Could not connect to database");
-        sqlx::query(
-            r#"CREATE TABLE sessions(
+    let postgres_store = postgres_store(url.clone()).await;
+    let pool = PgPoolOptions::new()
+        .max_connections(1)
+        .connect(url.as_str())
+        .await
+        .expect("Could not connect to database");
+    sqlx::query(
+        r#"CREATE TABLE sessions(
              key TEXT PRIMARY KEY NOT NULL,
              session_state JSONB,
              expires TIMESTAMP WITH TIME ZONE NOT NULL
         );"#,
-        )
-        .execute(&pool)
-        .await
-        .expect("Could not create table");
-        let mut session = HashMap::new();
-        session.insert("key".to_string(), "value".to_string());
-        let data = postgres_store.save(session, &time::Duration::days(1)).await;
-        println!("{:#?}", data);
-        assert!(data.is_ok());
-        super::test_helpers::acceptance_test_suite(move || postgres_store.clone(), true).await;
-    }
+    )
+    .execute(&pool)
+    .await
+    .expect("Could not create table");
+    let mut session = HashMap::new();
+    session.insert("key".to_string(), "value".to_string());
+    let data = postgres_store.save(session, &time::Duration::days(1)).await;
+    println!("{:#?}", data);
+    assert!(data.is_ok());
+    test_helpers::acceptance_test_suite(move || postgres_store.clone(), true).await;
 }