Merge pull request #249 from alexrudy/feature/client/pool-token-impro…

…vements

Use the token to indicate whether a connection is re-used.

src/client/pool/checkout.rs

@@ -688,26 +688,26 @@ where
             pool.push(token, reused, poolref.clone());
             return Pooled {
                 connection: Some(connection),
-                is_reused: true,
-                token,
+                token: Token::zero(),
                 pool: PoolRef::none(),
             };
         } else {
             return Pooled {
                 connection: Some(connection),
-                is_reused: false,
                 token,
                 pool: poolref.clone(),
             };
         }
     }
 
     // No pool or lock was available, so we can't add the connection to the pool.
+    //
+    // Returning the original poolref + token means that if this was temporary,
+    // and we can grab the pool later, we will do so.
     Pooled {
         connection: Some(connection),
-        is_reused: false,
         token,
-        pool: PoolRef::none(),
+        pool: poolref.clone(),
     }
 }
 

src/client/pool/mod.rs

@@ -89,6 +89,9 @@ pub enum UriError {
 #[derive(Debug)]
 pub(crate) struct Pool<C: PoolableConnection, K: Key> {
     inner: Arc<Mutex<PoolInner<C>>>,
+
+    // NOTE: The token map is stored on the Pool, not the PoolInner so that the generic K argument doesn't
+    // propogate into the pool inner and reference, only the connection type propogates.
     keys: Arc<Mutex<TokenMap<K>>>,
 }
 
@@ -330,8 +333,7 @@ where
                     trace!("re-usable connection will be sent to waiter");
                     let pooled = Pooled {
                         connection: Some(conn),
-                        is_reused: true,
-                        token,
+                        token: Token::zero(),
                         pool: pool_ref.clone(),
                     };
 
@@ -346,7 +348,6 @@ where
                     );
                     let pooled = Pooled {
                         connection: Some(connection),
-                        is_reused: false,
                         token,
                         pool: pool_ref.clone(),
                     };
@@ -461,7 +462,6 @@ where
     C: PoolableConnection,
 {
     connection: Option<C>,
-    is_reused: bool,
     token: Token,
     pool: PoolRef<C>,
 }
@@ -473,6 +473,12 @@ where
     fn take(mut self) -> Option<C> {
         self.connection.take()
     }
+
+    /// Checks if this connection is being re-used
+    /// by the pool (implying that it is multiplexed)
+    pub fn is_reused(&self) -> bool {
+        self.token.is_zero()
+    }
 }
 
 impl<C> fmt::Debug for Pooled<C>
@@ -514,7 +520,7 @@ where
 {
     fn drop(&mut self) {
         if let Some(connection) = self.connection.take() {
-            if connection.is_open() && !self.is_reused {
+            if connection.is_open() && !self.token.is_zero() {
                 if let Some(mut pool) = self.pool.lock() {
                     trace!("open connection returned to pool");
                     pool.push(self.token, connection, self.pool.clone());