1#[derive(Debug, Clone, PartialEq, Eq)]
3pub enum PoolError {
4 InvalidConnections,
5 InvalidTimeout,
6}
7#[derive(Debug, Clone, PartialEq, Eq)]
8pub struct PoolPolicy {
9 pub max_connections: u32,
10 pub min_connections: u32,
11 pub acquire_timeout_ms: u64,
12 pub idle_timeout_ms: u64,
13}
14impl PoolPolicy {
15 pub fn new(max_connections: u32) -> Result<Self, PoolError> {
16 if max_connections == 0 {
17 return Err(PoolError::InvalidConnections);
18 }
19 Ok(Self {
20 max_connections,
21 min_connections: 0,
22 acquire_timeout_ms: 30_000,
23 idle_timeout_ms: 600_000,
24 })
25 }
26 pub fn min_connections(mut self, min: u32) -> Result<Self, PoolError> {
27 if min > self.max_connections {
28 return Err(PoolError::InvalidConnections);
29 }
30 self.min_connections = min;
31 Ok(self)
32 }
33 pub fn acquire_timeout_ms(mut self, ms: u64) -> Result<Self, PoolError> {
34 if ms == 0 {
35 return Err(PoolError::InvalidTimeout);
36 }
37 self.acquire_timeout_ms = ms;
38 Ok(self)
39 }
40 pub fn idle_timeout_ms(mut self, ms: u64) -> Result<Self, PoolError> {
41 if ms == 0 {
42 return Err(PoolError::InvalidTimeout);
43 }
44 self.idle_timeout_ms = ms;
45 Ok(self)
46 }
47}
48impl Default for PoolPolicy {
49 fn default() -> Self {
50 Self::new(10).unwrap()
51 }
52}
53#[cfg(test)]
54mod tests {
55 use super::*;
56 #[test]
57 fn builds_deterministic_pool_policy() {
58 let p = PoolPolicy::new(10)
59 .unwrap()
60 .min_connections(2)
61 .unwrap()
62 .acquire_timeout_ms(1000)
63 .unwrap();
64 assert_eq!(p.max_connections, 10);
65 assert_eq!(p.min_connections, 2);
66 assert_eq!(p.acquire_timeout_ms, 1000)
67 }
68 #[test]
69 fn validates_bounds_and_timeouts() {
70 assert!(PoolPolicy::new(0).is_err());
71 assert!(PoolPolicy::new(2).unwrap().min_connections(3).is_err());
72 assert!(PoolPolicy::new(1).unwrap().acquire_timeout_ms(0).is_err());
73 assert!(PoolPolicy::new(1).unwrap().idle_timeout_ms(0).is_err())
74 }
75}