add what-if argkind

Author: tgauth

dsc/src/subcommand.rs

@@ -250,7 +250,7 @@ pub fn config(subcommand: &ConfigSubCommand, parameters: &Option<String>, stdin:
 
     if let ConfigSubCommand::Set { what_if , .. } = subcommand {
         if *what_if {
-            configurator.context.execution_type = ExecutionKind::WhatIf;
+            configurator.context.execution_type = ExecutionKind::WhatIfDSC;
         }
     };
 
@@ -511,11 +511,12 @@ fn list_resources(dsc: &mut DscManager, resource_name: &Option<String>, adapter_
         write_table = true;
     }
     for resource in dsc.list_available_resources(&resource_name.clone().unwrap_or("*".to_string()), &adapter_name.clone().unwrap_or_default()) {
-        let mut capabilities = "-------".to_string();
+        let mut capabilities = "--------".to_string();
         let capability_types = [
             (Capability::Get, "g"),
             (Capability::Set, "s"),
             (Capability::SetHandlesExist, "x"),
+            (Capability::SetHandlesWhatIf, "w"),
             (Capability::Test, "t"),
             (Capability::Delete, "d"),
             (Capability::Export, "e"),

dsc_lib/src/configure/config_doc.rs

@@ -30,7 +30,10 @@ pub enum Operation {
 #[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
 pub enum ExecutionKind {
     Actual,
-    WhatIf,
+    #[serde(rename = "WhatIf")]
+    WhatIfDSC,
+    #[serde(rename = "WhatIf")]
+    WhatIfResource,
 }
 
 #[derive(Debug, Default, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]

dsc_lib/src/configure/mod.rs

@@ -318,7 +318,7 @@ impl Configurator {
                 set_result = dsc_resource.set(&desired, skip_test, &self.context.execution_type)?;
                 end_datetime = chrono::Local::now();
             } else if dsc_resource.capabilities.contains(&Capability::Delete) {
-                if self.context.execution_type == ExecutionKind::WhatIf {
+                if self.context.execution_type == ExecutionKind::WhatIfDSC {
                     // TODO: add delete what-if support
                     return Err(DscError::NotSupported("What-if execution not supported for delete".to_string()));
                 }

dsc_lib/src/discovery/command_discovery.rs

@@ -4,7 +4,7 @@
 use crate::discovery::discovery_trait::ResourceDiscovery;
 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::resource_manifest::{import_manifest, validate_semver, ArgKind, Kind, ResourceManifest};
 use crate::dscresources::command_resource::invoke_command;
 use crate::dscerror::DscError;
 use indicatif::ProgressStyle;
@@ -449,6 +449,14 @@ fn load_manifest(path: &Path) -> Result<DscResource, DscError> {
         if set.handles_exist == Some(true) {
             capabilities.push(Capability::SetHandlesExist);
         }
+        if let Some(arg_values) = &set.args {
+            for arg in arg_values {
+                if let &ArgKind::WhatIf { .. } = arg {
+                    capabilities.push(Capability::SetHandlesWhatIf);
+                    break;
+                }
+            }
+        }
     }
     if manifest.test.is_some() {
         capabilities.push(Capability::Test);

dsc_lib/src/dscresources/command_resource.rs

@@ -50,7 +50,7 @@ pub fn invoke_get(resource: &ResourceManifest, cwd: &str, filter: &str) -> Resul
     let Some(get) = &resource.get else {
         return Err(DscError::NotImplemented("get".to_string()));
     };
-    let args = process_args(&get.args, filter);
+    let args = process_args(&get.args, filter, &ExecutionKind::Actual);
     if !filter.is_empty() {
         verify_json(resource, cwd, filter)?;
         command_input = get_command_input(&get.input, filter)?;
@@ -105,7 +105,7 @@ pub fn invoke_set(resource: &ResourceManifest, cwd: &str, desired: &str, skip_te
     if !skip_test && set.pre_test != Some(true) {
         info!("No pretest, invoking test {}", &resource.resource_type);
         let test_result = invoke_test(resource, cwd, desired)?;
-        if execution_type == &ExecutionKind::WhatIf && set.handles_what_if != Some(true) {
+        if execution_type == &ExecutionKind::WhatIfDSC {
             return Ok(test_result.into());
         }
         let (in_desired_state, actual_state) = match test_result {
@@ -130,14 +130,14 @@ pub fn invoke_set(resource: &ResourceManifest, cwd: &str, desired: &str, skip_te
         }
     }
 
-    if ExecutionKind::WhatIf == *execution_type && set.handles_what_if != Some(true) {
+    if ExecutionKind::WhatIfDSC == *execution_type {
         return Err(DscError::NotImplemented("cannot process what-if execution type, resource does not implement what-if or pre-test".to_string()));
     }
 
     let Some(get) = &resource.get else {
         return Err(DscError::NotImplemented("get".to_string()));
     };
-    let args = process_args(&get.args, desired);
+    let args = process_args(&get.args, desired, &ExecutionKind::Actual);
     let command_input = get_command_input(&get.input, desired)?;
 
     info!("Getting current state for set by invoking get {} using {}", &resource.resource_type, &get.executable);
@@ -157,16 +157,7 @@ pub fn invoke_set(resource: &ResourceManifest, cwd: &str, desired: &str, skip_te
 
     let mut env: Option<HashMap<String, String>> = None;
     let mut input_desired: Option<&str> = None;
-    let mut args = process_args(&set.args, desired);
-    if ExecutionKind::WhatIf == *execution_type {
-        if let Some(mut arguments) = args {
-            arguments.push("--what-if".to_string());
-            args = Some(arguments);
-        }
-        else {
-            args = Some(vec!["--what-if".to_string()]);
-        }
-    }
+    let args = process_args(&set.args, desired, execution_type);
     match &set.input {
         Some(InputKind::Env) => {
             env = Some(json_to_hashmap(desired)?);
@@ -269,7 +260,7 @@ pub fn invoke_test(resource: &ResourceManifest, cwd: &str, expected: &str) -> Re
 
     verify_json(resource, cwd, expected)?;
 
-    let args = process_args(&test.args, expected);
+    let args = process_args(&test.args, expected, &ExecutionKind::Actual);
     let command_input = get_command_input(&test.input, expected)?;
 
     info!("Invoking test '{}' using '{}'", &resource.resource_type, &test.executable);
@@ -383,7 +374,7 @@ pub fn invoke_delete(resource: &ResourceManifest, cwd: &str, filter: &str) -> Re
 
     verify_json(resource, cwd, filter)?;
 
-    let args = process_args(&delete.args, filter);
+    let args = process_args(&delete.args, filter, &ExecutionKind::Actual);
     let command_input = get_command_input(&delete.input, filter)?;
 
     info!("Invoking delete '{}' using '{}'", &resource.resource_type, &delete.executable);
@@ -414,7 +405,7 @@ pub fn invoke_validate(resource: &ResourceManifest, cwd: &str, config: &str) ->
         return Err(DscError::NotImplemented("validate".to_string()));
     };
 
-    let args = process_args(&validate.args, config);
+    let args = process_args(&validate.args, config, &ExecutionKind::Actual);
     let command_input = get_command_input(&validate.input, config)?;
 
     info!("Invoking validate '{}' using '{}'", &resource.resource_type, &validate.executable);
@@ -489,9 +480,9 @@ pub fn invoke_export(resource: &ResourceManifest, cwd: &str, input: Option<&str>
             command_input = get_command_input(&export.input, input)?;
         }
 
-        args = process_args(&export.args, input);
+        args = process_args(&export.args, input, &ExecutionKind::Actual);
     } else {
-        args = process_args(&export.args, "");
+        args = process_args(&export.args, "", &ExecutionKind::Actual);
     }
 
     let (_exit_code, stdout, stderr) = invoke_command(&export.executable, args, command_input.stdin.as_deref(), Some(cwd), command_input.env)?;
@@ -536,7 +527,7 @@ pub fn invoke_resolve(resource: &ResourceManifest, cwd: &str, input: &str) -> Re
         return Err(DscError::Operation(format!("Resolve is not supported by resource {}", &resource.resource_type)));
     };
 
-    let args = process_args(&resolve.args, input);
+    let args = process_args(&resolve.args, input, &ExecutionKind::Actual);
     let command_input = get_command_input(&resolve.input, input)?;
 
     info!("Invoking resolve '{}' using '{}'", &resource.resource_type, &resolve.executable);
@@ -628,7 +619,7 @@ pub fn invoke_command(executable: &str, args: Option<Vec<String>>, input: Option
     Ok((exit_code, stdout, cleaned_stderr))
 }
 
-fn process_args(args: &Option<Vec<ArgKind>>, value: &str) -> Option<Vec<String>> {
+fn process_args(args: &Option<Vec<ArgKind>>, value: &str, execution_type: &ExecutionKind) -> Option<Vec<String>> {
     let Some(arg_values) = args else {
         debug!("No args to process");
         return None;
@@ -648,6 +639,11 @@ fn process_args(args: &Option<Vec<ArgKind>>, value: &str) -> Option<Vec<String>>
                 processed_args.push(json_input_arg.clone());
                 processed_args.push(value.to_string());
             },
+            ArgKind::WhatIf { what_if_input_arg} => {
+                if execution_type == &ExecutionKind::WhatIfResource {
+                    processed_args.push(what_if_input_arg.clone());
+                }
+            }
         }
     }
 

dsc_lib/src/dscresources/dscresource.rs

@@ -211,7 +211,13 @@ impl Invoke for DscResource {
                     return Err(DscError::MissingManifest(self.type_name.clone()));
                 };
                 let resource_manifest = import_manifest(manifest.clone())?;
-                command_resource::invoke_set(&resource_manifest, &self.directory, desired, skip_test, execution_type)
+                let execution = if self.capabilities.contains(&Capability::SetHandlesWhatIf) && execution_type == &ExecutionKind::WhatIfDSC {
+                    ExecutionKind::WhatIfResource
+                }
+                else {
+                    execution_type.clone()
+                };
+                command_resource::invoke_set(&resource_manifest, &self.directory, desired, skip_test, &execution)
             },
         }
     }

dsc_lib/src/dscresources/resource_manifest.rs

@@ -103,6 +103,11 @@ pub enum ArgKind {
         /// Indicates if argument is mandatory which will pass an empty string if no JSON input is provided.  Default is false.
         mandatory: Option<bool>,
     },
+    WhatIf {
+        /// The argument that serves as the what-if switch.
+        #[serde(rename = "whatIfInputArg")]
+        what_if_input_arg: String,
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]

tools/dsctest/dscwhatif.dsc.resource.json

@@ -11,9 +11,11 @@
     "set": {
         "executable": "dsctest",
         "args": [
-            "what-if"
+            "what-if",
+            {
+                "whatIfInputArg": "--what-if"
+            }
         ],
-        "handlesWhatIf": true,
         "implementsPretest": true,
         "return": "state"
     },

tools/dsctest/src/args.rs

@@ -58,7 +58,7 @@ pub enum SubCommand {
 
     #[clap(name = "what-if", about = "Check if it is a what-if operation")]
     WhatIf {
-        #[clap(name = "what-if", short, long, help = "The input to the what-if command as JSON")]
+        #[clap(name = "what-if", short, long, help = "Run as a what-if executionType instead of actual executionType")]
         what_if: bool,
     }
 }

tools/dsctest/src/whatif.rs

@@ -4,15 +4,6 @@
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
-// #[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
-// #[serde(untagged)]
-// pub enum ExecutionKind {
-//     #[serde(rename = "actual")]
-//     Actual,
-//     #[serde(rename = "whatIf")]
-//     WhatIf,
-// }
-
 #[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
 #[serde(deny_unknown_fields)]
 pub struct WhatIf {