wreq-rb 0.5.0 → 0.5.1

data/vendor/wreq/src/client/{http → layer}/client/pool.rs

@@ -1,11 +1,11 @@
 use std::{
-    collections::VecDeque,
+    collections::{HashMap, HashSet, VecDeque},
     convert::Infallible,
     error::Error as StdError,
     fmt::{self, Debug},
     future::Future,
     hash::Hash,
-    num::NonZero,
+    num::NonZeroUsize,
     ops::{Deref, DerefMut},
     pin::Pin,
     sync::{Arc, Weak},
@@ -13,13 +13,12 @@ use std::{
     time::{Duration, Instant},
 };
 
-use schnellru::ByLength;
+use lru::LruCache;
 use tokio::sync::oneshot;
+use wreq_proto::rt::{Executor as _, Timer as _};
 
-use super::exec::{self, Exec};
 use crate::{
-    client::core::rt::{ArcTimer, Executor, Timer},
-    hash::{HASHER, HashMap, HashSet, LruMap},
+    rt::{Executor, Timer},
     sync::Mutex,
 };
 
@@ -79,7 +78,7 @@ struct PoolInner<T, K: Eq + Hash> {
     connecting: HashSet<K>,
     // These are internal Conns sitting in the event loop in the KeepAlive
     // state, waiting to receive a new Request to send on the socket.
-    idle: LruMap<K, Vec<Idle<T>>>,
+    idle: LruCache<K, Vec<Idle<T>>>,
     max_idle_per_host: usize,
     // These are outstanding Checkouts that are waiting for a socket to be
     // able to send a Request one. This is used when "racing" for a new
@@ -94,8 +93,8 @@ struct PoolInner<T, K: Eq + Hash> {
     // A oneshot channel is used to allow the interval to be notified when
     // the Pool completely drops. That way, the interval can cancel immediately.
     idle_interval_ref: Option<oneshot::Sender<Infallible>>,
-    exec: Exec,
-    timer: Option<ArcTimer>,
+    exec: Executor,
+    timer: Timer,
     timeout: Option<Duration>,
 }
 
@@ -107,7 +106,7 @@ struct WeakOpt<T>(Option<Weak<T>>);
 pub struct Config {
     pub idle_timeout: Option<Duration>,
     pub max_idle_per_host: usize,
-    pub max_pool_size: Option<NonZero<u32>>,
+    pub max_pool_size: Option<NonZeroUsize>,
 }
 
 impl Config {
@@ -117,23 +116,18 @@ impl Config {
 }
 
 impl<T, K: Key> Pool<T, K> {
-    pub fn new<E, M>(config: Config, executor: E, timer: Option<M>) -> Pool<T, K>
-    where
-        E: Executor<exec::BoxSendFuture> + Send + Sync + Clone + 'static,
-        M: Timer + Send + Sync + Clone + 'static,
-    {
+    pub fn new(config: Config, exec: Executor, timer: Timer) -> Pool<T, K> {
         let inner = if config.is_enabled() {
             Some(Arc::new(Mutex::new(PoolInner {
-                connecting: HashSet::with_hasher(HASHER),
-                idle: LruMap::with_hasher(
-                    ByLength::new(config.max_pool_size.map_or(u32::MAX, NonZero::get)),
-                    HASHER,
-                ),
+                connecting: HashSet::default(),
+                idle: config
+                    .max_pool_size
+                    .map_or_else(LruCache::unbounded, LruCache::new),
                 idle_interval_ref: None,
                 max_idle_per_host: config.max_idle_per_host,
-                waiters: HashMap::with_hasher(HASHER),
-                exec: Exec::new(executor),
-                timer: timer.map(ArcTimer::new),
+                waiters: HashMap::default(),
+                exec,
+                timer,
                 timeout: config.idle_timeout,
             })))
         } else {
@@ -262,7 +256,7 @@ struct IdlePopper<'a, T, K> {
 }
 
 impl<'a, T: Poolable + 'a, K: Debug> IdlePopper<'a, T, K> {
-    fn pop(self, expiration: &Expiration) -> Option<Idle<T>> {
+    fn pop(self, expiration: &Expiration, now: Instant) -> Option<Idle<T>> {
         while let Some(entry) = self.list.pop() {
             // If the connection has been closed, or is older than our idle
             // timeout, simply drop it and keep looking...
@@ -276,7 +270,7 @@ impl<'a, T: Poolable + 'a, K: Debug> IdlePopper<'a, T, K> {
             //
             // In that case, we could just break out of the loop and drop the
             // whole list...
-            if expiration.expires(entry.idle_at) {
+            if expiration.expires(entry.idle_at, now) {
                 trace!("removing expired connection for {:?}", self.key);
                 continue;
             }
@@ -284,7 +278,7 @@ impl<'a, T: Poolable + 'a, K: Debug> IdlePopper<'a, T, K> {
             let value = match entry.value.reserve() {
                 Reservation::Shared(to_reinsert, to_checkout) => {
                     self.list.push(Idle {
-                        idle_at: Instant::now(),
+                        idle_at: now,
                         value: to_reinsert,
                     });
                     to_checkout
@@ -303,6 +297,10 @@ impl<'a, T: Poolable + 'a, K: Debug> IdlePopper<'a, T, K> {
 }
 
 impl<T: Poolable, K: Key> PoolInner<T, K> {
+    fn now(&self) -> Instant {
+        self.timer.now()
+    }
+
     fn put(&mut self, key: &K, value: T, __pool_ref: &Arc<Mutex<PoolInner<T, K>>>) {
         if value.can_share() && self.idle.peek(key).is_some() {
             trace!("put; existing idle HTTP/2 connection for {:?}", key);
@@ -348,22 +346,21 @@ impl<T: Poolable, K: Key> PoolInner<T, K> {
         if let Some(value) = value {
             // borrow-check scope...
             {
+                let now = self.now();
                 let idle_list = self
                     .idle
-                    .get_or_insert(key.clone(), Vec::<Idle<T>>::default);
+                    .get_or_insert_mut(key.clone(), Vec::<Idle<T>>::default);
 
-                if let Some(idle_list) = idle_list {
-                    if self.max_idle_per_host <= idle_list.len() {
-                        trace!("max idle per host for {:?}, dropping connection", key);
-                        return;
-                    }
-
-                    debug!("pooling idle connection for {:?}", key);
-                    idle_list.push(Idle {
-                        value,
-                        idle_at: Instant::now(),
-                    });
+                if self.max_idle_per_host <= idle_list.len() {
+                    trace!("max idle per host for {:?}, dropping connection", key);
+                    return;
                 }
+
+                debug!("pooling idle connection for {:?}", key);
+                idle_list.push(Idle {
+                    value,
+                    idle_at: now,
+                });
             }
 
             self.spawn_idle_interval(__pool_ref);
@@ -398,11 +395,9 @@ impl<T: Poolable, K: Key> PoolInner<T, K> {
             return;
         }
 
-        let timer = if let Some(timer) = self.timer.clone() {
-            timer
-        } else {
+        if self.timer.is_empty() {
             return;
-        };
+        }
 
         // While someone might want a shorter duration, and it will be respected
         // at checkout time, there's no need to wake up and proactively evict
@@ -421,7 +416,7 @@ impl<T: Poolable, K: Key> PoolInner<T, K> {
         self.idle_interval_ref = Some(tx);
 
         let interval = IdleTask {
-            timer: timer.clone(),
+            timer: self.timer.clone(),
             duration: dur,
             pool: WeakOpt::downgrade(pool_ref),
             pool_drop_notifier: rx,
@@ -452,7 +447,7 @@ impl<T: Poolable, K: Key> PoolInner<T, K> {
     /// This should *only* be called by the IdleTask
     fn clear_expired(&mut self) {
         let dur = self.timeout.expect("interval assumes timeout");
-        let now = Instant::now();
+        let now = self.now();
 
         let mut keys_to_remove = Vec::new();
         for (key, values) in self.idle.iter_mut() {
@@ -480,7 +475,7 @@ impl<T: Poolable, K: Key> PoolInner<T, K> {
 
         for key in keys_to_remove {
             trace!("idle interval removing empty key {:?}", key);
-            self.idle.remove(&key);
+            self.idle.pop(&key);
         }
     }
 }
@@ -628,7 +623,8 @@ impl<T: Poolable, K: Key> Checkout<T, K> {
         let entry = {
             let mut inner = self.pool.inner.as_ref()?.lock();
             let expiration = Expiration::new(inner.timeout);
-            let maybe_entry = inner.idle.get(&self.key).and_then(|list| {
+            let now = inner.now();
+            let maybe_entry = inner.idle.get_mut(&self.key).and_then(|list| {
                 trace!("take? {:?}: expiration = {:?}", self.key, expiration.0);
                 // A block to end the mutable borrow on list,
                 // so the map below can check is_empty()
@@ -637,7 +633,7 @@ impl<T: Poolable, K: Key> Checkout<T, K> {
                         key: &self.key,
                         list,
                     };
-                    popper.pop(&expiration)
+                    popper.pop(&expiration, now)
                 }
                 .map(|e| (e, list.is_empty()))
             });
@@ -650,7 +646,7 @@ impl<T: Poolable, K: Key> Checkout<T, K> {
             };
 
             if empty {
-                inner.idle.remove(&self.key);
+                inner.idle.pop(&self.key);
             }
 
             if entry.is_none() && self.waiter.is_none() {
@@ -738,17 +734,17 @@ impl Expiration {
         Expiration(dur)
     }
 
-    fn expires(&self, instant: Instant) -> bool {
+    fn expires(&self, instant: Instant, now: Instant) -> bool {
         match self.0 {
             // Avoid `Instant::elapsed` to avoid issues like rust-lang/rust#86470.
-            Some(timeout) => Instant::now().saturating_duration_since(instant) > timeout,
+            Some(timeout) => now.saturating_duration_since(instant) > timeout,
             None => false,
         }
     }
 }
 
 struct IdleTask<T, K: Key> {
-    timer: ArcTimer,
+    timer: Timer,
     duration: Duration,
     pool: WeakOpt<Mutex<PoolInner<T, K>>>,
     // This allows the IdleTask to be notified as soon as the entire
@@ -761,7 +757,7 @@ impl<T: Poolable + 'static, K: Key> IdleTask<T, K> {
     async fn run(self) {
         use futures_util::future;
 
-        let mut sleep = self.timer.sleep_until(Instant::now() + self.duration);
+        let mut sleep = self.timer.sleep_until(self.timer.now() + self.duration);
         let mut on_pool_drop = self.pool_drop_notifier;
         loop {
             match future::select(&mut on_pool_drop, &mut sleep).await {
@@ -777,7 +773,7 @@ impl<T: Poolable + 'static, K: Key> IdleTask<T, K> {
                         drop(inner);
                     }
 
-                    let deadline = Instant::now() + self.duration;
+                    let deadline = self.timer.now() + self.duration;
                     self.timer.reset(&mut sleep, deadline);
                 }
             }
@@ -815,7 +811,7 @@ mod tests {
 
     use super::{Connecting, Key, Pool, Poolable, Reservation, WeakOpt};
     use crate::{
-        client::core::rt::{ArcTimer, TokioExecutor, TokioTimer},
+        rt::{Executor, Timer},
         sync::MutexGuard,
     };
 
@@ -862,8 +858,8 @@ mod tests {
                 max_idle_per_host: max_idle,
                 max_pool_size: None,
             },
-            TokioExecutor::new(),
-            Option::<ArcTimer>::None,
+            Executor::default(),
+            Timer::empty(),
         )
     }
 
@@ -960,15 +956,24 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn test_pool_timer_removes_expired() {
+    async fn test_pool_timer_removes_expired_realtime() {
+        test_pool_timer_removes_expired_inner().await
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn test_pool_timer_removes_expired_faketime() {
+        test_pool_timer_removes_expired_inner().await
+    }
+
+    async fn test_pool_timer_removes_expired_inner() {
         let pool = Pool::new(
             super::Config {
                 idle_timeout: Some(Duration::from_millis(10)),
                 max_idle_per_host: usize::MAX,
                 max_pool_size: None,
             },
-            TokioExecutor::new(),
-            Some(TokioTimer::new()),
+            Executor::default(),
+            Timer::default(),
         );
 
         let key = host_key("foo");
@@ -1087,8 +1092,8 @@ mod tests {
                 max_idle_per_host: usize::MAX,
                 max_pool_size: Some(NonZero::new(2).expect("max pool size")),
             },
-            TokioExecutor::new(),
-            Option::<ArcTimer>::None,
+            Executor::default(),
+            Timer::default(),
         );
         let key1 = host_key("foo");
         let key2 = host_key("bar");