deadpool-sync 0.1.0

Dead simple async pool utitities for sync managers
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

#![cfg(feature = "managed")]

use async_trait::async_trait;

use deadpool::{Manager, Pool, RecycleResult};
use deadpool_runtime::Runtime;
use deadpool_sync::SyncWrapper;

struct Computer {
    pub answer: usize,
}

struct ComputerManager {}

#[async_trait]
impl Manager for ComputerManager {
    type Type = SyncWrapper<Computer>;
    type Error = ();

    async fn create(&self) -> Result<Self::Type, Self::Error> {
        SyncWrapper::new(Runtime::Tokio1, || Ok(Computer { answer: 42 })).await
    }

    async fn recycle(&self, _: &mut Self::Type) -> RecycleResult<Self::Error> {
        Ok(())
    }
}

#[tokio::test]
async fn post_recycle() {
    let manager = ComputerManager {};
    let pool = Pool::<ComputerManager>::builder(manager)
        .max_size(1)
        .build()
        .unwrap();
    let obj = pool.get().await.unwrap();
    assert_eq!(obj.interact(|computer| computer.answer).await.unwrap(), 42);
    let guard = obj.lock().unwrap();
    assert_eq!(guard.answer, 42);
}