add initial what-if functionality to registry resource

tgauth · tgauth · commit 3c0ce2439620 · 2024-06-12T17:08:22.000-04:00
diff --git a/.vscode/launch.json b/.vscode/launch.json
@@ -8,12 +8,15 @@
             "type": "lldb",
             "request": "launch",
             "name": "Debug config",
-            "program": "${workspaceFolder}/config/target/debug/config",
+            "program": "C:\\dsc\\dsc\\target\\debug\\dsc.exe",
             "args": [
-                "list",
-                "r*"
+                "config",
+                "set",
+                "-w",
+                "-d",
+                "$schema: https://raw.githubusercontent.com/PowerShell/DSC/main/schemas/2023/10/config/document.json\nresources:\n- name: Registry\n     type: Microsoft.Windows/Registry\n     properties:\n          keyPath: 'HKCU\\1\\2'"
             ],
-            "cwd": "${workspaceFolder}"
+            "cwd": "C:\\dsc"
         },
         {
             "name": "(macOS) Attach",
diff --git a/dsc/tests/dsc_whatif.tests.ps1 b/dsc/tests/dsc_whatif.tests.ps1
@@ -38,10 +38,10 @@ Describe 'whatif tests' {
         $what_if_result = $config_yaml | dsc config set -w | ConvertFrom-Json
         $set_result = $config_yaml | dsc config set | ConvertFrom-Json
         $what_if_result.metadata.'Microsoft.DSC'.executionType | Should -BeExactly 'WhatIf'
-        $what_if_result.results.result.beforeState._exist | Should -Be $set_result.results.result.beforeState._exist
+        $what_if_result.results.result.beforeState._exist | Should -Be $false
         $what_if_result.results.result.beforeState.keyPath | Should -Be $set_result.results.result.beforeState.keyPath
         $what_if_result.results.result.afterState.KeyPath | Should -Be $set_result.results.result.afterState.keyPath
-        $what_if_result.results.result.changedProperties | Should -Be $set_result.results.result.changedProperties
+        $what_if_result.results.result.changedProperties | Should -Be @('changeType', 'depth', '_exist')
         $what_if_result.hadErrors | Should -BeFalse
         $what_if_result.results.Count | Should -Be 1
         $LASTEXITCODE | Should -Be 0
diff --git a/registry/registry.dsc.resource.json b/registry/registry.dsc.resource.json
@@ -39,6 +39,19 @@
             }
         ]
     },
+    "whatIf": {
+        "executable": "registry",
+        "args": [
+            "config",
+            "set",
+            "-w",
+            {
+                "jsonInputArg": "--input",
+                "mandatory": true
+            }
+        ],
+        "return": "state"
+    },
     "exitCodes": {
         "0": "Success",
         "1": "Invalid parameter",
diff --git a/registry/src/args.rs b/registry/src/args.rs
@@ -22,6 +22,8 @@ pub enum ConfigSubCommand {
     Set {
         #[clap(short, long, required = true, help = "The registry JSON input.")]
         input: String,
+        #[clap(short = 'w', long, help = "Run as a what-if operation instead of applying the registry configuration")]
+        what_if: bool,
     },
     #[clap(name = "delete", about = "Delete registry configuration.")]
     Delete {
diff --git a/registry/src/config.rs b/registry/src/config.rs
@@ -14,12 +14,15 @@ pub enum RegistryValueData {
     QWord(u64),
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize, JsonSchema)]
+#[derive(Debug, Default, Clone, PartialEq, Eq, Hash, Serialize, Deserialize, JsonSchema)]
 #[serde(rename = "Registry", deny_unknown_fields)]
 pub struct Registry {
     /// The path to the registry key.
     #[serde(rename = "keyPath")]
     pub key_path: String,
+    /// The information from a config set --what-if operation.
+    #[serde(flatten, skip_serializing_if = "Option::is_none")]
+    pub what_if: Option<WhatIf>,
     /// The name of the registry value.
     #[serde(rename = "valueName", skip_serializing_if = "Option::is_none")]
     pub value_name: Option<String>,
@@ -29,3 +32,27 @@ pub struct Registry {
     #[serde(rename = "_exist", skip_serializing_if = "Option::is_none")]
     pub exist: Option<bool>,
 }
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize, JsonSchema)]
+#[serde(deny_unknown_fields)]
+pub struct WhatIf {
+    #[serde(rename = "changeType")]
+    pub change_type: Action,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub depth: Option<usize>,
+    #[serde(rename = "proposedValueData", skip_serializing_if = "Option::is_none")]
+    pub proposed_data: Option<RegistryValueData>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize, JsonSchema)]
+#[serde(deny_unknown_fields)]
+pub enum Action {
+    #[serde(rename = "clobber")]
+    Clobber,
+    #[serde(rename = "error")]
+    Error,
+    #[serde(rename = "new")]
+    New
+}
diff --git a/registry/src/main.rs b/registry/src/main.rs
@@ -63,16 +63,21 @@ fn main() {
                         }
                     }
                 },
-                args::ConfigSubCommand::Set{input} => {
+                args::ConfigSubCommand::Set{input, what_if} => {
                     let reg_helper = match RegistryHelper::new(&input) {
                         Ok(reg_helper) => reg_helper,
                         Err(err) => {
-                            eprintln!("Error: {err}");
+                            eprintln!("{err}");
                             exit(EXIT_INVALID_INPUT);
                         }
                     };
-                    match reg_helper.set() {
-                        Ok(()) => {},
+                    match reg_helper.set(what_if) {
+                        Ok(reg_config) => {
+                            if let Some(config) = reg_config {
+                                let json = serde_json::to_string(&config).unwrap();
+                                println!("{json}");
+                            }
+                        },
                         Err(err) => {
                             eprintln!("Error: {err}");
                             exit(EXIT_REGISTRY_ERROR);
diff --git a/registry/src/registry_helper.rs b/registry/src/registry_helper.rs
@@ -3,7 +3,7 @@
 
 use registry::{Data, Hive, RegKey, Security, key, value};
 use utfx::{U16CString, UCString};
-use crate::config::{Registry, RegistryValueData};
+use crate::config::{Action, Registry, RegistryValueData, WhatIf};
 use crate::error::RegistryError;
 
 pub struct RegistryHelper {
@@ -40,9 +40,8 @@ impl RegistryHelper {
                 exist = false;
                 return Ok(Registry {
                     key_path: self.config.key_path.clone(),
-                    value_name: None,
-                    value_data: None,
                     exist: Some(exist),
+                    ..Default::default()
                 });
             },
             Err(e) => return Err(e),
@@ -56,8 +55,8 @@ impl RegistryHelper {
                     return Ok(Registry {
                         key_path: self.config.key_path.clone(),
                         value_name: Some(value_name.clone()),
-                        value_data: None,
                         exist: Some(exist),
+                        ..Default::default()
                     });
                 },
                 Err(e) => return Err(RegistryError::RegistryValue(e)),
@@ -67,19 +66,18 @@ impl RegistryHelper {
                 key_path: self.config.key_path.clone(),
                 value_name: Some(value_name.clone()),
                 value_data: Some(convert_reg_value(&value)?),
-                exist: None,
+                ..Default::default()
             })
         } else {
             Ok(Registry {
                 key_path: self.config.key_path.clone(),
-                value_name: None,
-                value_data: None,
-                exist: None,
+                ..Default::default()
             })
         }
     }
 
-    pub fn set(&self) -> Result<(), RegistryError> {
+    pub fn set(&self, is_what_if: bool) -> Result<Option<Registry>, RegistryError> {
+        let mut depth = None;
         let reg_key = match self.open(Security::Write) {
             Ok((reg_key, _subkey)) => reg_key,
             // handle NotFound error
@@ -88,6 +86,7 @@ impl RegistryHelper {
                 // not exist either, so we need to find the valid parent key
                 // and then create the subkeys that don't exist
                 let (parent_key, subkeys) = self.get_valid_parent_key_and_subkeys()?;
+                depth = Some(subkeys.len());
                 let mut reg_key = parent_key;
                 for subkey in subkeys {
                     let Ok(path) = UCString::<u16>::from_str(subkey) else {
@@ -99,50 +98,84 @@ impl RegistryHelper {
 
                 self.open(Security::Write)?.0
             },
-            Err(e) => return Err(e),
+            Err(e) => return self.handle_what_if_error(e, is_what_if)
         };
 
         if let Some(value_data) = &self.config.value_data {
             let Ok(value_name) = U16CString::from_str(self.config.value_name.as_ref().unwrap()) else {
-                return Err(RegistryError::Utf16Conversion("valueName".to_string()));
+                return self.handle_what_if_error(RegistryError::Utf16Conversion("valueName".to_string()), is_what_if);
             };
 
-            match value_data {
+            let data = match value_data {
                 RegistryValueData::String(s) => {
                     let Ok(utf16) = U16CString::from_str(s) else {
-                        return Err(RegistryError::Utf16Conversion("valueData".to_string()));
+                        return self.handle_what_if_error(RegistryError::Utf16Conversion("valueData".to_string()), is_what_if);
                     };
-                    reg_key.set_value(&value_name, &Data::String(utf16))?;
+                    Data::String(utf16)
                 },
                 RegistryValueData::ExpandString(s) => {
                     let Ok(utf16) = U16CString::from_str(s) else {
-                        return Err(RegistryError::Utf16Conversion("valueData".to_string()));
+                        return self.handle_what_if_error(RegistryError::Utf16Conversion("valueData".to_string()), is_what_if);
                     };
-                    reg_key.set_value(&value_name, &Data::ExpandString(utf16))?;  
+                    Data::ExpandString(utf16)
                 },
                 RegistryValueData::Binary(b) => {
-                    reg_key.set_value(&value_name, &Data::Binary(b.clone()))?;
+                    Data::Binary(b.clone())
                 },
                 RegistryValueData::DWord(d) => {
-                    reg_key.set_value(&value_name, &Data::U32(*d))?;
+                    Data::U32(*d)
                 },
                 RegistryValueData::MultiString(m) => {
                     let mut m16: Vec<UCString<u16>> = Vec::<UCString<u16>>::new();
                     for s in m {
                         let Ok(utf16) = U16CString::from_str(s) else {
-                            return Err(RegistryError::Utf16Conversion("valueData".to_string()));
+                            return self.handle_what_if_error(RegistryError::Utf16Conversion("valueData".to_string()), is_what_if);
                         };
                         m16.push(utf16);
                     }
-                    reg_key.set_value(&value_name, &Data::MultiString(m16))?;
+                    Data::MultiString(m16)
                 },
                 RegistryValueData::QWord(q) => {
-                    reg_key.set_value(&value_name, &Data::U64(*q))?;
+                    Data::U64(*q)
                 },
+            };
+
+            if is_what_if {
+                let change_type = if let Some(name_exists) = self.get()?.exist {
+                    if name_exists { Action::Clobber }
+                    else { Action::New }
+                } else { Action::Clobber };
+                return Ok(Some(Registry {
+                    key_path: self.config.key_path.clone(),
+                    what_if: Some(WhatIf {
+                        change_type,
+                        proposed_data: Some(convert_reg_value(&data)?),
+                        depth,
+                        message: None
+                    }),
+                    ..Default::default()
+                }));
             }
+            reg_key.set_value(&value_name, &data)?;
         }
 
-        Ok(())
+        if is_what_if {
+            let change_type = if let Some(name_exists) = self.get()?.exist {
+                if name_exists { Action::Clobber }
+                else { Action::New }
+            } else { Action::Clobber };
+            return Ok(Some(Registry {
+                key_path: self.config.key_path.clone(),
+                what_if: Some(WhatIf {
+                    change_type,
+                    proposed_data: None,
+                    depth,
+                    message: None
+                }),
+                ..Default::default()
+            }));
+        }
+        Ok(None)
     }
 
     pub fn remove(&self) -> Result<(), RegistryError> {
@@ -215,6 +248,22 @@ impl RegistryHelper {
 
         Ok((parent_key, subkeys))
     }
+
+    fn handle_what_if_error(&self, error: RegistryError, is_what_if: bool) -> Result<Option<Registry>, RegistryError> {
+        if is_what_if {
+            return Ok(Some(Registry {
+                key_path: self.config.key_path.clone(),
+                what_if: Some(WhatIf {
+                    change_type: Action::Error,
+                    depth: None,
+                    proposed_data: None,
+                    message: Some(error.to_string())
+                }),
+                ..Default::default()
+            }));
+        }
+        Err(error)
+    }
 }
 
 fn get_hive_from_path(path: &str) -> Result<(Hive, &str), RegistryError> {
@@ -313,7 +362,7 @@ fn get_nonexisting_value() {
 #[test]
 fn set_and_remove_test_value() {
     let reg_helper = RegistryHelper::new(r#"{"keyPath":"HKCU\\DSCTest\\DSCSubKey","valueName":"TestValue","valueData": { "String": "Hello"} }"#).unwrap();
-    reg_helper.set().unwrap();
+    reg_helper.set(false).unwrap();
     let result = reg_helper.get().unwrap();
     assert_eq!(result.key_path, r#"HKCU\DSCTest\DSCSubKey"#);
     assert_eq!(result.value_name, Some("TestValue".to_string()));
@@ -340,7 +389,7 @@ fn set_and_remove_test_value() {
 #[test]
 fn delete_tree() {
     let reg_helper = RegistryHelper::new(r#"{"keyPath":"HKCU\\DSCTest2\\DSCSubKey","valueName":"TestValue","valueData": { "String": "Hello"} }"#).unwrap();
-    reg_helper.set().unwrap();
+    reg_helper.set(false).unwrap();
     let result = reg_helper.get().unwrap();
     assert_eq!(result.key_path, r#"HKCU\DSCTest2\DSCSubKey"#);
     assert_eq!(result.value_name, Some("TestValue".to_string()));
