Cache project files (#45)

* extracting project-file-builder

* caching with timestamp

* adding no-cache flag

* verifying cache deletion

* extracting cache struct

* introducing cache trait

* adding enum_dispatch

* adding run_benchmarks.sh for hyperfine tests

Author: perryqh

Cargo.lock

@@ -1,21 +1,24 @@
 [package]
 name = "codeowners"
-version = "0.2.1"
+version = "0.2.2"
 edition = "2021"
 
 [profile.release]
 debug = true
 
+[lib]
+path = "src/lib.rs"
+
 [dependencies]
 clap = { version = "4.5.20", features = ["derive"] }
 clap_derive = "4.5.18"
 error-stack = "0.5.0"
+enum_dispatch = "0.3.13"
 fast-glob = "0.4.0"
 ignore = "0.4.23"
 itertools = "0.13.0"
-path-clean = "1.0.1"
 lazy_static = "1.5.0"
-num_cpus = "1.16.0"
+path-clean = "1.0.1"
 rayon = "1.10.0"
 regex = "1.11.1"
 serde = { version = "1.0.214", features = ["derive"] }
@@ -27,6 +30,7 @@ tracing-subscriber = { version = "0.3.18", features = ["env-filter"] }
 
 [dev-dependencies]
 assert_cmd = "2.0.16"
+glob = "0.3.1"
 rusty-hook = "^0.11.2"
 predicates = "3.1.2"
 pretty_assertions = "1.4.1" # Shows a more readable diff when comparing objects

Cargo.toml

@@ -0,0 +1,12 @@
+#!/bin/bash
+
+# Check if the file exists before removing it
+if [ -f "tmp/codeowners_benchmarks.md" ]; then
+  rm tmp/codeowners_benchmarks.md
+fi
+
+echo "To run these benchmarks on your application, you can place this repo next to your rails application and run bash ../rubyatscale/codeowners-rs/dev/run_benchmarks.sh from the root of your application" >> tmp/codeowners_benchmarks.md
+
+hyperfine --warmup=2 --runs=3 --export-markdown tmp/codeowners_benchmarks.md \
+  '../rubyatscale/codeowners-rs/target/release/codeowners gv' \
+  'bin/codeowners-rs gv' 

dev/run_benchmarks.sh

@@ -0,0 +1,173 @@
+use crate::project::Error;
+use error_stack::{Result, ResultExt};
+use std::{
+    collections::HashMap,
+    fs::{self, File, OpenOptions},
+    io::{BufReader, BufWriter},
+    path::{Path, PathBuf},
+    sync::Mutex,
+};
+
+use super::{Caching, FileOwnerCacheEntry};
+
+#[derive(Debug)]
+pub struct GlobalCache {
+    base_path: PathBuf,
+    cache_directory: String,
+    file_owner_cache: Option<Box<Mutex<HashMap<PathBuf, FileOwnerCacheEntry>>>>,
+}
+
+const DEFAULT_CACHE_CAPACITY: usize = 10000;
+
+impl Caching for GlobalCache {
+    fn get_file_owner(&self, path: &Path) -> Result<Option<FileOwnerCacheEntry>, Error> {
+        if let Ok(cache) = self.file_owner_cache.as_ref().unwrap().lock() {
+            if let Some(cached_entry) = cache.get(path) {
+                let timestamp = get_file_timestamp(path)?;
+                if cached_entry.timestamp == timestamp {
+                    return Ok(Some(cached_entry.clone()));
+                }
+            }
+        }
+        Ok(None)
+    }
+
+    fn write_file_owner(&self, path: &Path, owner: Option<String>) {
+        if let Ok(mut cache) = self.file_owner_cache.as_ref().unwrap().lock() {
+            if let Ok(timestamp) = get_file_timestamp(path) {
+                cache.insert(path.to_path_buf(), FileOwnerCacheEntry { timestamp, owner });
+            }
+        }
+    }
+
+    fn persist_cache(&self) -> Result<(), Error> {
+        let cache_path = self.get_cache_path();
+        let file = OpenOptions::new()
+            .write(true)
+            .create(true)
+            .truncate(true)
+            .open(cache_path)
+            .change_context(Error::Io)?;
+
+        let writer = BufWriter::new(file);
+        let cache = self.file_owner_cache.as_ref().unwrap().lock().map_err(|_| Error::Io)?;
+        serde_json::to_writer(writer, &*cache).change_context(Error::SerdeJson)
+    }
+
+    fn delete_cache(&self) -> Result<(), Error> {
+        let cache_path = self.get_cache_path();
+        dbg!("deleting", &cache_path);
+        fs::remove_file(cache_path).change_context(Error::Io)
+    }
+}
+
+impl GlobalCache {
+    pub fn new(base_path: PathBuf, cache_directory: String) -> Result<Self, Error> {
+        let mut cache = Self {
+            base_path,
+            cache_directory,
+            file_owner_cache: None,
+        };
+        cache.load_cache().change_context(Error::Io)?;
+        Ok(cache)
+    }
+
+    fn load_cache(&mut self) -> Result<(), Error> {
+        let cache_path = self.get_cache_path();
+        if !cache_path.exists() {
+            self.file_owner_cache = Some(Box::new(Mutex::new(HashMap::with_capacity(DEFAULT_CACHE_CAPACITY))));
+            return Ok(());
+        }
+
+        let file = File::open(cache_path).change_context(Error::Io)?;
+        let reader = BufReader::new(file);
+        let json = serde_json::from_reader(reader);
+        self.file_owner_cache = match json {
+            Ok(cache) => Some(Box::new(Mutex::new(cache))),
+            _ => Some(Box::new(Mutex::new(HashMap::with_capacity(DEFAULT_CACHE_CAPACITY)))),
+        };
+        Ok(())
+    }
+
+    fn get_cache_path(&self) -> PathBuf {
+        let cache_dir = self.base_path.join(PathBuf::from(&self.cache_directory));
+        fs::create_dir_all(&cache_dir).unwrap();
+
+        cache_dir.join("project-file-cache.json")
+    }
+}
+fn get_file_timestamp(path: &Path) -> Result<u64, Error> {
+    let metadata = fs::metadata(path).change_context(Error::Io)?;
+    metadata
+        .modified()
+        .change_context(Error::Io)?
+        .duration_since(std::time::UNIX_EPOCH)
+        .change_context(Error::Io)
+        .map(|duration| duration.as_secs())
+}
+
+#[cfg(test)]
+mod tests {
+    use tempfile::tempdir;
+
+    use super::*;
+
+    #[test]
+    fn test_cache_dir() -> Result<(), Error> {
+        let temp_dir = tempdir().change_context(Error::Io)?;
+        let cache_dir = "test-codeowners-cache";
+        let cache = GlobalCache::new(temp_dir.path().to_path_buf(), cache_dir.to_owned())?;
+
+        let file_path = PathBuf::from("tests/fixtures/valid_project/ruby/app/models/bank_account.rb");
+        assert!(file_path.exists());
+        let timestamp = get_file_timestamp(&file_path)?;
+
+        let cache_entry = cache.get_file_owner(&file_path)?;
+        assert_eq!(cache_entry, None);
+
+        cache.write_file_owner(&file_path, Some("owner 1".to_owned()));
+        let cache_entry = cache.get_file_owner(&file_path)?;
+        assert_eq!(
+            cache_entry,
+            Some(FileOwnerCacheEntry {
+                timestamp,
+                owner: Some("owner 1".to_owned())
+            })
+        );
+
+        cache.persist_cache().change_context(Error::Io)?;
+        let persisted_cache_path = cache.get_cache_path();
+        assert!(persisted_cache_path.exists());
+
+        let cache = GlobalCache::new(temp_dir.path().to_path_buf(), cache_dir.to_owned())?;
+        let cache_entry = cache.get_file_owner(&file_path)?;
+        assert_eq!(
+            cache_entry,
+            Some(FileOwnerCacheEntry {
+                timestamp,
+                owner: Some("owner 1".to_owned())
+            })
+        );
+
+        cache.delete_cache().change_context(Error::Io)?;
+        assert!(!persisted_cache_path.exists());
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_corrupted_cache() -> Result<(), Error> {
+        let temp_dir = tempdir().change_context(Error::Io)?;
+        let cache_dir = "test-codeowners-cache";
+        let cache = GlobalCache::new(temp_dir.path().to_path_buf(), cache_dir.to_owned())?;
+        let cache_path = cache.get_cache_path();
+        fs::write(cache_path, "corrupted_cache").change_context(Error::Io)?;
+
+        // When the cache is corrupted, it should be ignored and a new cache should be created
+        let cache = GlobalCache::new(temp_dir.path().to_path_buf(), cache_dir.to_owned())?;
+        let file_path = PathBuf::from("tests/fixtures/valid_project/ruby/app/models/bank_account.rb");
+        let cache_entry = cache.get_file_owner(&file_path)?;
+        assert_eq!(cache_entry, None);
+        Ok(())
+    }
+}

src/cache/file.rs

@@ -0,0 +1,29 @@
+use crate::project::Error;
+use enum_dispatch::enum_dispatch;
+use error_stack::Result;
+use file::GlobalCache;
+use noop::NoopCache;
+use std::path::Path;
+
+pub mod file;
+pub mod noop;
+
+#[enum_dispatch]
+pub enum Cache {
+    GlobalCache,
+    NoopCache,
+}
+
+#[enum_dispatch(Cache)]
+pub trait Caching {
+    fn get_file_owner(&self, path: &Path) -> Result<Option<FileOwnerCacheEntry>, Error>;
+    fn write_file_owner(&self, path: &Path, owner: Option<String>);
+    fn persist_cache(&self) -> Result<(), Error>;
+    fn delete_cache(&self) -> Result<(), Error>;
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, PartialEq)]
+pub struct FileOwnerCacheEntry {
+    timestamp: u64,
+    pub owner: Option<String>,
+}

src/cache/mod.rs

@@ -0,0 +1,26 @@
+use crate::project::Error;
+use error_stack::Result;
+use std::path::Path;
+
+use super::{Caching, FileOwnerCacheEntry};
+
+#[derive(Default)]
+pub struct NoopCache {}
+
+impl Caching for NoopCache {
+    fn get_file_owner(&self, _path: &Path) -> Result<Option<FileOwnerCacheEntry>, Error> {
+        Ok(None)
+    }
+
+    fn write_file_owner(&self, _path: &Path, _owner: Option<String>) {
+        // noop
+    }
+
+    fn persist_cache(&self) -> Result<(), Error> {
+        Ok(())
+    }
+
+    fn delete_cache(&self) -> Result<(), Error> {
+        Ok(())
+    }
+}