deadpool connection pool with diesel_async

[Sn0rt]

hi all

I have only recently started developing with Rust, so I may not be very proficient in Rust yet.

I want to implement a process-level connection pool, but I found that the type of the connection pool return value implemented using the built-in pool function of diesel_sync is very strange?

use diesel_async::AsyncConnection;
use diesel_async::AsyncPgConnection;
use diesel_async::pooled_connection::{AsyncDieselConnectionManager, PoolableConnection};
use diesel_async::pooled_connection::deadpool::Pool;

pub async fn new_connection_from_url(database_url: String) -> AsyncPgConnection {
    AsyncPgConnection::establish(&*database_url).await.unwrap()
}

pub async fn setup_connection_pool(database_url: String) -> Pool<AsyncPgConnection> {
    let manager = AsyncDieselConnectionManager::<AsyncPgConnection>::new(database_url);
    let pool = Pool::builder(manager)
        .max_size(8)
        .build()
        .expect("Failed to create pool");
}

pub async fn get_conn(database_url: String) -> AsyncPgConnection {
    let pool = setup_connection_pool(database_url).await;
    let conn = pool
        .get()
        .await.unwrap();
    conn
}

The above is just the code under development. I just want to get a variable of type AsyncPgConnection from the connection pool.

How can I accomplish this?

now the type of return value is Object<AsyncDieselConnectionManager<>AsyncPgConnection>

I have try use .defer method. but the lifecycle issues can't be sloved.

Is it because the connection pool needs to be managed that this wrapper is added? However, if the connection pool method needs to pass in this wrapper, it will be really ugly and inconvenient to test.

[Sn0rt]

and I have try other pool

use diesel_async::AsyncConnection;
use diesel_async::AsyncPgConnection;
use diesel_async::pooled_connection::AsyncDieselConnectionManager;
use diesel_async::pooled_connection::bb8::{Pool, PooledConnection};

pub async fn new_connection_from_url(database_url: String) -> AsyncPgConnection {
    AsyncPgConnection::establish(&*database_url).await.unwrap()
}

pub async fn setup_connection_pool(database_url: String) -> Pool<AsyncPgConnection> {
    let config = AsyncDieselConnectionManager::<AsyncPgConnection>::new(database_url);
    Pool::builder()
        .build(config)
        .await.unwrap()
}

pub async fn get_conn(database_url: String) -> PooledConnection<'static, AsyncDieselConnectionManager<AsyncPgConnection>> {
    let pool = setup_connection_pool(database_url).await;
    let conn = pool.get().await.unwrap();
    conn
}

mod test {
    use diesel_async::pooled_connection::PoolableConnection;

    use crate::setup_connection_pool;

    #[tokio::test]
    async fn test_conn_pool() {
        use diesel_async::pooled_connection::PoolableConnection;
        let pool = setup_connection_pool("postgres://postgres:123@localhost/wren".to_string()).await;
        let mut conn = pool.get().await.unwrap();
        let is_broken = conn.is_broken().to_string();
        assert_eq!(is_broken, "false");
    }
}

and the error info

error[E0308]: mismatched types
  --> crates/database/src/conn_pool.rs:20:5
   |
17 | pub async fn get_conn(database_url: String) -> PooledConnection<'static, AsyncDieselConnectionManager<AsyncPgConnection>> {
   |                                                -------------------------------------------------------------------------- expected `bb8::api::PooledConnection<'static, AsyncDieselConnectionManager<AsyncDieselConnectionManager<AsyncPgConnection>>>` because of return type
...
20 |     conn
   |     ^^^^ expected `AsyncDieselConnectionManager<AsyncPgConnection>`, found `AsyncPgConnection`
   |
   = note: expected struct `bb8::api::PooledConnection<'static, AsyncDieselConnectionManager<AsyncDieselConnectionManager<AsyncPgConnection>>>`
              found struct `bb8::api::PooledConnection<'_, AsyncDieselConnectionManager<AsyncPgConnection>>`

The error message is even stranger, because the manager type is nested.

[Sn0rt]

the last version of async connection pool, still't pass

use diesel_async::AsyncConnection;
use diesel_async::AsyncPgConnection;
use diesel_async::pooled_connection::AsyncDieselConnectionManager;
use diesel_async::pooled_connection::bb8::{Pool, PooledConnection};
use once_cell::sync::OnceCell;

static PG_CONN_POOL: OnceCell<Pool<AsyncDieselConnectionManager<AsyncPgConnection>>> = OnceCell::new();

pub async fn init_pool_from_url(database_url: String) {
    PG_CONN_POOL.get_or_init(|| {
        setup_connection_pool(database_url.clone())
    });
}

pub async fn new_connection_from_url(database_url: String) -> AsyncPgConnection {
    AsyncPgConnection::establish(&*database_url).await.unwrap()
}

pub async fn setup_connection_pool(database_url: String) -> Pool<AsyncPgConnection> {
    let config = AsyncDieselConnectionManager::<AsyncPgConnection>::new(database_url);
    Pool::builder()
        .build(config)
        .await.unwrap()
}

pub async fn get_conn() -> PooledConnection<'static, AsyncDieselConnectionManager<AsyncPgConnection>> {
    PG_CONN_POOL.get().unwrap().get().await.unwrap()
}

mod test {
    use diesel_async::pooled_connection::PoolableConnection;

    use crate::setup_connection_pool;

    #[tokio::test]
    async fn test_conn_pool() {
        use diesel_async::pooled_connection::PoolableConnection;
        let pool = setup_connection_pool("postgres://postgres:123@localhost/wren".to_string()).await;
        let mut conn = pool.get().await.unwrap();
        let is_broken = conn.is_broken().to_string();
        assert_eq!(is_broken, "false");
    }
}