Crate deadpool

Deadpool is a dead simple async pool for connections and objects of any type.

Example

use async_trait::async_trait;

#[derive(Debug)]
enum Error { Fail }

struct Connection {}

type Pool = deadpool::Pool<Connection, Error>;

impl Connection {
    async fn new() -> Result<Self, Error> {
        Ok(Connection {})
    }
    async fn check_health(&self) -> bool {
        true
    }
    async fn do_something(&self) -> String {
        "Hooray!".to_string()
    }
}

struct Manager {}

#[async_trait]
impl deadpool::Manager<Connection, Error> for Manager
{
    async fn create(&self) -> Result<Connection, Error> {
        Connection::new().await
    }
    async fn recycle(&self, conn: &mut Connection) -> deadpool::RecycleResult<Error> {
        if conn.check_health().await {
            Ok(())
        } else {
            Err(Error::Fail.into())
        }
    }
}

#[tokio::main]
async fn main() {
    let mgr = Manager {};
    let pool = Pool::new(mgr, 16);
    let mut conn = pool.get().await.unwrap();
    let value = conn.do_something().await;
    assert_eq!(value, "Hooray!".to_string());
}

For a more complete example please see deadpool-postgres

Structs

Object	A wrapper around the actual pooled object which implements the traits Deref, DerefMut and Drop. Use this object just as if it was of type T and upon leaving scope the drop function will take care of returning it to the pool.
Pool	A generic object and connection pool.
PoolConfig	Pool configuration
Status	The current pool status.
Timeouts	Timeouts when getting objects from the pool

Enums

PoolError	Error structure for Pool::get
RecycleError	This error is returned by the Manager::recycle function
TimeoutType	When Pool::get returns a timeout error this enum can be used to figure out which step caused the timeout.

Traits

Manager

This trait is used to create new objects or recycle existing ones.

Type Definitions

RecycleResult

Result type for the recycle function