add direct adapter invocation for all operations

Author: SteveL-MSFT

.vscode/launch.json

@@ -20,6 +20,11 @@
             "type": "lldb",
             "request": "attach",
             "pid": "${command:pickMyProcess}",
+            "expressions": "simple",
+            "preRunCommands": [
+                // !! change this path if you placed the script somewhere else !!
+                "command script import ~/.vscode/rust_prettifier_for_lldb.py"
+            ],
         },
         {
             "name": "(Windows) Attach",

dsc/tests/dsc_adapter.tests.ps1

@@ -0,0 +1,91 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+Describe 'Tests for adapter support' {
+    Context 'Adapter support single resource' {
+        It 'Direct resource invocation for: <operation>' -TestCases @(
+            @{ operation = 'get' },
+            @{ operation = 'set' },
+            @{ operation = 'test' },
+            @{ operation = 'export' }
+        ){
+            param($operation)
+
+            $out = dsc resource $operation -r Adapted/One -i '{"one":"1"}' 2>$TestDrive/error.log | ConvertFrom-Json -Depth 10
+            $LASTEXITCODE | Should -Be 0 -Because (Get-Content $TestDrive/error.log | Out-String)
+            switch ($operation) {
+                'get' {
+                    $out.actualState.one | Should -BeExactly 'value1'
+                }
+                'set' {
+                    $out.afterState.one | Should -BeExactly 'value1'
+                }
+                'test' {
+                    $out.actualState.one | Should -BeExactly 'value1'
+                    $out.inDesiredState | Should -BeFalse
+                    $out.differingProperties | Should -Be @('one')
+                }
+                'export' {
+                    $out.resources.count | Should -Be 2
+                    $out.resources[0].type | Should -BeExactly 'Adapted/One'
+                    $out.resources[0].name | Should -BeExactly 'first'
+                    $out.resources[0].properties.one | Should -BeExactly 'first1'
+                    $out.resources[1].type | Should -BeExactly 'Adapted/One'
+                    $out.resources[1].name | Should -BeExactly 'second'
+                    $out.resources[1].properties.one | Should -BeExactly 'second1'
+                }
+            }
+        }
+
+        It 'Config resource invocation for: <operation>' -TestCases @(
+            @{ operation = 'get' },
+            @{ operation = 'set' },
+            @{ operation = 'test' },
+            @{ operation = 'export' }
+        ){
+            param($operation)
+
+        $config_yaml = @"
+            `$schema: https://aka.ms/dsc/schemas/v3/bundled/config/document.json
+            resources:
+            - name: Test
+              type: Adapted/Two
+              properties:
+                two: '2'
+"@
+            $out = dsc config $operation -i $config_yaml 2>$TestDrive/error.log | ConvertFrom-Json -Depth 10
+            $LASTEXITCODE | Should -Be 0 -Because (Get-Content $TestDrive/error.log | Out-String)
+            switch ($operation) {
+                'get' {
+                    $out.results.Count | Should -Be 1
+                    $out.results[0].Name | Should -Be 'Test'
+                    $out.results[0].type | Should -BeExactly 'Adapted/Two'
+                    $out.results[0].result.actualState.two | Should -BeExactly 'value2' -Because ($out | ConvertTo-Json -Depth 10 | Out-String)
+                }
+                'set' {
+                    $out.results.Count | Should -Be 1
+                    $out.results[0].Name | Should -Be 'Test'
+                    $out.results[0].type | Should -BeExactly 'Adapted/Two'
+                    $out.results[0].result.afterState.two | Should -BeExactly 'value2' -Because ($out | ConvertTo-Json -Depth 10 | Out-String)
+                }
+                'test' {
+                    $out.results.Count | Should -Be 1
+                    $out.results[0].Name | Should -Be 'Test'
+                    $out.results[0].type | Should -BeExactly 'Adapted/Two'
+                    $out.results[0].result.actualState.two | Should -BeExactly 'value2' -Because ($out | ConvertTo-Json -Depth 10 | Out-String)
+                    $out.results[0].result.inDesiredState | Should -BeFalse
+                    $out.results[0].result.differingProperties | Should -Be @('two') -Because ($out | ConvertTo-Json -Depth 10 | Out-String)
+                }
+                'export' {
+                    $out.resources.Count | Should -Be 2
+                    $out.resources[0].Name | Should -Be 'first'
+                    $out.resources[0].type | Should -BeExactly 'Adapted/Two'
+                    $out.resources[0].properties.two | Should -BeExactly 'first2'
+                    $out.resources[1].Name | Should -Be 'second'
+                    $out.resources[1].type | Should -BeExactly 'Adapted/Two'
+                    $out.resources[1].properties.two | Should -BeExactly 'second2'
+                }
+            }
+        }
+    }
+}

dsc_lib/locales/en-us.toml

@@ -195,6 +195,9 @@ resourceImplementsValidate = "Resource implements validation"
 resourceValidationFailed = "Resource failed validation"
 validatingSchema = "Validating against schema"
 validationFailed = "Failed validation"
+adapterResourceNotFound = "Adapter resource '%{adapter}' not found"
+adapterManifestNotFound = "Adapter manifest for '%{adapter}' not found"
+adapterDoesNotSupportDelete = "Adapter '%{adapter}' does not support delete operation"
 
 [dscresources.resource_manifest]
 resourceManifestSchemaTitle = "Resource manifest schema URI"

dsc_lib/src/dscresources/command_resource.rs

@@ -25,13 +25,17 @@ pub const EXIT_PROCESS_TERMINATED: i32 = 0x102;
 /// # Errors
 ///
 /// Error returned if the resource does not successfully get the current state
-pub fn invoke_get(resource: &ResourceManifest, cwd: &str, filter: &str) -> Result<GetResult, DscError> {
+pub fn invoke_get(resource: &ResourceManifest, cwd: &str, filter: &str, target_resource: Option<&str>) -> Result<GetResult, DscError> {
     debug!("{}", t!("dscresources.commandResource.invokeGet", resource = &resource.resource_type));
     let mut command_input = CommandInput { env: None, stdin: None };
     let Some(get) = &resource.get else {
         return Err(DscError::NotImplemented("get".to_string()));
     };
-    let args = process_args(get.args.as_ref(), filter, &resource.resource_type);
+    let resource_type = match target_resource {
+        Some(r) => r,
+        None => &resource.resource_type,
+    };
+    let args = process_args(get.args.as_ref(), filter, resource_type);
     if !filter.is_empty() {
         verify_json(resource, cwd, filter)?;
         command_input = get_command_input(get.input.as_ref(), filter)?;
@@ -74,7 +78,7 @@ pub fn invoke_get(resource: &ResourceManifest, cwd: &str, filter: &str) -> Resul
 ///
 /// Error returned if the resource does not successfully set the desired state
 #[allow(clippy::too_many_lines)]
-pub fn invoke_set(resource: &ResourceManifest, cwd: &str, desired: &str, skip_test: bool, execution_type: &ExecutionKind) -> Result<SetResult, DscError> {
+pub fn invoke_set(resource: &ResourceManifest, cwd: &str, desired: &str, skip_test: bool, execution_type: &ExecutionKind, target_resource: Option<&str>) -> Result<SetResult, DscError> {
     debug!("{}", t!("dscresources.commandResource.invokeSet", resource = &resource.resource_type));
     let operation_type: String;
     let mut is_synthetic_what_if = false;
@@ -101,7 +105,7 @@ pub fn invoke_set(resource: &ResourceManifest, cwd: &str, desired: &str, skip_te
     // if resource doesn't implement a pre-test, we execute test first to see if a set is needed
     if !skip_test && set.pre_test != Some(true) {
         info!("{}", t!("dscresources.commandResource.noPretest", resource = &resource.resource_type));
-        let test_result = invoke_test(resource, cwd, desired)?;
+        let test_result = invoke_test(resource, cwd, desired, target_resource)?;
         if is_synthetic_what_if {
             return Ok(test_result.into());
         }
@@ -136,7 +140,11 @@ pub fn invoke_set(resource: &ResourceManifest, cwd: &str, desired: &str, skip_te
     let Some(get) = &resource.get else {
         return Err(DscError::NotImplemented("get".to_string()));
     };
-    let args = process_args(get.args.as_ref(), desired, &resource.resource_type);
+    let resource_type = match target_resource {
+        Some(r) => r,
+        None => &resource.resource_type,
+    };
+    let args = process_args(get.args.as_ref(), desired, resource_type);
     let command_input = get_command_input(get.input.as_ref(), desired)?;
 
     info!("{}", t!("dscresources.commandResource.setGetCurrent", resource = &resource.resource_type, executable = &get.executable));
@@ -168,7 +176,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 args = process_args(set.args.as_ref(), desired, &resource.resource_type);
+    let args = process_args(set.args.as_ref(), desired, resource_type);
     match &set.input {
         Some(InputKind::Env) => {
             env = Some(json_to_hashmap(desired)?);
@@ -228,7 +236,7 @@ pub fn invoke_set(resource: &ResourceManifest, cwd: &str, desired: &str, skip_te
         },
         None => {
             // perform a get and compare the result to the expected state
-            let get_result = invoke_get(resource, cwd, desired)?;
+            let get_result = invoke_get(resource, cwd, desired, target_resource)?;
             // for changed_properties, we compare post state to pre state
             let actual_state = match get_result {
                 GetResult::Group(results) => {
@@ -263,16 +271,20 @@ pub fn invoke_set(resource: &ResourceManifest, cwd: &str, desired: &str, skip_te
 /// # Errors
 ///
 /// Error is returned if the underlying command returns a non-zero exit code.
-pub fn invoke_test(resource: &ResourceManifest, cwd: &str, expected: &str) -> Result<TestResult, DscError> {
+pub fn invoke_test(resource: &ResourceManifest, cwd: &str, expected: &str, target_resource: Option<&str>) -> Result<TestResult, DscError> {
     debug!("{}", t!("dscresources.commandResource.invokeTest", resource = &resource.resource_type));
     let Some(test) = &resource.test else {
         info!("{}", t!("dscresources.commandResource.testSyntheticTest", resource = &resource.resource_type));
-        return invoke_synthetic_test(resource, cwd, expected);
+        return invoke_synthetic_test(resource, cwd, expected, target_resource);
     };
 
     verify_json(resource, cwd, expected)?;
 
-    let args = process_args(test.args.as_ref(), expected, &resource.resource_type);
+    let resource_type = match target_resource {
+        Some(r) => r,
+        None => &resource.resource_type,
+    };
+    let args = process_args(test.args.as_ref(), expected, resource_type);
     let command_input = get_command_input(test.input.as_ref(), expected)?;
 
     info!("{}", t!("dscresources.commandResource.invokeTestUsing", resource = &resource.resource_type, executable = &test.executable));
@@ -330,7 +342,7 @@ pub fn invoke_test(resource: &ResourceManifest, cwd: &str, expected: &str) -> Re
         },
         None => {
             // perform a get and compare the result to the expected state
-            let get_result = invoke_get(resource, cwd, expected)?;
+            let get_result = invoke_get(resource, cwd, expected, target_resource)?;
             let actual_state = match get_result {
                 GetResult::Group(results) => {
                     let mut result_array: Vec<Value> = Vec::new();
@@ -368,8 +380,8 @@ fn get_desired_state(actual: &Value) -> Result<Option<bool>, DscError> {
     Ok(in_desired_state)
 }
 
-fn invoke_synthetic_test(resource: &ResourceManifest, cwd: &str, expected: &str) -> Result<TestResult, DscError> {
-    let get_result = invoke_get(resource, cwd, expected)?;
+fn invoke_synthetic_test(resource: &ResourceManifest, cwd: &str, expected: &str, target_resource: Option<&str>) -> Result<TestResult, DscError> {
+    let get_result = invoke_get(resource, cwd, expected, target_resource)?;
     let actual_state = match get_result {
         GetResult::Group(results) => {
             let mut result_array: Vec<Value> = Vec::new();
@@ -403,17 +415,21 @@ fn invoke_synthetic_test(resource: &ResourceManifest, cwd: &str, expected: &str)
 /// # Errors
 ///
 /// Error is returned if the underlying command returns a non-zero exit code.
-pub fn invoke_delete(resource: &ResourceManifest, cwd: &str, filter: &str) -> Result<(), DscError> {
+pub fn invoke_delete(resource: &ResourceManifest, cwd: &str, filter: &str, target_resource: Option<&str>) -> Result<(), DscError> {
     let Some(delete) = &resource.delete else {
         return Err(DscError::NotImplemented("delete".to_string()));
     };
 
     verify_json(resource, cwd, filter)?;
 
-    let args = process_args(delete.args.as_ref(), filter, &resource.resource_type);
+    let resource_type = match target_resource {
+        Some(r) => r,
+        None => &resource.resource_type,
+    };
+    let args = process_args(delete.args.as_ref(), filter, resource_type);
     let command_input = get_command_input(delete.input.as_ref(), filter)?;
 
-    info!("{}", t!("dscresources.commandResource.invokeDeleteUsing", resource = &resource.resource_type, executable = &delete.executable));
+    info!("{}", t!("dscresources.commandResource.invokeDeleteUsing", resource = resource_type, executable = &delete.executable));
     let (_exit_code, _stdout, _stderr) = invoke_command(&delete.executable, args, command_input.stdin.as_deref(), Some(cwd), command_input.env, resource.exit_codes.as_ref())?;
 
     Ok(())
@@ -434,17 +450,21 @@ pub fn invoke_delete(resource: &ResourceManifest, cwd: &str, filter: &str) -> Re
 /// # Errors
 ///
 /// Error is returned if the underlying command returns a non-zero exit code.
-pub fn invoke_validate(resource: &ResourceManifest, cwd: &str, config: &str) -> Result<ValidateResult, DscError> {
+pub fn invoke_validate(resource: &ResourceManifest, cwd: &str, config: &str, target_resource: Option<&str>) -> Result<ValidateResult, DscError> {
     trace!("{}", t!("dscresources.commandResource.invokeValidateConfig", resource = &resource.resource_type, config = &config));
     // TODO: use schema to validate config if validate is not implemented
     let Some(validate) = resource.validate.as_ref() else {
         return Err(DscError::NotImplemented("validate".to_string()));
     };
 
-    let args = process_args(validate.args.as_ref(), config, &resource.resource_type);
+    let resource_type = match target_resource {
+        Some(r) => r,
+        None => &resource.resource_type,
+    };
+    let args = process_args(validate.args.as_ref(), config, resource_type);
     let command_input = get_command_input(validate.input.as_ref(), config)?;
 
-    info!("{}", t!("dscresources.commandResource.invokeValidateUsing", resource = &resource.resource_type, executable = &validate.executable));
+    info!("{}", t!("dscresources.commandResource.invokeValidateUsing", resource = resource_type, executable = &validate.executable));
     let (_exit_code, stdout, _stderr) = invoke_command(&validate.executable, args, command_input.stdin.as_deref(), Some(cwd), command_input.env, resource.exit_codes.as_ref())?;
     let result: ValidateResult = serde_json::from_str(&stdout)?;
     Ok(result)
@@ -491,12 +511,12 @@ pub fn get_schema(resource: &ResourceManifest, cwd: &str) -> Result<String, DscE
 /// # Errors
 ///
 /// Error returned if the resource does not successfully export the current state
-pub fn invoke_export(resource: &ResourceManifest, cwd: &str, input: Option<&str>) -> Result<ExportResult, DscError> {
+pub fn invoke_export(resource: &ResourceManifest, cwd: &str, input: Option<&str>, target_resource: Option<&str>) -> Result<ExportResult, DscError> {
     let Some(export) = resource.export.as_ref() else {
         // see if get is supported and use that instead
         if resource.get.is_some() {
             info!("{}", t!("dscresources.commandResource.exportNotSupportedUsingGet", resource = &resource.resource_type));
-            let get_result = invoke_get(resource, cwd, input.unwrap_or(""))?;
+            let get_result = invoke_get(resource, cwd, input.unwrap_or(""), target_resource)?;
             let mut instances: Vec<Value> = Vec::new();
             match get_result {
                 GetResult::Group(group_response) => {
@@ -518,16 +538,20 @@ pub fn invoke_export(resource: &ResourceManifest, cwd: &str, input: Option<&str>
 
     let mut command_input: CommandInput = CommandInput { env: None, stdin: None };
     let args: Option<Vec<String>>;
+    let resource_type = match target_resource {
+        Some(r) => r,
+        None => &resource.resource_type,
+    };
     if let Some(input) = input {
         if !input.is_empty() {
             verify_json(resource, cwd, input)?;
 
             command_input = get_command_input(export.input.as_ref(), input)?;
         }
 
-        args = process_args(export.args.as_ref(), input, &resource.resource_type);
+        args = process_args(export.args.as_ref(), input, resource_type);
     } else {
-        args = process_args(export.args.as_ref(), "", &resource.resource_type);
+        args = process_args(export.args.as_ref(), "", resource_type);
     }
 
     let (_exit_code, stdout, stderr) = invoke_command(&export.executable, args, command_input.stdin.as_deref(), Some(cwd), command_input.env, resource.exit_codes.as_ref())?;
@@ -815,7 +839,7 @@ fn verify_json(resource: &ResourceManifest, cwd: &str, json: &str) -> Result<(),
     // see if resource implements validate
     if resource.validate.is_some() {
         trace!("{}", t!("dscresources.commandResource.validateJson", json = json));
-        let result = invoke_validate(resource, cwd, json)?;
+        let result = invoke_validate(resource, cwd, json, None)?;
         if result.valid {
             return Ok(());
         }