Module deadpool::managed

This module contains the managed version of the pool. Managed meaning that it requires a Manager trait which is responsible for creating and recycling objects as they are needed.

Example

use async_trait::async_trait;

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

struct Computer {}

impl Computer {
    async fn get_answer(&self) -> i32 {
        42
    }
}

struct Manager {}

#[async_trait]
impl deadpool::managed::Manager<Computer, Error> for Manager {
    async fn create(&self) -> Result<Computer, Error> {
        Ok(Computer {})
    }
    async fn recycle(&self, conn: &mut Computer) -> deadpool::managed::RecycleResult<Error> {
        Ok(())
    }
}

type Pool = deadpool::managed::Pool<Computer, Error>;

#[tokio::main]
async fn main() {
    let mgr = Manager {};
    let pool = Pool::new(mgr, 16);
    let mut conn = pool.get().await.unwrap();
    let answer = conn.get_answer().await;
    assert_eq!(answer, 42);
}

For a more complete example please see deadpool-postgres

Re-exports

pub use crate::Status;

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
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