feat(storcaching): Implement cleanup

For now there is no hysteresis even, but thats fine for now,
at least we will not crash on no disk space.

Signed-off-by: Denys Fedoryshchenko <denys.f@collabora.com>

Author: nuclearcat

src/storcaching.rs

@@ -8,16 +8,20 @@ struct Files {
     last_update: SystemTime,
 }
 
-async fn read_files() -> Vec<Files> {
+async fn read_filesinfo(cache_dir: String) -> Vec<Files> {
     let mut files = Vec::new();
-    let paths = fs::read_dir(".");
+    let paths = fs::read_dir(&cache_dir);
     match paths {
         Ok(paths) => {
             for path in paths {
                 let path = path.unwrap().path();
                 let file = path.to_str().unwrap().to_string();
                 let metadata = fs::metadata(&file).unwrap();
                 let last_update = metadata.modified().unwrap();
+                // is this file ending with ".content"?
+                if !file.ends_with(".content") {
+                    continue;
+                }
                 files.push(Files { file, last_update });
             }
             files
@@ -51,15 +55,53 @@ async fn freediskspace_percent(cache_dir: String) -> u64 {
     percent as u64
 }
 
+fn delete_cache_file(file: String) {
+    // Truncate from filename .content, and add .headers, delete both files
+    let content_filename = file.clone();
+    let headers_filename = file.replace(".content", ".headers");
+    println!("Deleting files: {} {}", &content_filename, &headers_filename);
+    let res = fs::remove_file(&content_filename);
+    match res {
+        Ok(_) => {}
+        Err(_) => {
+            println!("Error deleting file: {}", content_filename);
+        }
+    }
+    let res = fs::remove_file(&headers_filename);
+    match res {
+        Ok(_) => {}
+        Err(_) => {
+            println!("Error deleting file: {}", headers_filename);
+        }
+    }
+}
+
+async fn clean_disk(cache_dir: String) {
+    let files = read_filesinfo(cache_dir).await;
+    let mut oldest_file = Files {
+        file: "".to_string(),
+        last_update: SystemTime::now(),
+    };
+    for file in files {
+        if file.last_update < oldest_file.last_update {
+            oldest_file = file;
+        }
+    }
+    delete_cache_file(oldest_file.file);
+}
+
 pub async fn cache_loop(cache_dir: &str) {
     loop {
         let free_space = freediskspace_percent(cache_dir.to_string()).await;
         if free_space < 10 {
             println!("Low disk space: {}%", free_space);
+            clean_disk(cache_dir.to_string()).await;
+            // critical mode, sleep only 100ms
+            tokio::time::sleep(Duration::from_millis(100)).await;
         } else {
             println!("Free disk space: {}%", free_space);
+            // sleep for 10 seconds before checking again
+            tokio::time::sleep(Duration::from_secs(10)).await;
         }
-        // sleep for 10 seconds
-        tokio::time::sleep(Duration::from_secs(10)).await;       
     }
 }