bb8: Drop reliance on parking_lot

bb8/Cargo.toml

@@ -13,8 +13,7 @@ rust-version = "1.57"
 async-trait = "0.1"
 futures-channel = "0.3.2"
 futures-util = { version = "0.3.2", default-features = false, features = ["channel"] }
-parking_lot = "0.12"
-tokio = { version = "1.0", features = ["rt", "time", "parking_lot"] }
+tokio = { version = "1.0", features = ["rt", "time"] }
 
 [dev-dependencies]
 tokio = { version = "1.0", features = ["macros"] }

bb8/src/inner.rs

@@ -40,7 +40,10 @@ where
     }
 
     pub(crate) async fn start_connections(&self) -> Result<(), M::Error> {
-        let wanted = self.inner.internals.lock().wanted(&self.inner.statics);
+        let wanted = {
+            let mut locked = self.inner.internals.lock().unwrap();
+            locked.wanted(&self.inner.statics)
+        };
         let mut stream = self.replenish_idle_connections(wanted);
         while let Some(result) = stream.next().await {
             result?;
@@ -49,7 +52,7 @@ where
     }
 
     pub(crate) fn spawn_start_connections(&self) {
-        let mut locked = self.inner.internals.lock();
+        let mut locked = self.inner.internals.lock().unwrap();
         self.spawn_replenishing_approvals(locked.wanted(&self.inner.statics));
     }
 
@@ -108,7 +111,7 @@ where
     {
         loop {
             let mut conn = {
-                let mut locked = self.inner.internals.lock();
+                let mut locked = self.inner.internals.lock().unwrap();
                 match locked.pop(&self.inner.statics) {
                     Some((conn, approvals)) => {
                         self.spawn_replenishing_approvals(approvals);
@@ -134,7 +137,7 @@ where
 
         let (tx, rx) = oneshot::channel();
         {
-            let mut locked = self.inner.internals.lock();
+            let mut locked = self.inner.internals.lock().unwrap();
             let approvals = locked.push_waiter(tx, &self.inner.statics);
             self.spawn_replenishing_approvals(approvals);
         };
@@ -161,7 +164,7 @@ where
             }
         });
 
-        let mut locked = self.inner.internals.lock();
+        let mut locked = self.inner.internals.lock().unwrap();
         match conn {
             Some(conn) => locked.put(conn, None, self.inner.clone()),
             None => {
@@ -173,11 +176,12 @@ where
 
     /// Returns information about the current state of the pool.
     pub(crate) fn state(&self) -> State {
-        self.inner.internals.lock().state()
+        let locked = self.inner.internals.lock().unwrap();
+        locked.state()
     }
 
     fn reap(&self) {
-        let mut internals = self.inner.internals.lock();
+        let mut internals = self.inner.internals.lock().unwrap();
         let approvals = internals.reap(&self.inner.statics);
         self.spawn_replenishing_approvals(approvals);
     }
@@ -205,15 +209,13 @@ where
             match conn {
                 Ok(conn) => {
                     let conn = Conn::new(conn);
-                    shared
-                        .internals
-                        .lock()
-                        .put(conn, Some(approval), self.inner.clone());
+                    let mut locked = shared.internals.lock().unwrap();
+                    locked.put(conn, Some(approval), self.inner.clone());
                     return Ok(());
                 }
                 Err(e) => {
                     if Instant::now() - start > self.inner.statics.connection_timeout {
-                        let mut locked = shared.internals.lock();
+                        let mut locked = shared.internals.lock().unwrap();
                         locked.connect_failed(approval);
                         return Err(e);
                     } else {

bb8/src/internals.rs

@@ -1,9 +1,9 @@
 use std::cmp::min;
 use std::sync::Arc;
+use std::sync::Mutex;
 use std::time::Instant;
 
 use futures_channel::oneshot;
-use parking_lot::Mutex;
 
 use crate::api::{Builder, ManageConnection};
 use std::collections::VecDeque;
@@ -188,7 +188,7 @@ impl<M: ManageConnection> InternalsGuard<M> {
 impl<M: ManageConnection> Drop for InternalsGuard<M> {
     fn drop(&mut self) {
         if let Some(conn) = self.conn.take() {
-            let mut locked = self.pool.internals.lock();
+            let mut locked = self.pool.internals.lock().unwrap();
             locked.put(conn, None, self.pool.clone());
         }
     }