Method discover

lib/dsc-lib/src/discovery/command_discovery.rs:214–351

(&mut self, kind: &DiscoveryKind, filter: &TypeNameFilter)

    #[allow(clippy::too_many_lines)]
    fn discover(&mut self, kind: &DiscoveryKind, filter: &TypeNameFilter) -> Result<(), DscError> {
        if self.discovery_mode == ResourceDiscoveryMode::PreDeployment && !locked_is_empty!(RESOURCES) {
            return Ok(());
        } else if self.discovery_mode == ResourceDiscoveryMode::DuringDeployment {
            locked_clear!(RESOURCES);
            locked_clear!(ADAPTERS);
        }

        // if kind is DscResource, we need to discover extensions first
        if *kind == DiscoveryKind::Resource && (self.discovery_mode == ResourceDiscoveryMode::DuringDeployment || locked_is_empty!(EXTENSIONS)){
            self.discover(&DiscoveryKind::Extension, &TypeNameFilter::default())?;
        }

        info!("{}", t!("discovery.commandDiscovery.discoverResources", kind = kind : {:?}, filter = filter.to_string()));

        debug!("Using type name filter '{filter}' for adapter name");
        let mut progress = ProgressBar::new(1, self.progress_format)?;
        match kind {
            DiscoveryKind::Resource => {
                progress.write_activity(t!("discovery.commandDiscovery.progressSearching").to_string().as_str());
            },
            DiscoveryKind::Extension => {
                progress.write_activity(t!("discovery.commandDiscovery.extensionSearching").to_string().as_str());
            }
        }

        let mut adapters = DiscoveryResourceCache::new();
        let mut resources = DiscoveryResourceCache::new();
        let mut extensions = DiscoveryExtensionCache::new();

        if let Ok(paths) = CommandDiscovery::get_resource_paths() {
            for path in paths {
                if path.exists() && path.is_dir() {
                    for entry in path.read_dir().unwrap() {
                        let entry = entry.unwrap();
                        let path = entry.path();
                        if path.is_file() {
                            let Some(os_file_name) = path.file_name() else {
                                // skip if not a file
                                continue;
                            };
                            let Some(file_name) = os_file_name.to_str() else {
                                // skip if not a valid file name
                                continue;
                            };
                            let file_name_lowercase = file_name.to_lowercase();
                            if DSC_MANIFEST_LIST_EXTENSIONS.iter().any(|ext| file_name_lowercase.ends_with(ext)) ||
                                (kind == &DiscoveryKind::Resource && (DSC_RESOURCE_EXTENSIONS.iter().any(|ext| file_name_lowercase.ends_with(ext))) || DSC_ADAPTED_RESOURCE_EXTENSIONS.iter().any(|ext| file_name_lowercase.ends_with(ext))) ||
                                (kind == &DiscoveryKind::Extension && DSC_EXTENSION_EXTENSIONS.iter().any(|ext| file_name_lowercase.ends_with(ext))) {
                                trace!("{}", t!("discovery.commandDiscovery.foundManifest", path = path.to_string_lossy()));
                                let imported_manifests = match load_manifest(&path)
                                {
                                    Ok(r) => r,
                                    Err(e) => {
                                        // At this point we can't determine whether or not the bad manifest contains
                                        // resource that is requested by resource/config operation
                                        // if it is, then "ResouceNotFound" error will be issued later
                                        // and here we just write as info