extracting cache struct

perryqh · perryqh · commit 1295e9190663 · 2024-11-13T21:44:12.000-06:00
diff --git a/src/cache/mod.rs b/src/cache/mod.rs
@@ -0,0 +1,113 @@
+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,
+};
+
+pub trait Cache {
+    fn get_file_owner(&self, path: &Path) -> Result<Option<FileOwnerCacheEntry>, Error>;
+    fn write_file_owner(&self, path: &Path, owner: Option<String>);
+}
+
+#[derive(Debug)]
+pub struct GlobalCache<'a> {
+    base_path: &'a PathBuf,
+    cache_directory: &'a String,
+    file_owner_cache: Option<Box<Mutex<HashMap<PathBuf, FileOwnerCacheEntry>>>>,
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+pub struct FileOwnerCacheEntry {
+    timestamp: u64,
+    pub owner: Option<String>,
+}
+
+const DEFAULT_CACHE_CAPACITY: usize = 10000;
+
+impl<'a> GlobalCache<'a> {
+    pub fn new(base_path: &'a PathBuf, cache_directory: &'a String) -> Self {
+        Self {
+            base_path,
+            cache_directory,
+            file_owner_cache: None,
+        }
+    }
+
+    pub 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)
+    }
+
+    pub 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(())
+    }
+
+    pub 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 = Self::get_file_timestamp(path)?;
+                if cached_entry.timestamp == timestamp {
+                    return Ok(Some(cached_entry.clone()));
+                }
+            }
+        }
+        Ok(None)
+    }
+
+    pub 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) = Self::get_file_timestamp(path) {
+                cache.insert(path.to_path_buf(), FileOwnerCacheEntry { timestamp, owner });
+            }
+        }
+    }
+
+    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")
+    }
+
+    pub 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)
+    }
+
+    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())
+    }
+}
diff --git a/src/cli.rs b/src/cli.rs
@@ -1,5 +1,7 @@
 use clap::{Parser, Subcommand};
 use codeowners::{
+    cache::GlobalCache,
+    config::Config,
     ownership::{FileOwner, Ownership},
     project_builder::ProjectBuilder,
 };
@@ -98,12 +100,23 @@ pub fn cli() -> Result<(), Error> {
         .change_context(Error::Io)
         .attach_printable(format!("Can't open config file: {}", config_path.to_string_lossy()))?;
 
-    let config = serde_yaml::from_reader(config_file).change_context(Error::Io)?;
+    let config: Config = serde_yaml::from_reader(config_file).change_context(Error::Io)?;
 
-    let mut project_builder = ProjectBuilder::new(&config, project_root, codeowners_file_path.clone(), !args.no_cache);
+    let mut global_cache = GlobalCache::new(&project_root, &config.cache_directory);
+    global_cache.load_cache().change_context(Error::Io)?;
+
+    let mut project_builder = ProjectBuilder::new(
+        &config,
+        project_root.clone(),
+        codeowners_file_path.clone(),
+        !args.no_cache,
+        &global_cache,
+    );
     let project = project_builder.build().change_context(Error::Io)?;
     let ownership = Ownership::build(project);
 
+    global_cache.persist_cache().change_context(Error::Io)?;
+
     match args.command {
         Command::Validate => ownership.validate().change_context(Error::ValidationFailed)?,
         Command::Generate => {
@@ -140,7 +153,7 @@ pub fn cli() -> Result<(), Error> {
             Err(err) => println!("{}", err),
         },
         Command::DeleteCache => {
-            project_builder.delete_cache().change_context(Error::Io)?;
+            global_cache.delete_cache().change_context(Error::Io)?;
         }
     }
 
diff --git a/src/common_test.rs b/src/common_test.rs
@@ -10,7 +10,7 @@ pub mod tests {
 
     use tempfile::tempdir;
 
-    use crate::{ownership::Ownership, project_builder::ProjectBuilder};
+    use crate::{cache::GlobalCache, config::Config, ownership::Ownership, project_builder::ProjectBuilder};
 
     macro_rules! ownership {
         ($($test_files:expr),+) => {{
@@ -107,17 +107,30 @@ pub mod tests {
         }
 
         let config_file = File::open(test_config.temp_dir_path.join(test_config.relative_code_ownership_config_yml_path))?;
-        let config = serde_yaml::from_reader(config_file)?;
+        let config: Config = serde_yaml::from_reader(config_file)?;
 
         let codeowners_file_path = &test_config.temp_dir_path.join(".github/CODEOWNERS");
-        let mut builder = ProjectBuilder::new(&config, test_config.temp_dir_path.clone(), codeowners_file_path.clone(), false);
+        let global_cache = GlobalCache::new(&test_config.temp_dir_path, &config.cache_directory);
+        let mut builder = ProjectBuilder::new(
+            &config,
+            test_config.temp_dir_path.clone(),
+            codeowners_file_path.clone(),
+            false,
+            &global_cache,
+        );
         let project = builder.build()?;
         let ownership = Ownership::build(project);
         if test_config.generate_codeowners {
             std::fs::write(codeowners_file_path, ownership.generate_file())?;
         }
         // rebuild project to ensure new codeowners file is read
-        let mut builder = ProjectBuilder::new(&config, test_config.temp_dir_path.clone(), codeowners_file_path.clone(), false);
+        let mut builder = ProjectBuilder::new(
+            &config,
+            test_config.temp_dir_path.clone(),
+            codeowners_file_path.clone(),
+            false,
+            &global_cache,
+        );
         let project = builder.build()?;
         Ok(Ownership::build(project))
     }
diff --git a/src/lib.rs b/src/lib.rs
@@ -1,5 +1,6 @@
+pub mod cache;
 pub(crate) mod common_test;
-pub(crate) mod config;
+pub mod config;
 pub mod ownership;
 pub(crate) mod project;
 pub mod project_builder;
diff --git a/src/project_builder.rs b/src/project_builder.rs
@@ -10,6 +10,7 @@ use rayon::iter::{IntoParallelIterator, ParallelIterator};
 use tracing::instrument;
 
 use crate::{
+    cache::GlobalCache,
     config::Config,
     project::{deserializers, DirectoryCodeownersFile, Error, Package, PackageType, Project, ProjectFile, Team, VendoredGem},
     project_file_builder::ProjectFileBuilder,
@@ -38,8 +39,14 @@ pub struct ProjectBuilder<'a> {
 const INITIAL_VECTOR_CAPACITY: usize = 1000;
 
 impl<'a> ProjectBuilder<'a> {
-    pub fn new(config: &'a Config, base_path: PathBuf, codeowners_file_path: PathBuf, use_cache: bool) -> Self {
-        let project_file_builder = ProjectFileBuilder::new(config, base_path.clone(), use_cache);
+    pub fn new(
+        config: &'a Config,
+        base_path: PathBuf,
+        codeowners_file_path: PathBuf,
+        use_cache: bool,
+        global_cache: &'a GlobalCache,
+    ) -> Self {
+        let project_file_builder = ProjectFileBuilder::new(use_cache, global_cache);
         Self {
             project_file_builder,
             config,
@@ -59,13 +66,7 @@ impl<'a> ProjectBuilder<'a> {
             let entry = entry.change_context(Error::Io)?;
             entry_types.push(self.build_entry_type(entry)?);
         }
-        let project = self.build_project_from_entry_types(entry_types);
-        self.project_file_builder.possibly_save_cache()?;
-        project
-    }
-
-    pub fn delete_cache(&mut self) -> Result<(), Error> {
-        self.project_file_builder.delete_cache()
+        self.build_project_from_entry_types(entry_types)
     }
 
     fn build_entry_type(&mut self, entry: ignore::DirEntry) -> Result<EntryType, Error> {
diff --git a/src/project_file_builder.rs b/src/project_file_builder.rs
