Update engine to call delete for resources that don't support _exist directly

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

dsc/tests/dsc_config_set.tests.ps1

@@ -0,0 +1,31 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+Describe 'dsc config get tests' {
+    It 'can use _exist with resources that support and do not support it' {
+        $config_yaml = @"
+            `$schema: https://raw.githubusercontent.com/PowerShell/DSC/main/schemas/2023/10/config/document.json
+            resources:
+            - name: Exist
+              type: Test/Exist
+              properties:
+                _exist: false
+            - name: Delete
+              type: Test/Delete
+              properties:
+                _exist: false
+"@
+        $out = $config_yaml | dsc config set | ConvertFrom-Json
+        $LASTEXITCODE | Should -Be 0
+        $out.results[0].type | Should -BeExactly 'Test/Exist'
+        $out.results[0].result.beforeState.state | Should -BeExactly 'Absent'
+        $out.results[0].result.beforeState._exist | Should -BeFalse
+        $out.results[0].result.afterState.state | Should -BeExactly 'Absent'
+        $out.results[0].result.afterState._exist | Should -BeFalse
+        $out.results[1].type | Should -BeExactly 'Test/Delete'
+        $out.results[1].result.beforeState.deleteCalled | Should -BeTrue
+        $out.results[1].result.beforeState._exist | Should -BeFalse
+        $out.results[1].result.afterState.deleteCalled | Should -BeTrue
+        $out.results[1].result.afterState._exist | Should -BeFalse
+    }
+}

dsc_lib/src/configure/mod.rs

@@ -3,7 +3,9 @@
 
 use crate::configure::parameters::Input;
 use crate::dscerror::DscError;
-use crate::dscresources::dscresource::Invoke;
+use crate::dscresources::dscresource::get_diff;
+use crate::dscresources::invoke_result::GetResult;
+use crate::dscresources::{dscresource::{Capability, Invoke}, invoke_result::{SetResult, ResourceSetResponse}};
 use crate::dscresources::resource_manifest::Kind;
 use crate::DscResource;
 use crate::discovery::Discovery;
@@ -278,16 +280,68 @@ impl Configurator {
                 return Err(DscError::ResourceNotFound(resource.resource_type));
             };
             debug!("resource_type {}", &resource.resource_type);
+
+            // see if the properties contains `_exist` and is false
+            let exist = match &properties {
+                Some(property_map) => {
+                    if let Some(exist) = property_map.get("_exist") {
+                        !matches!(exist, Value::Bool(false))
+                    } else {
+                        true
+                    }
+                },
+                _ => {
+                    true
+                }
+            };
+
             let desired = add_metadata(&dsc_resource.kind, properties)?;
             trace!("desired: {desired}");
-            let set_result = dsc_resource.set(&desired, skip_test)?;
-            self.context.outputs.insert(format!("{}:{}", resource.resource_type, resource.name), serde_json::to_value(&set_result)?);
-            let resource_result = config_result::ResourceSetResult {
-                name: resource.name.clone(),
-                resource_type: resource.resource_type.clone(),
-                result: set_result,
-            };
-            result.results.push(resource_result);
+
+            if exist || dsc_resource.capabilities.contains(&Capability::SetHandlesExist) {
+                debug!("Resource handles _exist or _exist is true");
+                let set_result = dsc_resource.set(&desired, skip_test)?;
+                self.context.outputs.insert(format!("{}:{}", resource.resource_type, resource.name), serde_json::to_value(&set_result)?);
+                let resource_result = config_result::ResourceSetResult {
+                    name: resource.name.clone(),
+                    resource_type: resource.resource_type.clone(),
+                    result: set_result,
+                };
+                result.results.push(resource_result);    
+            } else if dsc_resource.capabilities.contains(&Capability::Delete) {
+                debug!("Resource implements delete and _exist is false");
+                let before_result = dsc_resource.get(&desired)?;
+                dsc_resource.delete(&desired)?;
+                let after_result = dsc_resource.get(&desired)?;
+                // convert get result to set result                
+                let set_result = match before_result {
+                    GetResult::Resource(before_response) => {
+                        let after_result = match after_result {
+                            GetResult::Resource(get_response) => get_response,
+                            _ => return Err(DscError::NotSupported("Group resources not supported for delete".to_string())),
+                        };
+                        let before_value = serde_json::to_value(&before_response.actual_state)?;
+                        let after_value = serde_json::to_value(&after_result.actual_state)?;
+                        ResourceSetResponse {
+                            before_state: before_response.actual_state,
+                            after_state: after_result.actual_state,
+                            changed_properties: Some(get_diff(&before_value, &after_value)),
+                        }
+                    },
+                    GetResult::Group(_) => {
+                        return Err(DscError::NotSupported("Group resources not supported for delete".to_string()));
+                    },
+                };
+                self.context.outputs.insert(format!("{}:{}", resource.resource_type, resource.name), serde_json::to_value(&set_result)?);
+                let resource_result = config_result::ResourceSetResult {
+                    name: resource.name.clone(),
+                    resource_type: resource.resource_type.clone(),
+                    result: SetResult::Resource(set_result),
+                };
+                result.results.push(resource_result);
+            } else {
+                return Err(DscError::NotImplemented(format!("Resource '{}' does not support `delete` and does not handle `_exist` as false", resource.resource_type)));
+            }
         }
 
         mem::drop(pb_span_enter);

dsc_lib/src/dscerror.rs

@@ -71,6 +71,9 @@ pub enum DscError {
     #[error("Not implemented: {0}")]
     NotImplemented(String),
 
+    #[error("Not supported: {0}")]
+    NotSupported(String),
+
     #[error("Number conversion error: {0}")]
     NumberConversion(#[from] std::num::TryFromIntError),
 

tools/dsctest/dscdelete.dsc.resource.json

@@ -0,0 +1,37 @@
+{
+    "$schema": "https://raw.githubusercontent.com/PowerShell/DSC/main/schemas/2023/08/bundled/resource/manifest.json",
+    "type": "Test/Delete",
+    "version": "0.1.0",
+    "get": {
+        "executable": "dsctest",
+        "args": [
+            "delete",
+            "--input",
+            "{json}"
+        ],
+        "input": {
+            "arg": "{json}"
+        }
+    },
+    "delete": {
+        "executable": "dsctest",
+        "args": [
+            "delete",
+            "--input",
+            "{json}"
+        ],
+        "input": {
+            "arg": "{json}"
+        }
+    },
+    "schema": {
+        "command": {
+            "executable": "dsctest",
+            "args": [
+                "schema",
+                "-s",
+                "delete"
+            ]
+        }
+    }
+}

tools/dsctest/dscexist.dsc.resource.json

@@ -24,6 +24,7 @@
             "arg": "{json}"
         },
         "handlesExist": true,
+        "implementsPretest": true,
         "return": "state"
     },
     "schema": {

tools/dsctest/src/args.rs

@@ -5,6 +5,7 @@ use clap::{Parser, Subcommand, ValueEnum};
 
 #[derive(Debug, Clone, PartialEq, Eq, ValueEnum)]
 pub enum Schemas {
+    Delete,
     Echo,
     Exist,
     Sleep,
@@ -20,12 +21,24 @@ pub struct Args {
 
 #[derive(Debug, PartialEq, Eq, Subcommand)]
 pub enum SubCommand {
+    #[clap(name = "delete", about = "delete operation")]
+    Delete {
+        #[clap(name = "input", short, long, help = "The input to the delete command as JSON")]
+        input: String,
+    },
+
     #[clap(name = "echo", about = "Return the input")]
     Echo {
         #[clap(name = "input", short, long, help = "The input to the echo command as JSON")]
         input: String,
     },
 
+    #[clap(name = "exist", about = "Check if a resource exists")]
+    Exist {
+        #[clap(name = "input", short, long, help = "The input to the exist command as JSON")]
+        input: String,
+    },
+
     #[clap(name = "schema", about = "Get the JSON schema for a subcommand")]
     Schema {
         #[clap(name = "subcommand", short, long, help = "The subcommand to get the schema for")]
@@ -37,10 +50,4 @@ pub enum SubCommand {
         #[clap(name = "input", short, long, help = "The input to the sleep command as JSON")]
         input: String,
     },
-
-    #[clap(name = "exist", about = "Check if a resource exists")]
-    Exist {
-        #[clap(name = "input", short, long, help = "The input to the exist command as JSON")]
-        input: String,
-    },
 }

tools/dsctest/src/delete.rs

@@ -0,0 +1,14 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
+#[serde(deny_unknown_fields)]
+pub struct Delete {
+    #[serde(rename = "deleteCalled", skip_serializing_if = "Option::is_none")]
+    pub delete_called: Option<bool>,
+    #[serde(rename = "_exist")]
+    pub exist: bool,
+}

tools/dsctest/src/main.rs

@@ -2,13 +2,15 @@
 // Licensed under the MIT License.
 
 mod args;
+mod delete;
 mod echo;
 mod exist;
 mod sleep;
 
 use args::{Args, Schemas, SubCommand};
 use clap::Parser;
 use schemars::schema_for;
+use crate::delete::Delete;
 use crate::echo::Echo;
 use crate::exist::{Exist, State};
 use crate::sleep::Sleep;
@@ -17,6 +19,17 @@ use std::{thread, time::Duration};
 fn main() {
     let args = Args::parse();
     let json = match args.subcommand {
+        SubCommand::Delete { input } => {
+            let mut delete = match serde_json::from_str::<Delete>(&input) {
+                Ok(delete) => delete,
+                Err(err) => {
+                    eprintln!("Error JSON does not match schema: {err}");
+                    std::process::exit(1);
+                }
+            };
+            delete.delete_called = Some(true);
+            serde_json::to_string(&delete).unwrap()
+        },
         SubCommand::Echo { input } => {
             let echo = match serde_json::from_str::<Echo>(&input) {
                 Ok(echo) => echo,
@@ -45,6 +58,9 @@ fn main() {
         },
         SubCommand::Schema { subcommand } => {
             let schema = match subcommand {
+                Schemas::Delete => {
+                    schema_for!(Delete)
+                },
                 Schemas::Echo => {
                     schema_for!(Echo)
                 },