Struct redis_tang::Pool

pub struct Pool<M> where
    M: Manager,  { /* private fields */ }

Implementations

impl<M> Pool<M> where
    M: Manager, 

pub async fn get(&'_ self) -> Result<PoolRef<'_, M>, <M as Manager>::Error>

Return a PoolRef contains reference of SharedManagedPool<Manager> and an Option<Manager::Connection>.

The PoolRef should be dropped asap when you finish the use of it. Hold it in scope would prevent the connection from pushed back to pool.

pub async fn get_owned(
    &'_ self
) -> Result<PoolRefOwned<M>, <M as Manager>::Error>

Return a PoolRefOwned contains a weak smart pointer of SharedManagedPool<Manager> and an Option<Manager::Connection>.

You can move PoolRefOwned to async blocks and across await point. But the performance is considerably worse than Pool::get.

pub async fn run<'a, T, E, F, FF>(&'a self, f: F) -> Result<T, E> where
    F: FnOnce(PoolRef<'a, M>) -> FF,
    FF: 'a + Future<Output = Result<T, E>> + Send,
    E: From<<M as Manager>::Error>,
    T: 'static + Send, 

Run the pool with an async closure.

example:

pool.run(|mut pool_ref| async {
    let connection = &mut *pool_ref;
    Ok(())
})

pub fn pause(&self)

Pause the pool

these functionalities will stop:

• get connection. Pool<Manager>::get() would eventually be timed out (If Manager::timeout is manually implemented with proper timeout function. *. Otherwise it will stuck forever in executor unless you cancel the future).
• spawn of new connection.
• default scheduled works (They would skip at least one iteration if the schedule time come across with the time period the pool is paused).
• put back connection. (connection will be dropped instead.)

pub fn resume(&self)

restart the pool.

pub fn running(&self) -> bool

check if the pool is running.

pub fn clear(&self)

Clear the pool.

All pending connections will also be destroyed.

Spawned count is not reset to 0 so new connections can’t fill the pool until all outgoing PoolRef are dropped.

All PoolRef' and 'PoolRefOwned outside of pool before the clear happen would be destroyed when trying to return it’s connection to pool.

pub async fn init(&'_ self) -> Result<(), <M as Manager>::Error>

manually initialize pool. this is usually called when the Pool is built with build_uninitialized This is useful when you want to make an empty Pool and initialize it later.

example:

#[macro_use]
extern crate lazy_static;

use tokio_postgres_tang::{Pool, PostgresManager, Builder};
use tokio_postgres::NoTls;

lazy_static! {
   static ref POOL: Pool<PostgresManager<NoTls>> = Builder::new()
        .always_check(false)
        .idle_timeout(None)
        .max_lifetime(None)
        .min_idle(24)
        .max_size(24)
        .build_uninitialized(
            PostgresManager::new_from_stringlike("postgres://postgres:123@localhost/test", NoTls)
                .expect("can't make postgres manager")
        );
}

#[tokio::main]
async fn main() -> std::io::Result<()> {
    POOL.init().await.expect("Failed to initialize postgres pool");
    Ok(())
}

pub fn set_max_size(&self, size: usize)

Change the max size of pool. This operation could result in some reallocation of PoolInner and impact the performance. (Pool<Manager>::clear() will recalibrate the pool with a capacity of current max/min pool size)

No actual check is used for new max_size. Be ware not to pass a size smaller than min_idle.

pub fn set_min_idle(&self, size: usize)

Change the min idle size of pool. (Pool<Manager>::clear() will recalibrate the pool with a capacity of current max/min pool size)

No actual check is used for new min_idle. Be ware not to pass a size bigger than max_size.

pub fn get_manager(&self) -> &M

expose Manager to public

pub fn state(&self) -> State

Return a state of the pool inner. This call will block the thread and wait for lock.

Trait Implementations

impl<M> Clone for Pool<M> where
    M: Manager, 

fn clone(&self) -> Pool<M>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<M> Debug for Pool<M> where
    M: Manager, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<M> Drop for Pool<M> where
    M: Manager, 

fn drop(&mut self)

Executes the destructor for this type.