Method find_resources

lib/dsc-lib/src/discovery/command_discovery.rs:482–539

(&mut self, required_resource_types: &[DiscoveryFilter])

    }

    fn find_resources(&mut self, required_resource_types: &[DiscoveryFilter]) -> Result<DiscoveryResourceCache, DscError> {
        debug!("{}", t!("discovery.commandDiscovery.searchingForResources", resources = required_resource_types : {:?}));
        if self.discovery_mode == ResourceDiscoveryMode::DuringDeployment || locked_is_empty!(RESOURCES) {
            self.discover(&DiscoveryKind::Resource, &TypeNameFilter::default())?;
        }
        let mut found_resources = DiscoveryResourceCache::new();
        let mut required_resources = HashMap::<DiscoveryFilter, bool>::new();
        for filter in required_resource_types {
            required_resources.insert(filter.clone(), false);
        }

        for filter in required_resource_types {
            if let Some(resources) = locked_get!(RESOURCES, filter.resource_type()) {
                filter_resources(&mut found_resources, &mut required_resources, &resources, filter);
            }
            if required_resources.values().all(|&v| v) {
                break;
            }
        }
        debug!("{}", t!("discovery.commandDiscovery.foundNonAdapterResources", count = found_resources.len()));

        if required_resources.values().all(|&v| v) {
            return Ok(found_resources);
        }

        // store the keys of the ADAPTERS into a vec
        let mut adapters: Vec<FullyQualifiedTypeName> = locked_clone!(ADAPTERS).keys().cloned().collect();
        // sort the adapters by ones specified in the required resources first

        for filter in required_resource_types {
            if let Some(required_adapter) = filter.require_adapter() {
                if !adapters.contains(required_adapter) {
                    return Err(DscError::AdapterNotFound(required_adapter.to_string()));
                }
                // otherwise insert at the front of the list
                adapters.retain(|a| a != required_adapter);
                adapters.insert(0, required_adapter.clone());
            }
        }

        for adapter_name in &adapters {
            self.discover_adapted_resources(&TypeNameFilter::default(), &adapter_name.clone().into())?;
            add_resources_to_lookup_table(&locked_clone!(ADAPTED_RESOURCES));
            for filter in required_resource_types {
                if let Some(adapted_resources) = locked_get!(ADAPTED_RESOURCES, filter.resource_type()) {
                    filter_resources(&mut found_resources, &mut required_resources, &adapted_resources, filter);
                }
                if required_resources.values().all(|&v| v) {
                    break;
                }
            }
            if required_resources.values().all(|&v| v) {
                break;
            }
        }

        Ok(found_resources)
    }