refactor: use dashmap

dashmap is in effect a better `RwLock<HashMap<K, V>>`.

https://crates.io/crates/dashmap

Author: Fishrock123

Cargo.toml

@@ -31,6 +31,7 @@ hyper_client = ["hyper", "hyper-tls", "http-types/hyperium_http", "futures-util"
 
 [dependencies]
 async-trait = "0.1.37"
+dashmap = "3.11.10"
 http-types = "2.3.0"
 log = "0.4.7"
 

src/h1/mod.rs

@@ -1,12 +1,11 @@
 //! http-client implementation for async-h1, with connecton pooling ("Keep-Alive").
 
-use std::collections::HashMap;
 use std::net::SocketAddr;
 use std::{fmt::Debug, sync::Arc};
 
 use async_h1::client;
 use async_std::net::TcpStream;
-use async_std::sync::Mutex;
+use dashmap::DashMap;
 use deadpool::managed::Pool;
 use http_types::StatusCode;
 
@@ -27,13 +26,13 @@ use tls::{TlsConnWrapper, TlsConnection};
 // random benchmarks and see whatever gave decent perf vs resource use.
 static MAX_CONCURRENT_CONNECTIONS: usize = 50;
 
-type HttpPool = HashMap<SocketAddr, Pool<TcpStream, std::io::Error>>;
-type HttpsPool = HashMap<SocketAddr, Pool<TlsStream<TcpStream>, Error>>;
+type HttpPool = DashMap<SocketAddr, Pool<TcpStream, std::io::Error>>;
+type HttpsPool = DashMap<SocketAddr, Pool<TlsStream<TcpStream>, Error>>;
 
 /// Async-h1 based HTTP Client, with connecton pooling ("Keep-Alive").
 pub struct H1Client {
-    http_pool: Arc<Mutex<HttpPool>>,
-    https_pool: Arc<Mutex<HttpsPool>>,
+    http_pools: Arc<HttpPool>,
+    https_pools: Arc<HttpsPool>,
 }
 
 impl Debug for H1Client {
@@ -52,17 +51,17 @@ impl H1Client {
     /// Create a new instance.
     pub fn new() -> Self {
         Self {
-            http_pool: Arc::new(Mutex::new(HashMap::new())),
-            https_pool: Arc::new(Mutex::new(HashMap::new())),
+            http_pools: Arc::new(DashMap::new()),
+            https_pools: Arc::new(DashMap::new()),
         }
     }
 }
 
 #[async_trait]
 impl HttpClient for H1Client {
     async fn send(&self, mut req: Request) -> Result<Response, Error> {
-        let http_pool = self.http_pool.clone();
-        let https_pool = self.https_pool.clone();
+        let http_pools = self.http_pools.clone();
+        let https_pools = self.https_pools.clone();
         req.insert_header("Connection", "keep-alive");
 
         // Insert host
@@ -95,18 +94,16 @@ impl HttpClient for H1Client {
 
         match scheme {
             "http" => {
-                let mut hash = http_pool.lock().await;
-                let pool = if let Some(pool) = hash.get(&addr) {
+                let pool = if let Some(pool) = http_pools.get(&addr) {
                     pool
                 } else {
                     let manager = TcpConnection::new(addr);
                     let pool =
                         Pool::<TcpStream, std::io::Error>::new(manager, MAX_CONCURRENT_CONNECTIONS);
-                    hash.insert(addr, pool);
-                    hash.get(&addr).unwrap()
+                    http_pools.insert(addr, pool);
+                    http_pools.get(&addr).unwrap()
                 };
                 let pool = pool.clone();
-                std::mem::drop(hash);
                 let stream = pool.get().await?;
                 req.set_peer_addr(stream.peer_addr().ok());
                 req.set_local_addr(stream.local_addr().ok());
@@ -118,20 +115,18 @@ impl HttpClient for H1Client {
                 // client::connect(stream, req).await
             }
             "https" => {
-                let mut hash = https_pool.lock().await;
-                let pool = if let Some(pool) = hash.get(&addr) {
+                let pool = if let Some(pool) = https_pools.get(&addr) {
                     pool
                 } else {
                     let manager = TlsConnection::new(host.clone(), addr);
                     let pool = Pool::<TlsStream<TcpStream>, Error>::new(
                         manager,
                         MAX_CONCURRENT_CONNECTIONS,
                     );
-                    hash.insert(addr, pool);
-                    hash.get(&addr).unwrap()
+                    https_pools.insert(addr, pool);
+                    https_pools.get(&addr).unwrap()
                 };
                 let pool = pool.clone();
-                std::mem::drop(hash);
                 let stream = pool.get().await.unwrap(); // TODO: remove unwrap
                 req.set_peer_addr(stream.get_ref().peer_addr().ok());
                 req.set_local_addr(stream.get_ref().local_addr().ok());