Method list_available

lib/dsc-lib/src/discovery/mod.rs:60–103

List operation for getting available resources based on the filters. # Arguments `kind` - The kind of discovery (e.g., Resource). `type_name_filter` - The filter for the resource type name. `adapter_name_filter` - The filter for the adapter name. # Returns A vector of `DscResource` instances.

(
        &mut self,
        kind: &DiscoveryKind,
        type_name_filter: &TypeNameFilter,
        adapter_name_filter: Option<&TypeNameFilter>,
        progress_format: ProgressFormat
    )

    ///
    /// A vector of `DscResource` instances.
    pub fn list_available(
        &mut self,
        kind: &DiscoveryKind,
        type_name_filter: &TypeNameFilter,
        adapter_name_filter: Option<&TypeNameFilter>,
        progress_format: ProgressFormat
    ) -> Vec<ImportedManifest> {
        let discovery_types: Vec<Box<dyn ResourceDiscovery>> = vec![
            Box::new(command_discovery::CommandDiscovery::new(progress_format)),
        ];

        let mut resources: BTreeMap<String, ImportedManifest> = BTreeMap::new();

        for mut discovery_type in discovery_types {

            let discovered_resources = match discovery_type.list_available(kind, type_name_filter, adapter_name_filter) {
                Ok(value) => value,
                Err(err) => {
                    error!("{err}");
                    continue;
                }
            };

            for (_resource_name, found_resources) in discovered_resources {
                for manifest in found_resources {
                    let key = match &manifest {
                        ImportedManifest::Resource(resource) => {
                            format!("{}@{}", resource.type_name.to_lowercase(), resource.version)
                        },
                        ImportedManifest::Extension(extension) => {
                            format!("{}@{}", extension.type_name.to_lowercase(), extension.version)
                        }
                    };
                    resources.insert(key, manifest);
                }
            };

            if let Ok(extensions) = discovery_type.get_extensions() {
                self.extensions.extend(extensions);
            }
        }

        resources.into_values().collect::<Vec<ImportedManifest>>()
    }

    pub fn get_extensions(&mut self, capability: &Capability) -> Vec<DscExtension> {
        if self.extensions.is_empty() {