fix tlru race condition

The previous implementation would crash when accessing entries that were
about to be removed.

Author: vilgotf

Cargo.lock

@@ -5,7 +5,6 @@ name = "twilight-http-proxy"
 version = "0.1.0"
 
 [dependencies]
-dashmap = "6"
 http = "1"
 http-body-util = "0.1"
 hyper = { version = "1", default-features = false }

Cargo.toml

@@ -23,6 +23,7 @@ use std::{
     env,
     error::Error,
     net::{Ipv4Addr, SocketAddrV4},
+    num::NonZero,
     pin::pin,
     str::FromStr,
     sync::Arc,
@@ -88,7 +89,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
     let ratelimiter_map = Arc::new(RatelimiterMap::new(
         env::var("DISCORD_TOKEN")?,
         Duration::from_secs(parse_env("CLIENT_DECAY_TIMEOUT")?.unwrap_or(3600)),
-        parse_env("CLIENT_CACHE_MAX_SIZE")?,
+        parse_env("CLIENT_CACHE_MAX_SIZE")?.unwrap_or(NonZero::<usize>::MAX),
     ));
 
     let host = parse_env("HOST")?.unwrap_or(Ipv4Addr::UNSPECIFIED);

src/main.rs

@@ -1,4 +1,5 @@
-use crate::tlru::{Builder, Tlru};
+use crate::tlru::Tlru;
+use std::num::NonZero;
 use tokio::time::Duration;
 use twilight_http_ratelimiting::RateLimiter;
 
@@ -9,7 +10,7 @@ pub struct RatelimiterMap {
 }
 
 impl RatelimiterMap {
-    pub fn new(mut default_token: String, timeout: Duration, max_size: Option<usize>) -> Self {
+    pub fn new(mut default_token: String, timeout: Duration, cap: NonZero<usize>) -> Self {
         let is_bot = default_token.starts_with("Bot ");
         let is_bearer = default_token.starts_with("Bearer ");
 
@@ -19,13 +20,7 @@ impl RatelimiterMap {
             default_token.insert_str(0, "Bot ");
         }
 
-        let mut builder = Builder::new().expiration(timeout);
-
-        if let Some(max_size) = max_size {
-            builder = builder.max_size(max_size);
-        }
-
-        let inner = builder.build();
+        let inner = Tlru::new(cap, timeout);
 
         let default = RateLimiter::default();
 
@@ -41,13 +36,13 @@ impl RatelimiterMap {
             if token == self.default_token {
                 (self.default.clone(), self.default_token.clone())
             } else if let Some(entry) = self.inner.get(token) {
-                (entry.value().clone(), token.to_string())
+                (entry, token.to_owned())
             } else {
                 let ratelimiter = RateLimiter::default();
 
-                self.inner.insert(token.to_string(), ratelimiter.clone());
+                self.inner.insert(token.to_owned(), ratelimiter.clone());
 
-                (ratelimiter, token.to_string())
+                (ratelimiter, token.to_owned())
             }
         } else {
             (self.default.clone(), self.default_token.clone())