Add static memory cache for discovered resources

Author: Steve Lee (POWERSHELL HE/HIM) (from Dev Box)

dsc_lib/src/discovery/command_discovery.rs

@@ -1,7 +1,13 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-use crate::discovery::discovery_trait::{DiscoveryFilter, DiscoveryKind, ResourceDiscovery};
+use crate::discovery::{
+    command_discovery_cache::{
+        get_adapted_resource, get_adapted_resources, get_adapters, get_extensions, get_resource, get_resources, resources_is_empty,
+        adapters_is_empty, extensions_is_empty, extend_adapted_resources, extend_adapters, extend_extensions, extend_resources
+    },
+    discovery_trait::{DiscoveryFilter, DiscoveryKind, ResourceDiscovery}
+};
 use crate::dscresources::dscresource::{Capability, DscResource, ImplementedAs};
 use crate::dscresources::resource_manifest::{import_manifest, validate_semver, Kind, ResourceManifest, SchemaKind};
 use crate::dscresources::command_resource::invoke_command;
@@ -36,13 +42,9 @@ pub enum ImportedManifest {
     Extension(DscExtension),
 }
 
+
 #[derive(Clone)]
 pub struct CommandDiscovery {
-    // use BTreeMap so that the results are sorted by the typename, the Vec is sorted by version
-    adapters: BTreeMap<String, Vec<DscResource>>,
-    resources: BTreeMap<String, Vec<DscResource>>,
-    extensions: BTreeMap<String, DscExtension>,
-    adapted_resources: BTreeMap<String, Vec<DscResource>>,
     progress_format: ProgressFormat,
 }
 
@@ -72,17 +74,13 @@ impl CommandDiscovery {
     #[must_use]
     pub fn new(progress_format: ProgressFormat) -> CommandDiscovery {
         CommandDiscovery {
-            adapters: BTreeMap::new(),
-            resources: BTreeMap::new(),
-            extensions: BTreeMap::new(),
-            adapted_resources: BTreeMap::new(),
             progress_format,
         }
     }
 
     #[must_use]
-    pub fn get_extensions(&self) -> &BTreeMap<String, DscExtension> {
-        &self.extensions
+    pub fn get_extensions(&self) -> BTreeMap<String, DscExtension> {
+        get_extensions()
     }
 
     fn get_resource_path_setting() -> Result<ResourcePathSetting, DscError>
@@ -307,7 +305,7 @@ impl ResourceDiscovery for CommandDiscovery {
         match kind {
             DiscoveryKind::Resource => {
                 // Now we need to call discover extensions and add those resource to the list of resources
-                for extension in self.extensions.values() {
+                for extension in get_extensions().values() {
                     if extension.capabilities.contains(&ExtensionCapability::Discover) {
                         debug!("{}", t!("discovery.commandDiscovery.callingExtension", extension = extension.type_name));
                         let discovered_resources = extension.discover()?;
@@ -320,26 +318,27 @@ impl ResourceDiscovery for CommandDiscovery {
                         }
                     }
                 }
-                self.adapters = adapters;
-                self.resources = resources;
+                extend_adapters(adapters);
+                extend_resources(resources);
             },
             DiscoveryKind::Extension => {
-                self.extensions = extensions;
+                extend_extensions(extensions);
             }
         }
 
         Ok(())
     }
 
     fn discover_adapted_resources(&mut self, name_filter: &str, adapter_filter: &str) -> Result<(), DscError> {
-        if self.resources.is_empty() && self.adapters.is_empty() {
+        if resources_is_empty() && adapters_is_empty() {
             self.discover(&DiscoveryKind::Resource, "*")?;
         }
 
-        if self.adapters.is_empty() {
+        if adapters_is_empty() {
             return Ok(());
         }
 
+        let adapters = get_adapters();
         let regex_str = convert_wildcard_to_regex(adapter_filter);
         debug!("Using regex {regex_str} as filter for adapter name");
         let mut regex_builder = RegexBuilder::new(&regex_str);
@@ -356,13 +355,13 @@ impl ResourceDiscovery for CommandDiscovery {
             return Err(DscError::Operation("Could not build Regex filter for resource name".to_string()));
         };
 
-        let mut progress = ProgressBar::new(self.adapters.len() as u64, self.progress_format)?;
+        let mut progress = ProgressBar::new(adapters.len() as u64, self.progress_format)?;
         progress.write_activity("Searching for adapted resources");
 
         let mut adapted_resources = BTreeMap::<String, Vec<DscResource>>::new();
 
         let mut found_adapter: bool = false;
-        for (adapter_name, adapters) in &self.adapters {
+        for (adapter_name, adapters) in &adapters {
             for adapter in adapters {
                 progress.write_increment(1);
 
@@ -431,7 +430,7 @@ impl ResourceDiscovery for CommandDiscovery {
             return Err(DscError::AdapterNotFound(adapter_filter.to_string()));
         }
 
-        self.adapted_resources = adapted_resources;
+        extend_adapted_resources(adapted_resources);
 
         Ok(())
     }
@@ -441,26 +440,27 @@ impl ResourceDiscovery for CommandDiscovery {
         if *kind == DiscoveryKind::Resource {
             if adapter_name_filter.is_empty() {
                 self.discover(kind, type_name_filter)?;
-                for (resource_name, resources_vec) in &self.resources {
+                for (resource_name, resources_vec) in &get_resources() {
                     resources.insert(resource_name.clone(), resources_vec.iter().map(|r| ImportedManifest::Resource(r.clone())).collect());
                 }
-                for (adapter_name, adapter_vec) in &self.adapters {
+                for (adapter_name, adapter_vec) in &get_adapters() {
                     resources.insert(adapter_name.clone(), adapter_vec.iter().map(|r| ImportedManifest::Resource(r.clone())).collect());
                 }
             } else {
                 self.discover(kind, "*")?;
                 self.discover_adapted_resources(type_name_filter, adapter_name_filter)?;
 
                 // add/update found adapted resources to the lookup_table
-                add_resources_to_lookup_table(&self.adapted_resources);
+                let adapted_resources = get_adapted_resources();
+                add_resources_to_lookup_table(&adapted_resources);
 
-                for (adapted_name, adapted_vec) in &self.adapted_resources {
+                for (adapted_name, adapted_vec) in &adapted_resources {
                     resources.insert(adapted_name.clone(), adapted_vec.iter().map(|r| ImportedManifest::Resource(r.clone())).collect());
                 }
             }
         } else {
             self.discover(kind, type_name_filter)?;
-            for (extension_name, extension) in &self.extensions {
+            for (extension_name, extension) in &get_extensions() {
                 resources.insert(extension_name.clone(), vec![ImportedManifest::Extension(extension.clone())]);
             }
         }
@@ -470,16 +470,18 @@ impl ResourceDiscovery for CommandDiscovery {
 
     fn find_resources(&mut self, required_resource_types: &[DiscoveryFilter]) -> Result<BTreeMap<String, Vec<DscResource>>, DscError> {
         debug!("{}", t!("discovery.commandDiscovery.searchingForResources", resources = required_resource_types : {:?}));
-        self.discover( &DiscoveryKind::Resource, "*")?;
+        if resources_is_empty() {
+            self.discover( &DiscoveryKind::Resource, "*")?;
+        }
         let mut found_resources = BTreeMap::<String, Vec<DscResource>>::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) = self.resources.get(filter.resource_type()) {
-                filter_resources(&mut found_resources, &mut required_resources, resources, filter);
+            if let Some(resources) = get_resource(filter.resource_type()) {
+                filter_resources(&mut found_resources, &mut required_resources, &resources, filter);
             }
             if required_resources.values().all(|&v| v) {
                 break;
@@ -492,12 +494,12 @@ impl ResourceDiscovery for CommandDiscovery {
         }
 
         // now go through the adapters, this is for implicit adapters so version can't be specified so use latest version
-        for adapter_name in self.adapters.clone().keys() {
+        for adapter_name in get_adapters().keys() {
             self.discover_adapted_resources("*", adapter_name)?;
-            add_resources_to_lookup_table(&self.adapted_resources);
+            add_resources_to_lookup_table(&get_adapted_resources());
             for filter in required_resource_types {
-                if let Some(adapted_resources) = self.adapted_resources.get(filter.resource_type()) {
-                    filter_resources(&mut found_resources, &mut required_resources, adapted_resources, filter);
+                if let Some(adapted_resources) = get_adapted_resource(filter.resource_type()) {
+                    filter_resources(&mut found_resources, &mut required_resources, &adapted_resources, filter);
                 }
                 if required_resources.values().all(|&v| v) {
                     break;
@@ -512,10 +514,10 @@ impl ResourceDiscovery for CommandDiscovery {
     }
 
     fn get_extensions(&mut self) -> Result<BTreeMap<String, DscExtension>, DscError> {
-        if self.extensions.is_empty() {
+        if extensions_is_empty() {
             self.discover(&DiscoveryKind::Extension, "*")?;
         }
-        Ok(self.extensions.clone())
+        Ok(get_extensions())
     }
 }
 

dsc_lib/src/discovery/command_discovery_cache.rs

@@ -0,0 +1,71 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+use crate::dscresources::dscresource::DscResource;
+use crate::extensions::dscextension::DscExtension;
+use std::collections::BTreeMap;
+use std::sync::{LazyLock, Mutex};
+
+// use BTreeMap so that the results are sorted by the typename, the Vec is sorted by version
+static ADAPTERS : LazyLock<Mutex<BTreeMap<String, Vec<DscResource>>>> = LazyLock::new(|| Mutex::new(BTreeMap::new()));
+static RESOURCES : LazyLock<Mutex<BTreeMap<String, Vec<DscResource>>>> = LazyLock::new(|| Mutex::new(BTreeMap::new()));
+static EXTENSIONS : LazyLock<Mutex<BTreeMap<String, DscExtension>>> = LazyLock::new(|| Mutex::new(BTreeMap::new()));
+static ADAPTED_RESOURCES : LazyLock<Mutex<BTreeMap<String, Vec<DscResource>>>> = LazyLock::new(|| Mutex::new(BTreeMap::new()));
+
+pub fn get_adapters() -> BTreeMap<String, Vec<DscResource>> {
+    ADAPTERS.lock().unwrap().clone()
+}
+
+pub fn get_adapted_resources() -> BTreeMap<String, Vec<DscResource>> {
+    ADAPTED_RESOURCES.lock().unwrap().clone()
+}
+
+pub fn get_adapted_resource(type_name: &str) -> Option<Vec<DscResource>> {
+    if let Some(resources) = ADAPTED_RESOURCES.lock().unwrap().get(type_name) {
+        return Some(resources.clone());
+    }
+    None
+}
+
+pub fn get_extensions() -> BTreeMap<String, DscExtension> {
+    EXTENSIONS.lock().unwrap().clone()
+}
+
+pub fn get_resources() -> BTreeMap<String, Vec<DscResource>> {
+    RESOURCES.lock().unwrap().clone()
+}
+
+pub fn get_resource(type_name: &str) -> Option<Vec<DscResource>> {
+    if let Some(resources) = RESOURCES.lock().unwrap().get(type_name) {
+        return Some(resources.clone());
+    }
+    None
+}
+
+pub fn extend_adapters(new_adapters: BTreeMap<String, Vec<DscResource>>) {
+    ADAPTERS.lock().unwrap().extend(new_adapters);
+}
+
+pub fn extend_resources(new_resources: BTreeMap<String, Vec<DscResource>>) {
+    RESOURCES.lock().unwrap().extend(new_resources);
+}
+
+pub fn extend_extensions(new_extensions: BTreeMap<String, DscExtension>) {
+    EXTENSIONS.lock().unwrap().extend(new_extensions);
+}
+
+pub fn extend_adapted_resources(new_adapted_resources: BTreeMap<String, Vec<DscResource>>) {
+    ADAPTED_RESOURCES.lock().unwrap().extend(new_adapted_resources);
+}
+
+pub fn extensions_is_empty() -> bool {
+    EXTENSIONS.lock().unwrap().is_empty()
+}
+
+pub fn resources_is_empty() -> bool {
+    RESOURCES.lock().unwrap().is_empty()
+}
+
+pub fn adapters_is_empty() -> bool {
+    ADAPTERS.lock().unwrap().is_empty()
+}

dsc_lib/src/discovery/mod.rs

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 
 pub mod command_discovery;
+mod command_discovery_cache;
 pub mod discovery_trait;
 
 use crate::discovery::discovery_trait::{DiscoveryKind, ResourceDiscovery, DiscoveryFilter};