WIP: Example using functional programming

andyleejordan · SteveL-MSFT · commit d929b6e51ff3 · 2025-10-02T12:14:08.000-07:00
diff --git a/dsc_lib/src/discovery/command_discovery.rs b/dsc_lib/src/discovery/command_discovery.rs
@@ -2,12 +2,9 @@
 // Licensed under the MIT License.
 
 use crate::discovery::{
-    command_discovery_cache::{
-        adapters_is_empty, extend_adapted_resources, extend_adapters, extend_extensions, extend_resources, extensions_is_empty,
-        get_adapted_resource, get_adapted_resources, get_adapters, get_extensions, get_resource, get_resources, resources_is_empty,
-    },
     discovery_trait::{DiscoveryFilter, DiscoveryKind, ResourceDiscovery}
 };
+use crate::{locked_is_empty, locked_extend, locked_clone, locked_get};
 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;
@@ -21,7 +18,7 @@ use rust_i18n::t;
 use semver::{Version, VersionReq};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use std::collections::{BTreeMap, HashSet, HashMap};
+use std::{collections::{BTreeMap, HashMap, HashSet}, sync::{LazyLock, Mutex}};
 use std::env;
 use std::ffi::OsStr;
 use std::fs;
@@ -36,6 +33,12 @@ use crate::util::get_exe_path;
 const DSC_RESOURCE_EXTENSIONS: [&str; 3] = [".dsc.resource.json", ".dsc.resource.yaml", ".dsc.resource.yml"];
 const DSC_EXTENSION_EXTENSIONS: [&str; 3] = [".dsc.extension.json", ".dsc.extension.yaml", ".dsc.extension.yml"];
 
+// 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()));
+
 #[derive(Clone, Serialize, Deserialize, JsonSchema)]
 pub enum ImportedManifest {
     Resource(DscResource),
@@ -79,9 +82,7 @@ impl CommandDiscovery {
     }
 
     #[must_use]
-    pub fn get_extensions(&self) -> BTreeMap<String, DscExtension> {
-        get_extensions()
-    }
+    pub fn get_extensions(&self) -> BTreeMap<String, DscExtension> { locked_clone!(EXTENSIONS) }
 
     fn get_resource_path_setting() -> Result<ResourcePathSetting, DscError>
     {
@@ -305,7 +306,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 get_extensions().values() {
+                for extension in locked_clone!(EXTENSIONS).values() {
                     if extension.capabilities.contains(&ExtensionCapability::Discover) {
                         debug!("{}", t!("discovery.commandDiscovery.callingExtension", extension = extension.type_name));
                         let discovered_resources = extension.discover()?;
@@ -318,27 +319,27 @@ impl ResourceDiscovery for CommandDiscovery {
                         }
                     }
                 }
-                extend_adapters(adapters);
-                extend_resources(resources);
+                locked_extend!(ADAPTERS, adapters);
+                locked_extend!(RESOURCES, resources);
             },
             DiscoveryKind::Extension => {
-                extend_extensions(extensions);
+                locked_extend!(EXTENSIONS, extensions);
             }
         }
 
         Ok(())
     }
 
     fn discover_adapted_resources(&mut self, name_filter: &str, adapter_filter: &str) -> Result<(), DscError> {
-        if resources_is_empty() && adapters_is_empty() {
+        if locked_is_empty!(RESOURCES) && locked_is_empty!(ADAPTERS) {
             self.discover(&DiscoveryKind::Resource, "*")?;
         }
 
-        if adapters_is_empty() {
+        if locked_is_empty!(ADAPTERS) {
             return Ok(());
         }
 
-        let adapters = get_adapters();
+        let adapters = locked_clone!(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);
@@ -430,7 +431,7 @@ impl ResourceDiscovery for CommandDiscovery {
             return Err(DscError::AdapterNotFound(adapter_filter.to_string()));
         }
 
-        extend_adapted_resources(adapted_resources);
+        locked_extend!(ADAPTED_RESOURCES, adapted_resources);
 
         Ok(())
     }
@@ -440,18 +441,18 @@ 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 &get_resources() {
+                for (resource_name, resources_vec) in &locked_clone!(RESOURCES) {
                     resources.insert(resource_name.clone(), resources_vec.iter().map(|r| ImportedManifest::Resource(r.clone())).collect());
                 }
-                for (adapter_name, adapter_vec) in &get_adapters() {
+                for (adapter_name, adapter_vec) in &locked_clone!(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
-                let adapted_resources = get_adapted_resources();
+                let adapted_resources = locked_clone!(ADAPTED_RESOURCES);
                 add_resources_to_lookup_table(&adapted_resources);
 
                 for (adapted_name, adapted_vec) in &adapted_resources {
@@ -460,7 +461,7 @@ impl ResourceDiscovery for CommandDiscovery {
             }
         } else {
             self.discover(kind, type_name_filter)?;
-            for (extension_name, extension) in &get_extensions() {
+            for (extension_name, extension) in &locked_clone!(EXTENSIONS) {
                 resources.insert(extension_name.clone(), vec![ImportedManifest::Extension(extension.clone())]);
             }
         }
@@ -470,7 +471,7 @@ 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 : {:?}));
-        if resources_is_empty() {
+        if locked_is_empty!(RESOURCES) {
             self.discover(&DiscoveryKind::Resource, "*")?;
         }
         let mut found_resources = BTreeMap::<String, Vec<DscResource>>::new();
@@ -480,7 +481,7 @@ impl ResourceDiscovery for CommandDiscovery {
         }
 
         for filter in required_resource_types {
-            if let Some(resources) = get_resource(filter.resource_type()) {
+            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) {
@@ -494,11 +495,11 @@ 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 get_adapters().keys() {
+        for adapter_name in locked_clone!(ADAPTERS).keys() {
             self.discover_adapted_resources("*", adapter_name)?;
-            add_resources_to_lookup_table(&get_adapted_resources());
+            add_resources_to_lookup_table(&locked_clone!(ADAPTED_RESOURCES));
             for filter in required_resource_types {
-                if let Some(adapted_resources) = get_adapted_resource(filter.resource_type()) {
+                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) {
@@ -514,10 +515,10 @@ impl ResourceDiscovery for CommandDiscovery {
     }
 
     fn get_extensions(&mut self) -> Result<BTreeMap<String, DscExtension>, DscError> {
-        if extensions_is_empty() {
+        if locked_is_empty!(EXTENSIONS) {
             self.discover(&DiscoveryKind::Extension, "*")?;
         }
-        Ok(get_extensions())
+        Ok(locked_clone!(EXTENSIONS))
     }
 }
 
diff --git a/dsc_lib/src/discovery/command_discovery_cache.rs b/dsc_lib/src/discovery/command_discovery_cache.rs
diff --git a/dsc_lib/src/discovery/mod.rs b/dsc_lib/src/discovery/mod.rs
@@ -2,7 +2,6 @@
 // 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};
diff --git a/dsc_lib/src/util.rs b/dsc_lib/src/util.rs
@@ -212,3 +212,35 @@ fn get_settings_policy_file_path() -> String
     // This location is writable only by admins, but readable by all users
     Path::new("/etc").join("dsc").join("dsc.settings.json").display().to_string()
 }
+
+#[macro_export]
+macro_rules! locked_is_empty {
+    ($lockable:expr) => {{
+        $lockable.lock().unwrap().is_empty()
+    }};
+}
+
+#[macro_export]
+macro_rules! locked_extend {
+    ($lockable:expr, $items:expr) => {{
+        $lockable.lock().unwrap().extend($items);
+    }};
+}
+
+#[macro_export]
+macro_rules! locked_clone {
+    ($lockable:expr) => {{
+        $lockable.lock().unwrap().clone()
+    }};
+}
+
+#[macro_export]
+macro_rules! locked_get {
+    ($lockable:expr, $key:expr) => {{
+        if let Some(v) = $lockable.lock().unwrap().get($key) {
+            Some(v.clone())
+        } else {
+            None
+        }
+    }};
+}
