Identify and report conda envs not found (#97)

Author: DonJayamanne

crates/pet-conda/src/conda_info.rs

@@ -9,14 +9,14 @@ use std::path::PathBuf;
 pub struct CondaInfo {
     pub executable: PathBuf,
     pub envs: Vec<PathBuf>,
-    pub conda_prefix: PathBuf,
+    pub conda_prefix: Option<PathBuf>,
     pub conda_version: String,
     pub envs_dirs: Vec<PathBuf>,
-    pub envs_path: Vec<PathBuf>,
     pub config_files: Vec<PathBuf>,
     pub rc_path: Option<PathBuf>,
     pub sys_rc_path: Option<PathBuf>,
     pub user_rc_path: Option<PathBuf>,
+    pub root_prefix: Option<PathBuf>,
 }
 
 #[derive(Debug, serde::Deserialize)]
@@ -25,11 +25,13 @@ pub struct CondaInfoJson {
     pub conda_prefix: Option<PathBuf>,
     pub conda_version: Option<String>,
     pub envs_dirs: Option<Vec<PathBuf>>,
+    /// This is an alias for envs_dirs
     pub envs_path: Option<Vec<PathBuf>>,
     pub config_files: Option<Vec<PathBuf>>,
     pub rc_path: Option<PathBuf>,
     pub user_rc_path: Option<PathBuf>,
     pub sys_rc_path: Option<PathBuf>,
+    pub root_prefix: Option<PathBuf>,
 }
 
 impl CondaInfo {
@@ -47,23 +49,34 @@ impl CondaInfo {
             .arg("info")
             .arg("--json")
             .output();
-        trace!("Executing Conda: {:?} info --json", executable);
+        trace!("Executing Conda: {:?} info --json -a", executable);
         match result {
             Ok(output) => {
                 if output.status.success() {
                     let output = String::from_utf8_lossy(&output.stdout).to_string();
                     match serde_json::from_str::<CondaInfoJson>(output.trim()) {
                         Ok(info) => {
+                            let envs_path = info
+                                .envs_path
+                                .unwrap_or_default()
+                                .drain(..)
+                                .collect::<Vec<PathBuf>>();
+                            let mut envs_dirs = info
+                                .envs_dirs
+                                .unwrap_or_default()
+                                .drain(..)
+                                .collect::<Vec<PathBuf>>();
+                            envs_dirs.extend(envs_path);
                             let info = CondaInfo {
                                 executable: executable.clone(),
                                 envs: info.envs.unwrap_or_default().drain(..).collect(),
-                                conda_prefix: info.conda_prefix.unwrap_or_default(),
+                                conda_prefix: info.conda_prefix,
+                                root_prefix: info.root_prefix,
                                 rc_path: info.rc_path,
                                 sys_rc_path: info.sys_rc_path,
                                 user_rc_path: info.user_rc_path,
+                                envs_dirs,
                                 conda_version: info.conda_version.unwrap_or_default(),
-                                envs_dirs: info.envs_dirs.unwrap_or_default().drain(..).collect(),
-                                envs_path: info.envs_path.unwrap_or_default().drain(..).collect(),
                                 config_files: info
                                     .config_files
                                     .unwrap_or_default()

crates/pet-conda/src/conda_rc.rs

@@ -5,6 +5,7 @@ use crate::env_variables::EnvVariables;
 use log::trace;
 use pet_fs::path::expand_path;
 use std::{
+    collections::HashSet,
     fs,
     path::{Path, PathBuf},
 };
@@ -93,11 +94,19 @@ fn get_conda_rc_search_paths(env_vars: &EnvVariables) -> Vec<PathBuf> {
             PathBuf::from(conda_prefix.clone()).join(".condarc.d"),
         ]);
     }
+    if let Some(ref conda_dir) = env_vars.conda_dir {
+        search_paths.append(&mut vec![
+            PathBuf::from(conda_dir.clone()).join(".condarc"),
+            PathBuf::from(conda_dir.clone()).join("condarc"),
+            PathBuf::from(conda_dir.clone()).join(".condarc.d"),
+        ]);
+    }
     if let Some(ref condarc) = env_vars.condarc {
         search_paths.append(&mut vec![PathBuf::from(condarc)]);
     }
 
-    search_paths
+    let search_paths: HashSet<_> = search_paths.into_iter().collect();
+    search_paths.into_iter().collect()
 }
 
 // https://github.com/conda/conda/blob/3ae5d7cf6cbe2b0ff9532359456b7244ae1ea5ef/conda/common/configuration.py#L1315

crates/pet-conda/src/env_variables.rs

@@ -18,6 +18,8 @@ pub struct EnvVariables {
     pub programdata: Option<String>,
     pub homedrive: Option<String>,
     pub conda_root: Option<String>,
+    /// https://github.com/jupyter/docker-stacks/issues/1086
+    pub conda_dir: Option<String>,
     pub conda: Option<String>,
     pub conda_prefix: Option<String>,
     /// https://docs.conda.io/projects/conda/en/22.11.x/user-guide/configuration/use-condarc.html
@@ -37,6 +39,7 @@ impl EnvVariables {
             allusersprofile: env.get_env_var("ALLUSERSPROFILE".to_string()),
             programdata: env.get_env_var("PROGRAMDATA".to_string()),
             homedrive: env.get_env_var("HOMEDRIVE".to_string()),
+            conda_dir: env.get_env_var("CONDA_DIR".to_string()),
             conda_root: env.get_env_var("CONDA_ROOT".to_string()),
             conda: env.get_env_var("CONDA".to_string()),
             conda_prefix: env.get_env_var("CONDA_PREFIX".to_string()),

crates/pet-conda/src/environment_locations.rs

@@ -302,6 +302,9 @@ pub fn get_known_conda_install_locations(env_vars: &EnvVariables) -> Vec<PathBuf
     if let Some(ref conda_prefix) = env_vars.conda_prefix {
         known_paths.push(expand_path(PathBuf::from(conda_prefix.clone())));
     }
+    if let Some(ref conda_dir) = env_vars.conda_dir {
+        known_paths.push(expand_path(PathBuf::from(conda_dir.clone())));
+    }
     if let Some(ref conda) = env_vars.conda {
         known_paths.push(expand_path(PathBuf::from(conda)));
     }

crates/pet-conda/src/environments.rs

@@ -77,7 +77,7 @@ pub fn get_conda_environment_info(
     }
     // If we know the conda install folder, then we can use it.
     let mut conda_install_folder = match manager {
-        Some(manager) => Some(manager.conda_dir.clone()),
+        Some(manager) => manager.conda_dir.clone(),
         None => get_conda_installation_used_to_create_conda_env(env_path),
     };
     if let Some(conda_dir) = &conda_install_folder {

crates/pet-conda/src/lib.rs

@@ -5,7 +5,7 @@ use conda_info::CondaInfo;
 use env_variables::EnvVariables;
 use environment_locations::{get_conda_environment_paths, get_environments};
 use environments::{get_conda_environment_info, CondaEnvironment};
-use log::{error, warn};
+use log::error;
 use manager::CondaManager;
 use pet_core::{
     os_environment::Environment,
@@ -20,6 +20,7 @@ use std::{
     sync::{Arc, Mutex},
     thread,
 };
+use telemetry::report_missing_envs;
 use utils::{is_conda_env, is_conda_install};
 
 mod conda_info;
@@ -29,11 +30,16 @@ pub mod environment_locations;
 pub mod environments;
 pub mod manager;
 pub mod package;
+mod telemetry;
 pub mod utils;
 
 pub trait CondaLocator: Send + Sync {
     fn find_in(&self, path: &Path) -> Option<LocatorResult>;
-    fn find_with_conda_executable(&self, conda_executable: Option<PathBuf>) -> Option<()>;
+    fn find_and_report_missing_envs(
+        &self,
+        reporter: &dyn Reporter,
+        conda_executable: Option<PathBuf>,
+    ) -> Option<()>;
 }
 pub struct Conda {
     /// Directories where conda environments are found (env_dirs returned from `conda info --json`)
@@ -55,11 +61,29 @@ impl Conda {
 }
 
 impl CondaLocator for Conda {
-    fn find_with_conda_executable(&self, conda_executable: Option<PathBuf>) -> Option<()> {
-        let info = CondaInfo::from(conda_executable)?;
-        // Have we seen these envs, if yes, then nothing to do
+    fn find_and_report_missing_envs(
+        &self,
+        reporter: &dyn Reporter,
+        conda_executable: Option<PathBuf>,
+    ) -> Option<()> {
+        // Look for environments that we couldn't find without spawning conda.
+        let user_provided_conda_exe = conda_executable.is_some();
+        let conda_info = CondaInfo::from(conda_executable)?;
+
+        // Keep track of these directories for next refresh
+        // This way we can search these directories again and they will be reported.
+        {
+            let mut env_dirs = self.env_dirs.lock().unwrap();
+            env_dirs.append(&mut conda_info.envs_dirs.clone());
+            conda_info.envs_dirs.iter().for_each(|p| {
+                if !env_dirs.contains(p) {
+                    env_dirs.push(p.clone());
+                }
+            });
+        }
+
         let environments = self.environments.lock().unwrap().clone();
-        let mut new_envs = info
+        let new_envs = conda_info
             .envs
             .clone()
             .into_iter()
@@ -68,61 +92,57 @@ impl CondaLocator for Conda {
         if new_envs.is_empty() {
             return None;
         }
+        let environments = environments
+            .into_values()
+            .collect::<Vec<PythonEnvironment>>();
 
-        // Oh oh, we have new envs, lets find them.
-        let manager = CondaManager::from_info(&info.executable, &info)?;
-        for path in new_envs.iter() {
-            let mgr = manager.clone();
-            if let Some(env) = get_conda_environment_info(path, &Some(mgr.clone())) {
-                warn!(
-                    "Found a conda env {:?} using the conda exe {:?}",
-                    env.prefix, info.executable
-                );
-            }
-        }
-
-        // Also keep track of these directories for next time
-        let mut env_dirs = self.env_dirs.lock().unwrap();
-        env_dirs.append(&mut new_envs);
-
-        // Send telemetry
+        let _ = report_missing_envs(
+            reporter,
+            &self.env_vars,
+            &new_envs,
+            &environments,
+            &conda_info,
+            user_provided_conda_exe,
+        );
 
         Some(())
     }
+
     fn find_in(&self, conda_dir: &Path) -> Option<LocatorResult> {
         if !is_conda_install(conda_dir) {
             return None;
         }
         if let Some(manager) = CondaManager::from(conda_dir) {
-            let conda_dir = manager.conda_dir.clone();
-            // Keep track to search again later.
-            // Possible we'll find environments in other directories created using this manager
-            let mut managers = self.managers.lock().unwrap();
-            // Keep track to search again later.
-            // Possible we'll find environments in other directories created using this manager
-            managers.insert(conda_dir.clone(), manager.clone());
-            drop(managers);
+            if let Some(conda_dir) = manager.conda_dir.clone() {
+                // Keep track to search again later.
+                // Possible we'll find environments in other directories created using this manager
+                let mut managers = self.managers.lock().unwrap();
+                // Keep track to search again later.
+                // Possible we'll find environments in other directories created using this manager
+                managers.insert(conda_dir.clone(), manager.clone());
+                drop(managers);
 
-            let mut new_environments = vec![];
+                let mut new_environments = vec![];
 
-            // Find all the environments in the conda install folder. (under `envs` folder)
-            for conda_env in
-                get_conda_environments(&get_environments(&conda_dir), &manager.clone().into())
-            {
-                let mut environments = self.environments.lock().unwrap();
-                if environments.contains_key(&conda_env.prefix) {
-                    continue;
+                // Find all the environments in the conda install folder. (under `envs` folder)
+                for conda_env in
+                    get_conda_environments(&get_environments(&conda_dir), &manager.clone().into())
+                {
+                    let mut environments = self.environments.lock().unwrap();
+                    if environments.contains_key(&conda_env.prefix) {
+                        continue;
+                    }
+                    let env = conda_env
+                        .to_python_environment(Some(conda_dir.clone()), Some(manager.to_manager()));
+                    environments.insert(conda_env.prefix.clone(), env.clone());
+                    new_environments.push(env);
                 }
-                let env = conda_env
-                    .to_python_environment(Some(conda_dir.clone()), Some(manager.to_manager()));
-                environments.insert(conda_env.prefix.clone(), env.clone());
-                new_environments.push(env);
-            }
 
-            return Some(LocatorResult {
-                environments: new_environments,
-                managers: vec![manager.to_manager()],
-            });
+                return Some(LocatorResult {
+                    environments: new_environments,
+                    managers: vec![manager.to_manager()],
+                });
+            }
         }
         None
     }
@@ -279,7 +299,7 @@ impl Locator for Conda {
                     // 5. Report this env.
                     if let Some(manager) = manager {
                         let env = env.to_python_environment(
-                            Some(manager.conda_dir.clone()),
+                            manager.conda_dir.clone(),
                             Some(manager.to_manager()),
                         );
                         let mut environments = self.environments.lock().unwrap();

crates/pet-conda/src/manager.rs

@@ -61,7 +61,7 @@ pub fn find_conda_binary(env_vars: &EnvVariables) -> Option<PathBuf> {
 pub struct CondaManager {
     pub executable: PathBuf,
     pub version: Option<String>,
-    pub conda_dir: PathBuf,
+    pub conda_dir: Option<PathBuf>,
 }
 
 impl CondaManager {
@@ -108,7 +108,7 @@ fn get_conda_manager(path: &Path) -> Option<CondaManager> {
         Some(CondaManager {
             executable: conda_exe,
             version: Some(conda_pkg.version),
-            conda_dir: path.to_path_buf(),
+            conda_dir: Some(path.to_path_buf()),
         })
     } else {
         None