Determine failures to find poetry envs (#100)

Author: DonJayamanne

crates/pet-core/src/telemetry/missing_poetry_info.rs

@@ -0,0 +1,35 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+use serde::{Deserialize, Serialize};
+
+/// Telemetry sent when
+/// 1. We are able to spawn poetry
+/// 2. We have found some new envs after spawning poetry
+#[derive(Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+#[derive(Debug, Clone, Copy)]
+pub struct MissingPoetryEnvironments {
+    /// Total number of missing envs.
+    pub missing: u16,
+    /// Total number of missing envs, where the envs are created in the virtualenvs_path directory.
+    pub missing_in_path: u16,
+    /// Whether the user provided a executable.
+    pub user_provided_poetry_exe: Option<bool>,
+    /// Whether we managed to find the poetry exe or not.
+    pub poetry_exe_not_found: Option<bool>,
+    /// Whether we failed to find the global config file.
+    pub global_config_not_found: Option<bool>,
+    /// Whether the cache-dir returned by Poetry exe was not found by us
+    /// This indicated the fact that we are unable to parse the poetry config file or something else.
+    pub cache_dir_not_found: Option<bool>,
+    /// Whether the cache-dir we found is different from what is returned by Poetry exe
+    pub cache_dir_is_different: Option<bool>,
+    /// Whether the virtualenvs path returned by Poetry exe was not found by us
+    /// This indicated the fact that we are unable to parse the poetry config file or something else.
+    pub virtualenvs_path_not_found: Option<bool>,
+    /// Whether the virtualenvs_path we found is different from what is returned by Poetry exe
+    pub virtualenvs_path_is_different: Option<bool>,
+    /// Whether the virtualenvs.in-project setting value is differnt from what is returned by Poetry exe
+    pub in_project_is_different: Option<bool>,
+}

crates/pet-core/src/telemetry/mod.rs

@@ -3,10 +3,12 @@
 
 use inaccurate_python_info::InaccuratePythonEnvironmentInfo;
 use missing_conda_info::MissingCondaEnvironments;
+use missing_poetry_info::MissingPoetryEnvironments;
 use serde::{Deserialize, Serialize};
 
 pub mod inaccurate_python_info;
 pub mod missing_conda_info;
+pub mod missing_poetry_info;
 
 pub type NumberOfCustomSearchPaths = u32;
 
@@ -30,6 +32,8 @@ pub enum TelemetryEvent {
     InaccuratePythonEnvironmentInfo(InaccuratePythonEnvironmentInfo),
     /// Sent when an environment is discovered by spawning conda and not found otherwise.
     MissingCondaEnvironments(MissingCondaEnvironments),
+    /// Sent when an environment is discovered by spawning poetry and not found otherwise.
+    MissingPoetryEnvironments(MissingPoetryEnvironments),
 }
 
 pub fn get_telemetry_event_name(event: &TelemetryEvent) -> &'static str {
@@ -47,5 +51,6 @@ pub fn get_telemetry_event_name(event: &TelemetryEvent) -> &'static str {
         TelemetryEvent::SearchCompleted(_) => "SearchCompleted",
         TelemetryEvent::InaccuratePythonEnvironmentInfo(_) => "InaccuratePythonEnvironmentInfo",
         TelemetryEvent::MissingCondaEnvironments(_) => "MissingCondaEnvironments",
+        TelemetryEvent::MissingPoetryEnvironments(_) => "MissingPoetryEnvironments",
     }
 }

crates/pet-poetry/src/config.rs

@@ -17,24 +17,28 @@ static _APP_NAME: &str = "pypoetry";
 pub struct Config {
     pub virtualenvs_in_project: Option<bool>,
     pub virtualenvs_path: PathBuf,
+    pub cache_dir: Option<PathBuf>,
     pub file: Option<PathBuf>,
 }
 
 impl Config {
     fn new(
         file: Option<PathBuf>,
         virtualenvs_path: PathBuf,
+        cache_dir: Option<PathBuf>,
         virtualenvs_in_project: Option<bool>,
     ) -> Self {
         trace!(
-            "Poetry config file => {:?}, virtualenv.path => {:?}, virtualenvs_in_project => {:?}",
+            "Poetry config file => {:?}, virtualenv.path => {:?}, cache_dir => {:?}, virtualenvs_in_project => {:?}",
             file,
             virtualenvs_path,
+            cache_dir,
             virtualenvs_in_project
         );
         Config {
             file,
             virtualenvs_path,
+            cache_dir,
             virtualenvs_in_project,
         }
     }
@@ -54,44 +58,79 @@ impl Config {
 
 fn create_config(file: Option<PathBuf>, env: &EnvVariables) -> Option<Config> {
     let cfg = file.clone().and_then(|f| parse(&f));
+    let cache_dir = get_cache_dir(&cfg, env);
+    let virtualenvs_path_from_env_var = env
+        .poetry_virtualenvs_path
+        .clone()
+        .map(|p| resolve_virtualenvs_path(&p, &cache_dir));
+
     if let Some(virtualenvs_path) = &cfg.clone().and_then(|cfg| cfg.virtualenvs_path) {
-        let mut virtualenvs_path = virtualenvs_path.clone();
         trace!("Poetry virtualenvs path => {:?}", virtualenvs_path);
-        if virtualenvs_path
-            .to_string_lossy()
-            .to_lowercase()
-            .contains("{cache-dir}")
-        {
-            if let Some(cache_dir) = &get_default_cache_dir(env) {
-                virtualenvs_path = PathBuf::from(
-                    virtualenvs_path
-                        .to_string_lossy()
-                        .replace("{cache-dir}", cache_dir.to_string_lossy().as_ref()),
-                );
-                trace!(
-                    "Poetry virtualenvs path after replacing cache-dir => {:?}",
-                    virtualenvs_path
-                );
-            }
-        }
+        let virtualenvs_path = resolve_virtualenvs_path(&virtualenvs_path.clone(), &cache_dir);
 
         return Some(Config::new(
             file.clone(),
-            virtualenvs_path.clone(),
+            // Give preference to the virtualenvs path from the env var
+            virtualenvs_path_from_env_var.unwrap_or(virtualenvs_path.clone()),
+            cache_dir,
             cfg.and_then(|cfg| cfg.virtualenvs_in_project),
         ));
     }
 
-    get_default_cache_dir(env)
-        .map(|cache_dir| Config::new(file, cache_dir.join("virtualenvs"), None))
+    // Give preference to the virtualenvs path from the env var
+    if let Some(virtualenvs_path_from_env_var) = virtualenvs_path_from_env_var {
+        if virtualenvs_path_from_env_var.exists() {
+            return Some(Config::new(
+                file,
+                virtualenvs_path_from_env_var,
+                cache_dir,
+                cfg.and_then(|cfg| cfg.virtualenvs_in_project),
+            ));
+        }
+    }
+
+    cache_dir
+        .map(|cache_dir| Config::new(file, cache_dir.join("virtualenvs"), Some(cache_dir), None))
+}
+
+/// Replaces {cache-dir} in virtualenvs path with the cache dir
+fn resolve_virtualenvs_path(virtualenvs_path: &Path, cache_dir: &Option<PathBuf>) -> PathBuf {
+    if virtualenvs_path
+        .to_string_lossy()
+        .to_lowercase()
+        .contains("{cache-dir}")
+    {
+        if let Some(cache_dir) = &cache_dir {
+            let virtualenvs_path = PathBuf::from(
+                virtualenvs_path
+                    .to_string_lossy()
+                    .replace("{cache-dir}", cache_dir.to_string_lossy().as_ref()),
+            );
+            trace!(
+                "Poetry virtualenvs path after replacing cache-dir => {:?}",
+                virtualenvs_path
+            );
+            return virtualenvs_path;
+        }
+    }
+    virtualenvs_path.to_path_buf()
 }
 /// Maps to DEFAULT_CACHE_DIR in poetry
-fn get_default_cache_dir(env: &EnvVariables) -> Option<PathBuf> {
+fn get_cache_dir(cfg: &Option<ConfigToml>, env: &EnvVariables) -> Option<PathBuf> {
+    // Cache dir in env variables takes precedence
     if let Some(cache_dir) = env.poetry_cache_dir.clone() {
-        Some(cache_dir)
-    } else {
-        Platformdirs::new(_APP_NAME.into(), false).user_cache_path()
+        if cache_dir.is_dir() {
+            return Some(cache_dir);
+        }
+    }
+    // Check cache dir in config.
+    if let Some(cache_dir) = cfg.as_ref().and_then(|cfg| cfg.cache_dir.clone()) {
+        if cache_dir.is_dir() {
+            return Some(cache_dir);
+        }
     }
+
+    Platformdirs::new(_APP_NAME.into(), false).user_cache_path()
 }
 
 /// Maps to CONFIG_DIR in poetry
@@ -105,7 +144,7 @@ fn get_config_dir(env: &EnvVariables) -> Option<PathBuf> {
     Platformdirs::new(_APP_NAME.into(), true).user_config_path()
 }
 
-fn find_config_file(env: &EnvVariables) -> Option<PathBuf> {
+pub fn find_config_file(env: &EnvVariables) -> Option<PathBuf> {
     let config_dir = get_config_dir(env)?;
     let file = config_dir.join("config.toml");
     if file.exists() {

crates/pet-poetry/src/env_variables.rs

@@ -13,6 +13,8 @@ pub struct EnvVariables {
     pub root: Option<PathBuf>,
     /// Maps to env var `APPDATA`
     pub app_data: Option<PathBuf>,
+    /// Maps to env var `POETRY_VIRTUALENVS_PATH`
+    pub poetry_virtualenvs_path: Option<PathBuf>,
     /// Maps to env var `POETRY_HOME`
     pub poetry_home: Option<PathBuf>,
     /// Maps to env var `POETRY_CONFIG_DIR`
@@ -46,6 +48,9 @@ impl EnvVariables {
             path: env.get_env_var("PATH".to_string()),
             root: env.get_root(),
             app_data: env.get_env_var("APPDATA".to_string()).map(PathBuf::from),
+            poetry_virtualenvs_path: env
+                .get_env_var("POETRY_VIRTUALENVS_PATH".to_string())
+                .map(PathBuf::from),
             poetry_cache_dir: env
                 .get_env_var("POETRY_CACHE_DIR".to_string())
                 .map(PathBuf::from),

crates/pet-poetry/src/environment_locations.rs

@@ -122,21 +122,21 @@ fn should_use_local_venv_as_poetry_env(
     local: &Option<Config>,
     env: &EnvVariables,
 ) -> bool {
-    // Give preference to setting in local config file.
-    if let Some(poetry_virtualenvs_in_project) =
-        local.clone().and_then(|c| c.virtualenvs_in_project)
-    {
+    // Given preference to env variable.
+    if let Some(poetry_virtualenvs_in_project) = env.poetry_virtualenvs_in_project {
         trace!(
-            "Poetry virtualenvs_in_project from local config file: {}",
+            "Poetry virtualenvs_in_project from Env Variable: {}",
             poetry_virtualenvs_in_project
         );
         return poetry_virtualenvs_in_project;
     }
 
-    // Given preference to env variable.
-    if let Some(poetry_virtualenvs_in_project) = env.poetry_virtualenvs_in_project {
+    // Give preference to setting in local config file.
+    if let Some(poetry_virtualenvs_in_project) =
+        local.clone().and_then(|c| c.virtualenvs_in_project)
+    {
         trace!(
-            "Poetry virtualenvs_in_project from Env Variable: {}",
+            "Poetry virtualenvs_in_project from local config file: {}",
             poetry_virtualenvs_in_project
         );
         return poetry_virtualenvs_in_project;

crates/pet-poetry/src/environment_locations_spawn.rs

@@ -16,12 +16,12 @@ lazy_static! {
 
 pub fn list_environments(
     executable: &PathBuf,
-    project_dirs: Vec<PathBuf>,
+    project_dirs: &Vec<PathBuf>,
     manager: &PoetryManager,
 ) -> Vec<PythonEnvironment> {
     let mut envs = vec![];
     for project_dir in project_dirs {
-        if let Some(project_envs) = get_environments(executable, &project_dir) {
+        if let Some(project_envs) = get_environments(executable, project_dir) {
             for project_env in project_envs {
                 if let Some(env) =
                     create_poetry_env(&project_env, project_dir.clone(), Some(manager.clone()))
@@ -81,3 +81,72 @@ fn get_environments(executable: &PathBuf, project_dir: &PathBuf) -> Option<Vec<P
         }
     }
 }
+
+#[derive(Clone, Debug)]
+pub struct PoetryConfig {
+    pub cache_dir: Option<PathBuf>,
+    pub virtualenvs_in_project: Option<bool>,
+    pub virtualenvs_path: Option<PathBuf>,
+}
+
+pub fn get_config(executable: &PathBuf, project_dir: &PathBuf) -> PoetryConfig {
+    let cache_dir = get_config_path(executable, project_dir, "cache-dir");
+    let virtualenvs_path = get_config_path(executable, project_dir, "virtualenvs.path");
+    let virtualenvs_in_project = get_config_bool(executable, project_dir, "virtualenvs.in-project");
+    PoetryConfig {
+        cache_dir,
+        virtualenvs_in_project,
+        virtualenvs_path,
+    }
+}
+
+fn get_config_bool(executable: &PathBuf, project_dir: &PathBuf, setting: &str) -> Option<bool> {
+    match get_config_value(executable, project_dir, setting) {
+        Some(output) => {
+            let output = output.trim();
+            if output.starts_with("true") {
+                Some(true)
+            } else if output.starts_with("false") {
+                Some(false)
+            } else {
+                None
+            }
+        }
+        None => None,
+    }
+}
+fn get_config_path(executable: &PathBuf, project_dir: &PathBuf, setting: &str) -> Option<PathBuf> {
+    get_config_value(executable, project_dir, setting).map(|output| PathBuf::from(output.trim()))
+}
+
+fn get_config_value(executable: &PathBuf, project_dir: &PathBuf, setting: &str) -> Option<String> {
+    let start = SystemTime::now();
+    let result = std::process::Command::new(executable)
+        .arg("config")
+        .arg(setting)
+        .current_dir(project_dir)
+        .output();
+    trace!(
+        "Executed Poetry ({}ms): {executable:?} config {setting} {project_dir:?}",
+        start.elapsed().unwrap_or_default().as_millis(),
+    );
+    match result {
+        Ok(output) => {
+            if output.status.success() {
+                Some(String::from_utf8_lossy(&output.stdout).to_string())
+            } else {
+                let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+                trace!(
+                    "Failed to get Poetry config {setting} using exe {executable:?} in {project_dir:?}, due to ({}) {}",
+                    output.status.code().unwrap_or_default(),
+                    stderr
+                );
+                None
+            }
+        }
+        Err(err) => {
+            error!("Failed to execute Poetry env list {:?}", err);
+            None
+        }
+    }
+}