Basic functionality

This doesn't acually work since generic destructors are still broken :(
rust-lang/rust#15905

Author: sfackler

Cargo.toml

@@ -2,3 +2,12 @@
 name = "r2d2"
 version = "0.0.0"
 authors = ["Steven Fackler <[email protected]>"]
+
+[[lib]]
+name = "r2d2"
+path = "src/lib.rs"
+test = false
+
+[[test]]
+name = "test"
+path = "tests/test.rs"

src/lib.rs

@@ -2,6 +2,7 @@
 
 use std::default::Default;
 use std::sync::Mutex;
+use std::fmt;
 
 pub trait PoolManager<C, E> {
     fn connect(&self) -> Result<C, E>;
@@ -19,6 +20,37 @@ impl Default for Config {
     }
 }
 
+impl Config {
+    pub fn validate(&self) -> Result<(), ConfigError> {
+        Ok(())
+    }
+}
+
+#[deriving(PartialEq, Eq)]
+pub enum ConfigError {
+}
+
+impl fmt::Show for ConfigError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        Ok(())
+    }
+}
+
+#[deriving(PartialEq, Eq)]
+pub enum NewPoolError<E> {
+    InvalidConfig(ConfigError),
+    ConnectionError(E),
+}
+
+impl<E: fmt::Show> fmt::Show for NewPoolError<E> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            InvalidConfig(ref error) => write!(f, "Invalid Config: {}", error),
+            ConnectionError(ref error) => write!(f, "Unable to create connections: {}", error),
+        }
+    }
+}
+
 struct PoolInternals<C> {
     conns: Vec<C>,
 }
@@ -30,23 +62,56 @@ pub struct Pool<C, M> {
 }
 
 impl<C: Send, E, M: PoolManager<C, E>+Default> Pool<C, M> {
-    pub fn new(config: Config) -> Pool<C, M> {
+    pub fn new(config: Config) -> Result<Pool<C, M>, NewPoolError<E>> {
         Pool::with_manager(config, Default::default())
     }
 }
 
 impl<C: Send, E, M: PoolManager<C, E>> Pool<C, M> {
-    pub fn with_manager(config: Config, manager: M) -> Pool<C, M> {
-        Pool {
+    pub fn with_manager(config: Config, manager: M) -> Result<Pool<C, M>, NewPoolError<E>> {
+        match config.validate() {
+            Ok(()) => {}
+            Err(err) => return Err(InvalidConfig(err))
+        }
+
+        let mut internals = PoolInternals {
+            conns: vec![],
+        };
+
+        for _ in range(0, config.initial_size) {
+            match manager.connect() {
+                Ok(conn) => internals.conns.push(conn),
+                Err(err) => return Err(ConnectionError(err)),
+            }
+        }
+
+        Ok(Pool {
             config: config,
             manager: manager,
-            internals: Mutex::new(PoolInternals {
-                conns: vec![]
-            }),
+            internals: Mutex::new(internals),
+        })
+    }
+
+    pub fn get<'a>(&'a self) -> Result<PooledConnection<'a, C, M>, E> {
+        let mut internals = self.internals.lock();
+
+        loop {
+            match internals.conns.pop() {
+                Some(conn) => {
+                    return Ok(PooledConnection {
+                        pool: self,
+                        conn: Some(conn)
+                    })
+                }
+                None => internals.cond.wait(),
+            }
         }
     }
 
     fn put_back(&self, conn: C) {
+        let mut internals = self.internals.lock();
+        internals.conns.push(conn);
+        internals.cond.signal();
     }
 }
 

tests/test.rs

@@ -0,0 +1,67 @@
+extern crate r2d2;
+
+use std::cell::Cell;
+use std::default::Default;
+
+#[deriving(Show, PartialEq)]
+struct FakeConnection;
+
+#[deriving(Default)]
+struct OkManager;
+
+impl r2d2::PoolManager<FakeConnection, ()> for OkManager {
+    fn connect(&self) -> Result<FakeConnection, ()> {
+        Ok(FakeConnection)
+    }
+}
+
+struct NthConnectFailManager {
+    n: Cell<uint>
+}
+
+impl r2d2::PoolManager<FakeConnection, ()> for NthConnectFailManager {
+    fn connect(&self) -> Result<FakeConnection, ()> {
+        let n = self.n.get();
+        if n > 0 {
+            self.n.set(n - 1);
+            Ok(FakeConnection)
+        } else {
+            Err(())
+        }
+    }
+}
+
+#[test]
+fn test_initial_size_ok() {
+    let config = r2d2::Config {
+        initial_size: 5,
+        ..Default::default()
+    };
+    let manager = NthConnectFailManager { n: Cell::new(5) };
+    assert!(r2d2::Pool::with_manager(config, manager).is_ok());
+}
+
+#[test]
+fn test_initial_size_err() {
+    let config = r2d2::Config {
+        initial_size: 5,
+        ..Default::default()
+    };
+    let manager = NthConnectFailManager { n: Cell::new(4) };
+    assert_eq!(r2d2::Pool::with_manager(config, manager).err().unwrap(),
+               r2d2::ConnectionError(()));
+}
+
+#[test]
+fn test_acquire_release() {
+    let config = r2d2::Config {
+        initial_size: 2,
+        ..Default::default()
+    };
+    let pool = r2d2::Pool::with_manager(config, OkManager).unwrap();
+
+    let conn1 = pool.get().unwrap();
+    let _conn2 = pool.get().unwrap();
+    drop(conn1);
+    let _conn3 = pool.get().unwrap();
+}