max size of 100k for fast cache

src/main.rs

@@ -49,8 +49,8 @@ async fn main() -> std::io::Result<()> {
     let mut requester = util::requester::Requester::new();
     requester.set_proxy(env::var("PROXY").unwrap_or("0".to_string()) != "0".to_string());
 
-    let cache: util::cache::VideoCache = crate::util::cache::VideoCache::new();
+    let cache: util::cache::VideoCache = crate::util::cache::VideoCache::new().max_size(100_000).to_owned();
-
+    
     thread::spawn(move || {
             // Create a tiny runtime just for these async tasks
             let rt = tokio::runtime::Builder::new_current_thread()

src/util/cache.rs

@@ -1,22 +1,28 @@
-use std::time::{SystemTime};
+use std::time::SystemTime;
 
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
-
 use crate::videos::VideoItem;
 
 #[derive(Clone)]
-pub struct VideoCache{
+pub struct VideoCache {
-    cache: Arc<Mutex<std::collections::HashMap<String, (SystemTime, Vec<VideoItem>)>>>,    // url -> time+Items
+    cache: Arc<Mutex<std::collections::HashMap<String, (SystemTime, Vec<VideoItem>)>>>, // url -> time+Items
+    max_size: usize,
 }
 impl VideoCache {
     pub fn new() -> Self {
         VideoCache {
             cache: Arc::new(Mutex::new(std::collections::HashMap::new())),
+            max_size: 100,
         }
     }
 
+    pub fn max_size(&mut self, size: usize) -> &mut Self {
+        self.max_size = size;
+        self
+    }
+
     pub fn get(&self, key: &str) -> Option<(SystemTime, Vec<VideoItem>)> {
         let cache = self.cache.lock().ok()?;
         cache.get(key).cloned()
@@ -24,14 +30,22 @@ impl VideoCache {
 
     pub fn insert(&self, key: String, value: Vec<VideoItem>) {
         if let Ok(mut cache) = self.cache.lock() {
+            if cache.len() >= self.max_size {
+                // Simple eviction policy: remove a random entry
+                if let Some(first_key) = cache.keys().next().cloned() {
+                    cache.remove(&first_key);
+                }
+            }
             cache.insert(key.clone(), (SystemTime::now(), value.clone()));
         }
     }
+
     pub fn remove(&self, key: &str) {
         if let Ok(mut cache) = self.cache.lock() {
             cache.remove(key);
         }
     }
+    
     pub fn entries(&self) -> Option<Vec<(String, (SystemTime, Vec<VideoItem>))>> {
         if let Ok(cache) = self.cache.lock() {
             // Return a cloned vector of the cache entries
@@ -40,20 +54,24 @@ impl VideoCache {
         None
     }
 
-    pub async fn check(&self) -> Result<(), Box<dyn std::error::Error>>{
+    pub async fn check(&self) -> Result<(), Box<dyn std::error::Error>> {
-            let iter = match self.entries(){
+        let iter = match self.entries() {
-                Some(iter) => iter,
+            Some(iter) => iter,
-                None => return Err(Box::new(std::io::Error::new(std::io::ErrorKind::Other, "Could not get entries")))
+            None => {
-            };
+                return Err(Box::new(std::io::Error::new(
+                    std::io::ErrorKind::Other,
+                    "Could not get entries",
+                )));
+            }
+        };
 
-            for (key, (time, _items)) in iter {
+        for (key, (time, _items)) in iter {
-                if let Ok(elapsed) = time.elapsed() {
+            if let Ok(elapsed) = time.elapsed() {
-                    if elapsed > Duration::from_secs(60*60){
+                if elapsed > Duration::from_secs(60 * 60) {
-                        self.remove(&key);
+                    self.remove(&key);
-                    }
                 }
             }
-            Ok(())
+        }
+        Ok(())
     }
-    
+}
-}