Rpool (Resource Pool joined) is a small Rust crate to handle abstract resource pooling. Rpool is a non-blocking implementation, providing state reset, externally immutable context, and opt-in automatic scaling (descaling is manual through the reset trait function).
Any pooled data must implement the rpool::Poolable trait. Generally speaking, one would have a wrapper struct around a network stream or higher level resource, along with any necessary internal state specific to that resource.
```
pub trait Poolable
fn reset(&mut self) -> bool; // ran during return to the pool, must return true if resource is still valid.
} ```
The T type parameter is for the context type, use () if no inter-resource context is necessary. Internal mutability is safe through Mutex implementations or std::atomic.
PoolScaleMode is an exposed enum specifying one of two different scaling strategies that rpool can use.
Static { count: usize }: Maintain a consistent number of resources at all times, and do not create more unless a resource fails to reset.AutoScale { maximum: Option<usize>, initial: usize, chunk_size: usize }: Start at initial resources allocated, increasing up to maximum or indefinitely in chunks of size chunk_size. If chunk_size is zero, the resource allocation is doubled during allocation. A reset resource in AutoScale is not automatically recreated immediately, but on demand.Pools are constructed through Pool::new::<ContextType, PoolableType>(scale_mode: PoolScaleMode, context: Y), which returns an Arc<Pool<ContextType, PoolableType>>.
The only exposed function on a Pool object is get(&self) -> PoolGuard<ContextType, PoolableType>.
PoolGuard transparently wraps PoolableType and returns the item into the pool upon being dropped.
See src/libs.rs, tests module.