Whitepool - A hunky Rust+Tokio worker pool factory

• WhitePool is a lightweight, generic pooling library for Rust+Tokio with a focus on simplicity, performance, and rock-solid disaster recovery.

• Whitepool inspired by Elixir/Erlang Poolboy almost all Elixir/Erlang Database library rely on it for Connetcion Pooling

Example

```rust

[tokio::main]

async fn main() {

let pool_size = 7;
let max_overflow = 4;


// Create a session for communicate with pool channel
let session = Pool::new(pool_size, 
                        max_overflow, 
                        || {Box::pin(async move {

                            // tokio_postgres create connection 

                            let (client, connection) =
                                    tokio_postgres::connect("host=localhost user=postgres", NoTls)
                                    .await.unwrap();

                            tokio::spawn(async move {
                                if let Err(e) = connection.await {
                                    eprintln!("connection error: {}", e);
                                }
                            });

                            // return client
                            client

                        })}).await.run_service();                            



// session.clone() internally call channel mpsc::Sender::Clone
process(session.clone()).await;

process(session.clone()).await;

process(session.clone()).await;



// wait until all pending checkout handled, then shutdown
session.safe_shutdown().await



tokio::time::sleep(Duration::from_secs(100)).await;

}

pub async fn process(session: Session) {

// Checkout a resource from Pool
// block_checkout don't block your scheduler
// just await on oneshot with timeout
if let Ok(mut client) = session.block_checkout().await {

// ============== start ===================

    let _rows = client
                .get()
                .query("SELECT $1::TEXT", &[&"hello world"])
                .await.unwrap();


// ============== end ===================

    // after job done, call checkin
    let _ = session.checkin(client).await;

    // OR if resource destroy, call this
    // session.destroyed(resource).await;
}

}

```

Options

• pool_size: maximum pool size
• max_overflow: maximum number of workers created if pool is empty
• factory: is a closure create a worker

Author

• DanyalMh

License

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at https://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.