mobc_redis

```rust use mobc::futures::compat::Future01CompatExt; use mobc::Error; use mobc::Pool; use mobcredis::redis::{self, RedisError}; use mobcredis::RedisConnectionManager; use std::time::Instant; use tokio::executor::DefaultExecutor; use tokio::prelude::*; use tokio::sync::mpsc;

const MAX: usize = 5000;

async fn singlerequest( pool: Pool>, mut sender: mpsc::Sender<()>, ) -> Result<(), Error> { let mut conn = pool.get().await?; let rawredisconn = conn.takeraw_conn();

let (raw_redis_conn, pong) = redis::cmd("PING")
    .query_async::<_, String>(raw_redis_conn)
    .compat()
    .await?;

conn.set_raw_conn(raw_redis_conn);

assert_eq!("PONG", pong);
sender.send(()).await.unwrap();
Ok(())

}

async fn doredis(sender: mpsc::Sender<()>) -> Result<(), Error> { let client = redis::Client::open("redis://127.0.0.1").unwrap(); let manager = RedisConnectionManager::new(client); let pool = Pool::builder().maxsize(40).build(manager).await?;

for _ in 0..MAX {
    let pool = pool.clone();
    let tx = sender.clone();
    tokio::spawn(single_request(pool, tx).map(|_| ()));
}
Ok(())

}

[tokio::main]

async fn main() { let mark = Instant::now(); let (tx, mut rx) = mpsc::channel::<()>(MAX); if let Err(e) = doredis(tx).await { println!("some error {}", e.tostring()); } let mut num: usize = 0; while let Some(_) = rx.next().await { num += 1; if num == MAX { break; } }

println!("cost {:?}", mark.elapsed());

}

```