Clear cache request

Author: DonJayamanne

crates/pet-core/src/lib.rs

@@ -33,6 +33,8 @@ pub struct Configuration {
     /// These are different from search_paths, as these are specific directories where environments are expected.
     /// environment_directories on the other hand can be any directory such as a workspace folder, where envs might never exist.
     pub environment_directories: Option<Vec<PathBuf>>,
+    /// Directory to cache the Python environment details.
+    pub cache_directory: Option<PathBuf>,
 }
 
 pub trait Locator: Send + Sync {

crates/pet-poetry/src/lib.rs

@@ -3,6 +3,7 @@
 
 use env_variables::EnvVariables;
 use environment_locations::list_environments;
+use log::trace;
 use manager::PoetryManager;
 use pet_core::{
     env::PythonEnv,
@@ -69,6 +70,7 @@ impl Poetry {
             self.poetry_executable.lock().unwrap().clone(),
             &self.env_vars,
         );
+        trace!("Poetry Manager {:?}", manager);
         let mut result = LocatorResult {
             managers: vec![],
             environments: vec![],

crates/pet-pyenv/src/lib.rs

@@ -4,15 +4,13 @@
 use std::{
     fs,
     path::PathBuf,
-    sync::{
-        atomic::{AtomicBool, Ordering},
-        Arc, Mutex,
-    },
+    sync::{Arc, Mutex},
     thread,
 };
 
 use env_variables::EnvVariables;
 use environments::{get_generic_python_environment, get_virtual_env_environment};
+use log::trace;
 use manager::PyEnvInfo;
 use pet_conda::{utils::is_conda_env, CondaLocator};
 use pet_core::{
@@ -33,7 +31,6 @@ mod manager;
 pub struct PyEnv {
     pub env_vars: EnvVariables,
     pub conda_locator: Arc<dyn CondaLocator>,
-    found_pyenv: AtomicBool,
     manager: Arc<Mutex<Option<EnvManager>>>,
     versions_dir: Arc<Mutex<Option<PathBuf>>>,
 }
@@ -44,24 +41,22 @@ impl PyEnv {
         conda_locator: Arc<dyn CondaLocator>,
     ) -> impl Locator {
         PyEnv {
-            found_pyenv: AtomicBool::new(false),
             env_vars: EnvVariables::from(environment),
             conda_locator,
             manager: Arc::new(Mutex::new(None)),
             versions_dir: Arc::new(Mutex::new(None)),
         }
     }
     fn clear(&self) {
-        self.found_pyenv
-            .store(false, std::sync::atomic::Ordering::Relaxed);
         self.manager.lock().unwrap().take();
         self.versions_dir.lock().unwrap().take();
     }
     fn get_manager_versions_dir(&self) -> (Option<EnvManager>, Option<PathBuf>) {
         let mut managers = self.manager.lock().unwrap();
         let mut versions = self.versions_dir.lock().unwrap();
-        if !self.found_pyenv.load(Ordering::Relaxed) && (managers.is_none() || versions.is_none()) {
+        if managers.is_none() || versions.is_none() {
             let pyenv_info = PyEnvInfo::from(&self.env_vars);
+            trace!("PyEnv Info {:?}", pyenv_info);
             if let Some(ref exe) = pyenv_info.exe {
                 let version = pyenv_info.version.clone();
                 let manager = EnvManager::new(exe.clone(), EnvManagerType::Pyenv, version);
@@ -74,9 +69,7 @@ impl PyEnv {
             } else {
                 versions.take();
             }
-            self.found_pyenv.store(true, Ordering::Relaxed);
         }
-
         (managers.clone(), versions.clone())
     }
 }
@@ -164,6 +157,8 @@ impl Locator for PyEnv {
                     }
                 }
             });
+        } else {
+            trace!("PyEnv versions directory not found");
         }
     }
 }

crates/pet-python-utils/src/fs_cache.rs

@@ -114,9 +114,9 @@ mod tests {
     fn test_hash_generation() {
         assert_eq!(
             generate_hash(&PathBuf::from(
-                &"C:\\temp\\poetry-folders\\demo-project1".into(),
+                "C:\\temp\\poetry-folders\\demo-project1".to_string(),
             )),
-            "e72c82125e7281e2"
+            "c3694bfb39d7065b"
         );
     }
 }

crates/pet/src/find.rs

@@ -78,7 +78,13 @@ pub fn find_and_report_envs(
                         let summary = summary.clone();
                         s.spawn(move || {
                             let start = std::time::Instant::now();
+                            trace!("Searching using locator: {}", locator.get_name());
                             locator.find(reporter);
+                            trace!(
+                                "Completed searching using locator: {} in {:?}",
+                                locator.get_name(),
+                                start.elapsed()
+                            );
                             summary
                                 .lock()
                                 .unwrap()

crates/pet/src/jsonrpc.rs

@@ -76,6 +76,7 @@ pub fn start_jsonrpc_server() {
     handlers.add_request_handler("resolve", handle_resolve);
     handlers.add_request_handler("find", handle_find);
     handlers.add_request_handler("condaInfo", handle_conda_telemetry);
+    handlers.add_request_handler("clearCache", handle_clear_cache);
     start_server(&handlers)
 }
 
@@ -106,7 +107,8 @@ pub fn handle_configure(context: Arc<Context>, id: u32, params: Value) {
                 // We will not support changing the cache directories once set.
                 // No point, supporting such a use case.
                 if let Some(cache_directory) = configure_options.cache_directory {
-                    set_cache_directory(cache_directory)
+                    set_cache_directory(cache_directory.clone());
+                    cfg.cache_directory = Some(cache_directory);
                 }
                 trace!("Configuring locators: {:?}", cfg);
                 drop(cfg);
@@ -370,3 +372,29 @@ pub fn handle_conda_telemetry(context: Arc<Context>, id: u32, _params: Value) {
         send_reply(id, info.into());
     });
 }
+
+pub fn handle_clear_cache(context: Arc<Context>, id: u32, _params: Value) {
+    thread::spawn(move || {
+        if let Some(cache_directory) = context
+            .configuration
+            .read()
+            .unwrap()
+            .cache_directory
+            .clone()
+        {
+            if let Err(e) = std::fs::remove_dir_all(&cache_directory) {
+                error!("Failed to clear cache {:?}: {}", cache_directory, e);
+                send_error(
+                    Some(id),
+                    -4,
+                    format!("Failed to clear cache {:?}: {}", cache_directory, e),
+                );
+            } else {
+                info!("Cleared cache {:?}", cache_directory);
+                send_reply(id, None::<()>);
+            }
+        } else {
+            send_reply(id, None::<()>);
+        }
+    });
+}

crates/pet/tests/ci_poetry.rs

@@ -2,10 +2,7 @@
 // Licensed under the MIT License.
 
 use pet_poetry::Poetry;
-use pet_reporter::{
-    cache::{self, CacheReporter},
-    collect,
-};
+use pet_reporter::{cache::CacheReporter, collect};
 
 mod common;
 

crates/pet/tests/ci_test.rs

@@ -17,10 +17,7 @@ use pet_core::{
 };
 use pet_env_var_path::get_search_paths_from_env_variables;
 use pet_poetry::Poetry;
-use pet_reporter::{
-    cache::{self, CacheReporter},
-    collect,
-};
+use pet_reporter::{cache::CacheReporter, collect};
 use regex::Regex;
 use serde::Deserialize;
 
@@ -226,6 +223,7 @@ fn check_if_pyenv_virtualenv_exists() {
     let environment = EnvironmentApi::new();
     let conda_locator = Arc::new(Conda::from(&environment));
     let poetry_locator = Arc::new(Poetry::from(&environment));
+    trace!("Checking for pyenv-virtualenv");
 
     find_and_report_envs(
         &CacheReporter::new(reporter.clone()),