cleanup traces and add adapter to list of found resources when enumerating adapted resources

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

dsc/src/resource_command.rs

@@ -27,7 +27,7 @@ pub fn get(dsc: &DscManager, resource_type: &str, mut input: String, format: &Op
         if let Some(pr) = get_resource(dsc, requires) {
             resource = pr;
         } else {
-            error!("Adapter {} not found", requires);
+            error!("Adapter '{}' not found", requires);
             return;
         };
     }
@@ -112,7 +112,7 @@ pub fn set(dsc: &DscManager, resource_type: &str, mut input: String, format: &Op
         if let Some(pr) = get_resource(dsc, requires) {
             resource = pr;
         } else {
-            error!("Adapter {} not found", requires);
+            error!("Adapter '{}' not found", requires);
             return;
         };
     }
@@ -149,7 +149,7 @@ pub fn test(dsc: &DscManager, resource_type: &str, mut input: String, format: &O
         if let Some(pr) = get_resource(dsc, requires) {
             resource = pr;
         } else {
-            error!("Adapter {} not found", requires);
+            error!("Adapter '{}' not found", requires);
             return;
         };
     }
@@ -186,7 +186,7 @@ pub fn delete(dsc: &DscManager, resource_type: &str, mut input: String) {
         if let Some(pr) = get_resource(dsc, requires) {
             resource = pr;
         } else {
-            error!("Adapter {} not found", requires);
+            error!("Adapter '{}' not found", requires);
             return;
         };
     }

dsc_lib/src/discovery/command_discovery.rs

@@ -6,7 +6,6 @@ use crate::discovery::convert_wildcard_to_regex;
 use crate::dscresources::dscresource::{Capability, DscResource, ImplementedAs};
 use crate::dscresources::resource_manifest::{import_manifest, validate_semver, Kind, ResourceManifest};
 use crate::dscresources::command_resource::invoke_command;
-use crate::dscresources::command_resource::log_resource_traces;
 use crate::dscerror::DscError;
 use indicatif::ProgressStyle;
 use regex::RegexBuilder;
@@ -49,7 +48,7 @@ impl CommandDiscovery {
             trace!("DSC_RESOURCE_PATH not set, trying PATH");
             match env::var_os("PATH") {
                 Some(value) => {
-                    debug!("Using PATH: {:?}", value.to_string_lossy());
+                    trace!("Using PATH: {:?}", value.to_string_lossy());
                     value
                 },
                 None => {
@@ -85,10 +84,6 @@ impl Default for CommandDiscovery {
 impl ResourceDiscovery for CommandDiscovery {
 
     fn discover_resources(&mut self, filter: &str) -> Result<(), DscError> {
-        if !self.resources.is_empty() || !self.adapters.is_empty() {
-            return Ok(());
-        }
-
         info!("Discovering resources using filter: {filter}");
 
         let regex_str = convert_wildcard_to_regex(filter);
@@ -232,11 +227,10 @@ impl ResourceDiscovery for CommandDiscovery {
                     Ok((exit_code, stdout, stderr)) => (exit_code, stdout, stderr),
                     Err(e) => {
                         // In case of error, log and continue
-                        warn!("Could not start {}: {}", list_command.executable, e);
+                        warn!("{e}");
                         continue;
                     },
                 };
-                log_resource_traces(&stderr);
 
                 if exit_code != 0 {
                     // in case of failure, log and continue
@@ -331,32 +325,34 @@ impl ResourceDiscovery for CommandDiscovery {
 
             if remaining_required_resource_types.contains(&adapter_name.to_lowercase())
             {
-                // if an adapter is required, we need to find the resources it adapts
-                self.discover_adapted_resources("*", &adapter_name)?;
-
                 // remove the adapter from the list of required resources
                 remaining_required_resource_types.retain(|x| *x != adapter_name.to_lowercase());
                 found_resources.insert(adapter_name.to_lowercase(), adapter.clone());
                 if remaining_required_resource_types.is_empty()
                 {
                     return Ok(found_resources);
                 }
+            }
 
-                // now go through the adapter resources and add them to the list of resources
-                for (adapted_name, adapted_resource) in &self.adapted_resources {
-                    let Some(adapted_resource) = adapted_resource.first() else {
-                        // skip if no resources
-                        continue;
-                    };
+            self.discover_adapted_resources("*", &adapter_name)?;
 
-                    if remaining_required_resource_types.contains(&adapted_name.to_lowercase())
+            // now go through the adapter resources and add them to the list of resources
+            for (adapted_name, adapted_resource) in &self.adapted_resources {
+                let Some(adapted_resource) = adapted_resource.first() else {
+                    // skip if no resources
+                    continue;
+                };
+
+                if remaining_required_resource_types.contains(&adapted_name.to_lowercase())
+                {
+                    remaining_required_resource_types.retain(|x| *x != adapted_name.to_lowercase());
+                    found_resources.insert(adapted_name.to_lowercase(), adapted_resource.clone());
+
+                    // also insert the adapter
+                    found_resources.insert(adapter_name.to_lowercase(), adapter.clone());
+                    if remaining_required_resource_types.is_empty()
                     {
-                        remaining_required_resource_types.retain(|x| *x != adapted_name.to_lowercase());
-                        found_resources.insert(adapted_name.to_lowercase(), adapted_resource.clone());
-                        if remaining_required_resource_types.is_empty()
-                        {
-                            return Ok(found_resources);
-                        }
+                        return Ok(found_resources);
                     }
                 }
             }

dsc_lib/src/dscerror.rs

@@ -17,6 +17,9 @@ pub enum DscError {
     #[error("Command: Resource '{0}' [Exit code {1}] {2}")]
     Command(String, i32, String),
 
+    #[error("Command: Executable '{0}' [Exit code {1}] {2}")]
+    CommandExit(String, i32, String),
+
     #[error("CommandOperation: {0} for executable '{1}'")]
     CommandOperation(String, String),
 

dsc_lib/src/dscresources/command_resource.rs

@@ -12,22 +12,22 @@ use tracing::{error, warn, info, debug, trace};
 pub const EXIT_PROCESS_TERMINATED: i32 = 0x102;
 
 
-pub fn log_resource_traces(stderr: &str)
+pub fn log_resource_traces(process_name: &str, stderr: &str)
 {
     if !stderr.is_empty()
     {
         for trace_line in stderr.lines() {
             if let Result::Ok(json_obj) = serde_json::from_str::<Value>(trace_line) {
                 if let Some(msg) = json_obj.get("Error") {
-                    error!("{}", msg.as_str().unwrap_or_default());
+                    error!("Process {process_name}: {}", msg.as_str().unwrap_or_default());
                 } else if let Some(msg) = json_obj.get("Warning") {
-                    warn!("{}", msg.as_str().unwrap_or_default());
+                    warn!("Process {process_name}: {}", msg.as_str().unwrap_or_default());
                 } else if let Some(msg) = json_obj.get("Info") {
-                    info!("{}", msg.as_str().unwrap_or_default());
+                    info!("Process {process_name}: {}", msg.as_str().unwrap_or_default());
                 } else if let Some(msg) = json_obj.get("Debug") {
-                    debug!("{}", msg.as_str().unwrap_or_default());
+                    debug!("Process {process_name}: {}", msg.as_str().unwrap_or_default());
                 } else if let Some(msg) = json_obj.get("Trace") {
-                    trace!("{}", msg.as_str().unwrap_or_default());
+                    trace!("Process {process_name}: {}", msg.as_str().unwrap_or_default());
                 };
             };
         }
@@ -54,12 +54,7 @@ pub fn invoke_get(resource: &ResourceManifest, cwd: &str, filter: &str) -> Resul
     }
 
     info!("Invoking get '{}' using '{}'", &resource.resource_type, &resource.get.executable);
-    let (exit_code, stdout, stderr) = invoke_command(&resource.get.executable, args, command_input.stdin.as_deref(), Some(cwd), command_input.env)?;
-    log_resource_traces(&stderr);
-    if exit_code != 0 {
-        return Err(DscError::Command(resource.resource_type.clone(), exit_code, stderr));
-    }
-
+    let (_exit_code, stdout, stderr) = invoke_command(&resource.get.executable, args, command_input.stdin.as_deref(), Some(cwd), command_input.env)?;
     if resource.kind == Some(Kind::Resource) {
         debug!("Verifying output of get '{}' using '{}'", &resource.resource_type, &resource.get.executable);
         verify_json(resource, cwd, &stdout)?;
@@ -131,10 +126,6 @@ pub fn invoke_set(resource: &ResourceManifest, cwd: &str, desired: &str, skip_te
 
     info!("Getting current state for set by invoking get {} using {}", &resource.resource_type, &resource.get.executable);
     let (exit_code, stdout, stderr) = invoke_command(&resource.get.executable, args, command_input.stdin.as_deref(), Some(cwd), command_input.env)?;
-    log_resource_traces(&stderr);
-    if exit_code != 0 {
-        return Err(DscError::Command(resource.resource_type.clone(), exit_code, stderr));
-    }
 
     if resource.kind == Some(Kind::Resource) {
         debug!("Verifying output of get '{}' using '{}'", &resource.resource_type, &resource.get.executable);
@@ -165,10 +156,6 @@ pub fn invoke_set(resource: &ResourceManifest, cwd: &str, desired: &str, skip_te
 
     info!("Invoking set '{}' using '{}'", &resource.resource_type, &set.executable);
     let (exit_code, stdout, stderr) = invoke_command(&set.executable, args, input_desired, Some(cwd), env)?;
-    log_resource_traces(&stderr);
-    if exit_code != 0 {
-        return Err(DscError::Command(resource.resource_type.clone(), exit_code, stderr));
-    }
 
     match set.returns {
         Some(ReturnKind::State) => {
@@ -260,10 +247,6 @@ pub fn invoke_test(resource: &ResourceManifest, cwd: &str, expected: &str) -> Re
 
     info!("Invoking test '{}' using '{}'", &resource.resource_type, &test.executable);
     let (exit_code, stdout, stderr) = invoke_command(&test.executable, args, command_input.stdin.as_deref(), Some(cwd), command_input.env)?;
-    log_resource_traces(&stderr);
-    if exit_code != 0 {
-        return Err(DscError::Command(resource.resource_type.clone(), exit_code, stderr));
-    }
 
     if resource.kind == Some(Kind::Resource) {
         debug!("Verifying output of test '{}' using '{}'", &resource.resource_type, &test.executable);
@@ -377,11 +360,7 @@ pub fn invoke_delete(resource: &ResourceManifest, cwd: &str, filter: &str) -> Re
     let command_input = get_command_input(&delete.input, filter)?;
 
     info!("Invoking delete '{}' using '{}'", &resource.resource_type, &delete.executable);
-    let (exit_code, _stdout, stderr) = invoke_command(&delete.executable, args, command_input.stdin.as_deref(), Some(cwd), command_input.env)?;
-    log_resource_traces(&stderr);
-    if exit_code != 0 {
-        return Err(DscError::Command(resource.resource_type.clone(), exit_code, stderr));
-    }
+    let (_exit_code, _stdout, _stderr) = invoke_command(&delete.executable, args, command_input.stdin.as_deref(), Some(cwd), command_input.env)?;
 
     Ok(())
 }
@@ -412,12 +391,7 @@ pub fn invoke_validate(resource: &ResourceManifest, cwd: &str, config: &str) ->
     let command_input = get_command_input(&validate.input, config)?;
 
     info!("Invoking validate '{}' using '{}'", &resource.resource_type, &validate.executable);
-    let (exit_code, stdout, stderr) = invoke_command(&validate.executable, args, command_input.stdin.as_deref(), Some(cwd), command_input.env)?;
-    log_resource_traces(&stderr);
-    if exit_code != 0 {
-        return Err(DscError::Command(resource.resource_type.clone(), exit_code, stderr));
-    }
-
+    let (_exit_code, stdout, _stderr) = invoke_command(&validate.executable, args, command_input.stdin.as_deref(), Some(cwd), command_input.env)?;
     let result: ValidateResult = serde_json::from_str(&stdout)?;
     Ok(result)
 }
@@ -438,11 +412,7 @@ pub fn get_schema(resource: &ResourceManifest, cwd: &str) -> Result<String, DscE
 
     match schema_kind {
         SchemaKind::Command(ref command) => {
-            let (exit_code, stdout, stderr) = invoke_command(&command.executable, command.args.clone(), None, Some(cwd), None)?;
-            log_resource_traces(&stderr);
-            if exit_code != 0 {
-                return Err(DscError::Command(resource.resource_type.clone(), exit_code, stderr));
-            }
+            let (_exit_code, stdout, _stderr) = invoke_command(&command.executable, command.args.clone(), None, Some(cwd), None)?;
             Ok(stdout)
         },
         SchemaKind::Embedded(ref schema) => {
@@ -499,11 +469,7 @@ pub fn invoke_export(resource: &ResourceManifest, cwd: &str, input: Option<&str>
         args = process_args(&export.args, "");
     }
 
-    let (exit_code, stdout, stderr) = invoke_command(&export.executable, args, command_input.stdin.as_deref(), Some(cwd), command_input.env)?;
-    log_resource_traces(&stderr);
-    if exit_code != 0 {
-        return Err(DscError::Command(resource.resource_type.clone(), exit_code, stderr));
-    }
+    let (_exit_code, stdout, stderr) = invoke_command(&export.executable, args, command_input.stdin.as_deref(), Some(cwd), command_input.env)?;
     let mut instances: Vec<Value> = Vec::new();
     for line in stdout.lines()
     {
@@ -594,7 +560,13 @@ pub fn invoke_command(executable: &str, args: Option<Vec<String>>, input: Option
     }
     if !stderr.is_empty() {
         trace!("STDERR returned: {}", &stderr);
+        log_resource_traces(executable, &stderr);
     }
+
+    if exit_code != 0 {
+        return Err(DscError::Command(executable.to_string(), exit_code, stderr));
+    }
+
     Ok((exit_code, stdout, stderr))
 }