(GH-538) Update target_resource to use FQTN

michaeltlombardi · michaeltlombardi · commit 84ccfc5903e9 · 2026-01-08T14:17:54.000-06:00
This change updates the `target_resource` field of `DscResource` to use
`FullyQualifiedTypeName` instead of `String`. It also updates related
functions to expect that type instead of `&amp;str`.
diff --git a/dsc/src/mcp/list_dsc_resources.rs b/dsc/src/mcp/list_dsc_resources.rs
@@ -70,7 +70,7 @@ impl McpServer {
                         r#type: resource.type_name.to_string(),
                         kind: resource.kind.clone(),
                         description: resource.description.clone(),
-                        require_adapter: resource.require_adapter.clone(),
+                        require_adapter: resource.require_adapter.map(|fqtn| fqtn.to_string()),
                     };
                     resources.insert(resource.type_name.to_lowercase(), summary);
                 }
diff --git a/dsc/src/subcommand.rs b/dsc/src/subcommand.rs
@@ -824,7 +824,7 @@ pub fn list_resources(dsc: &mut DscManager, resource_name: Option<&String>, adap
                     format!("{:?}", resource.kind),
                     resource.version,
                     capabilities,
-                    resource.require_adapter.unwrap_or_default(),
+                    resource.require_adapter.unwrap_or_default().to_string(),
                     resource.description.unwrap_or_default()
                 ]);
             }
diff --git a/lib/dsc-lib/src/dscresources/command_resource.rs b/lib/dsc-lib/src/dscresources/command_resource.rs
@@ -7,7 +7,7 @@ use rust_i18n::t;
 use serde::Deserialize;
 use serde_json::{Map, Value};
 use std::{collections::HashMap, env, path::Path, process::Stdio};
-use crate::{configure::{config_doc::ExecutionKind, config_result::{ResourceGetResult, ResourceTestResult}}, util::canonicalize_which};
+use crate::{configure::{config_doc::ExecutionKind, config_result::{ResourceGetResult, ResourceTestResult}}, types::FullyQualifiedTypeName, util::canonicalize_which};
 use crate::dscerror::DscError;
 use super::{dscresource::{get_diff, redact}, invoke_result::{ExportResult, GetResult, ResolveResult, SetResult, TestResult, ValidateResult, ResourceGetResponse, ResourceSetResponse, ResourceTestResponse, get_in_desired_state}, resource_manifest::{ArgKind, InputKind, Kind, ResourceManifest, ReturnKind, SchemaKind}};
 use tracing::{error, warn, info, debug, trace};
@@ -25,17 +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: &Path, filter: &str, target_resource: Option<&str>) -> Result<GetResult, DscError> {
+pub fn invoke_get(resource: &ResourceManifest, cwd: &Path, filter: &str, target_resource: Option<FullyQualifiedTypeName>) -> 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 resource_type = match target_resource {
         Some(r) => r,
-        None => &resource.resource_type,
+        None => resource.resource_type.clone(),
     };
-    let args = process_args(get.args.as_ref(), filter, 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)?;
@@ -78,7 +78,7 @@ pub fn invoke_get(resource: &ResourceManifest, cwd: &Path, filter: &str, target_
 ///
 /// Error returned if the resource does not successfully set the desired state
 #[allow(clippy::too_many_lines)]
-pub fn invoke_set(resource: &ResourceManifest, cwd: &Path, desired: &str, skip_test: bool, execution_type: &ExecutionKind, target_resource: Option<&str>) -> Result<SetResult, DscError> {
+pub fn invoke_set(resource: &ResourceManifest, cwd: &Path, desired: &str, skip_test: bool, execution_type: &ExecutionKind, target_resource: Option<FullyQualifiedTypeName>) -> Result<SetResult, DscError> {
     debug!("{}", t!("dscresources.commandResource.invokeSet", resource = &resource.resource_type));
     let operation_type: String;
     let mut is_synthetic_what_if = false;
@@ -105,7 +105,7 @@ pub fn invoke_set(resource: &ResourceManifest, cwd: &Path, desired: &str, skip_t
     // 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, target_resource)?;
+        let test_result = invoke_test(resource, cwd, desired, target_resource.clone())?;
         if is_synthetic_what_if {
             return Ok(test_result.into());
         }
@@ -140,11 +140,11 @@ pub fn invoke_set(resource: &ResourceManifest, cwd: &Path, desired: &str, skip_t
     let Some(get) = &resource.get else {
         return Err(DscError::NotImplemented("get".to_string()));
     };
-    let resource_type = match target_resource {
+    let resource_type = match target_resource.clone() {
         Some(r) => r,
-        None => &resource.resource_type,
+        None => resource.resource_type.clone(),
     };
-    let args = process_args(get.args.as_ref(), desired, 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));
@@ -176,7 +176,7 @@ pub fn invoke_set(resource: &ResourceManifest, cwd: &Path, desired: &str, skip_t
 
     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_type);
+    let args = process_args(set.args.as_ref(), desired, &resource_type);
     match &set.input {
         Some(InputKind::Env) => {
             env = Some(json_to_hashmap(desired)?);
@@ -271,7 +271,7 @@ pub fn invoke_set(resource: &ResourceManifest, cwd: &Path, desired: &str, skip_t
 /// # Errors
 ///
 /// Error is returned if the underlying command returns a non-zero exit code.
-pub fn invoke_test(resource: &ResourceManifest, cwd: &Path, expected: &str, target_resource: Option<&str>) -> Result<TestResult, DscError> {
+pub fn invoke_test(resource: &ResourceManifest, cwd: &Path, expected: &str, target_resource: Option<FullyQualifiedTypeName>) -> 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));
@@ -280,11 +280,11 @@ pub fn invoke_test(resource: &ResourceManifest, cwd: &Path, expected: &str, targ
 
     verify_json(resource, cwd, expected)?;
 
-    let resource_type = match target_resource {
+    let resource_type = match target_resource.clone() {
         Some(r) => r,
-        None => &resource.resource_type,
+        None => resource.resource_type.clone(),
     };
-    let args = process_args(test.args.as_ref(), expected, 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));
@@ -380,7 +380,7 @@ fn get_desired_state(actual: &Value) -> Result<Option<bool>, DscError> {
     Ok(in_desired_state)
 }
 
-fn invoke_synthetic_test(resource: &ResourceManifest, cwd: &Path, expected: &str, target_resource: Option<&str>) -> Result<TestResult, DscError> {
+fn invoke_synthetic_test(resource: &ResourceManifest, cwd: &Path, expected: &str, target_resource: Option<FullyQualifiedTypeName>) -> Result<TestResult, DscError> {
     let get_result = invoke_get(resource, cwd, expected, target_resource)?;
     let actual_state = match get_result {
         GetResult::Group(results) => {
@@ -511,7 +511,7 @@ pub fn get_schema(resource: &ResourceManifest, cwd: &Path) -> Result<String, Dsc
 /// # Errors
 ///
 /// Error returned if the resource does not successfully export the current state
-pub fn invoke_export(resource: &ResourceManifest, cwd: &Path, input: Option<&str>, target_resource: Option<&str>) -> Result<ExportResult, DscError> {
+pub fn invoke_export(resource: &ResourceManifest, cwd: &Path, input: Option<&str>, target_resource: Option<FullyQualifiedTypeName>) -> 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() {
@@ -540,7 +540,7 @@ pub fn invoke_export(resource: &ResourceManifest, cwd: &Path, input: Option<&str
     let args: Option<Vec<String>>;
     let resource_type = match target_resource {
         Some(r) => r,
-        None => &resource.resource_type,
+        None => resource.resource_type.clone(),
     };
     if let Some(input) = input {
         if !input.is_empty() {
@@ -549,9 +549,9 @@ pub fn invoke_export(resource: &ResourceManifest, cwd: &Path, input: Option<&str
             command_input = get_command_input(export.input.as_ref(), input)?;
         }
 
-        args = process_args(export.args.as_ref(), input, resource_type);
+        args = process_args(export.args.as_ref(), input, &resource_type);
     } else {
-        args = process_args(export.args.as_ref(), "", 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())?;
diff --git a/lib/dsc-lib/src/dscresources/dscresource.rs b/lib/dsc-lib/src/dscresources/dscresource.rs
@@ -57,7 +57,7 @@ pub struct DscResource {
     #[serde(rename="requireAdapter")]
     pub require_adapter: Option<FullyQualifiedTypeName>,
     /// The target resource for the resource adapter.
-    pub target_resource: Option<String>,
+    pub target_resource: Option<FullyQualifiedTypeName>,
     /// The manifest of the resource.
     pub manifest: Option<Value>,
 }
@@ -140,11 +140,11 @@ impl DscResource {
         Ok(configurator)
     }
 
-    fn invoke_get_with_adapter(&self, adapter: &FullyQualifiedTypeName, resource_name: &str, filter: &str) -> Result<GetResult, DscError> {
+    fn invoke_get_with_adapter(&self, adapter: &FullyQualifiedTypeName, resource_name: &FullyQualifiedTypeName, filter: &str) -> Result<GetResult, DscError> {
         let mut configurator = self.clone().create_config_for_adapter(adapter, filter)?;
         let mut adapter = Self::get_adapter_resource(&mut configurator, adapter)?;
         if get_adapter_input_kind(&adapter)? == AdapterInputKind::Single {
-            adapter.target_resource = Some(resource_name.to_string());
+            adapter.target_resource = Some(resource_name.clone());
             return adapter.get(filter);
         }
 
@@ -164,11 +164,11 @@ impl DscResource {
         Ok(get_result)
     }
 
-    fn invoke_set_with_adapter(&self, adapter: &FullyQualifiedTypeName, resource_name: &str, desired: &str, skip_test: bool, execution_type: &ExecutionKind) -> Result<SetResult, DscError> {
+    fn invoke_set_with_adapter(&self, adapter: &FullyQualifiedTypeName, resource_name: &FullyQualifiedTypeName, desired: &str, skip_test: bool, execution_type: &ExecutionKind) -> Result<SetResult, DscError> {
         let mut configurator = self.clone().create_config_for_adapter(adapter, desired)?;
         let mut adapter = Self::get_adapter_resource(&mut configurator, adapter)?;
         if get_adapter_input_kind(&adapter)? == AdapterInputKind::Single {
-            adapter.target_resource = Some(resource_name.to_string());
+            adapter.target_resource = Some(resource_name.clone());
             return adapter.set(desired, skip_test, execution_type);
         }
 
@@ -197,11 +197,11 @@ impl DscResource {
         Ok(set_result)
     }
 
-    fn invoke_test_with_adapter(&self, adapter: &FullyQualifiedTypeName, resource_name: &str, expected: &str) -> Result<TestResult, DscError> {
+    fn invoke_test_with_adapter(&self, adapter: &FullyQualifiedTypeName, resource_name: &FullyQualifiedTypeName, expected: &str) -> Result<TestResult, DscError> {
         let mut configurator = self.clone().create_config_for_adapter(adapter, expected)?;
         let mut adapter = Self::get_adapter_resource(&mut configurator, adapter)?;
         if get_adapter_input_kind(&adapter)? == AdapterInputKind::Single {
-            adapter.target_resource = Some(resource_name.to_string());
+            adapter.target_resource = Some(resource_name.clone());
             return adapter.test(expected);
         }
 
@@ -231,12 +231,12 @@ impl DscResource {
         Ok(test_result)
     }
 
-    fn invoke_delete_with_adapter(&self, adapter: &FullyQualifiedTypeName, resource_name: &str, filter: &str) -> Result<(), DscError> {
+    fn invoke_delete_with_adapter(&self, adapter: &FullyQualifiedTypeName, resource_name: &FullyQualifiedTypeName, filter: &str) -> Result<(), DscError> {
         let mut configurator = self.clone().create_config_for_adapter(adapter, filter)?;
         let mut adapter = Self::get_adapter_resource(&mut configurator, adapter)?;
         if get_adapter_input_kind(&adapter)? == AdapterInputKind::Single {
             if adapter.capabilities.contains(&Capability::Delete) {
-                adapter.target_resource = Some(resource_name.to_string());
+                adapter.target_resource = Some(resource_name.clone());
                 return adapter.delete(filter);
             }
             return Err(DscError::NotSupported(t!("dscresources.dscresource.adapterDoesNotSupportDelete", adapter = adapter.type_name).to_string()));
@@ -250,7 +250,7 @@ impl DscResource {
         let mut configurator = self.clone().create_config_for_adapter(adapter, input)?;
         let mut adapter = Self::get_adapter_resource(&mut configurator, adapter)?;
         if get_adapter_input_kind(&adapter)? == AdapterInputKind::Single {
-            adapter.target_resource = Some(self.type_name.to_string());
+            adapter.target_resource = Some(self.type_name.clone());
             return adapter.export(input);
         }
 
@@ -394,7 +394,7 @@ impl Invoke for DscResource {
                     return Err(DscError::MissingManifest(self.type_name.to_string()));
                 };
                 let resource_manifest = import_manifest(manifest.clone())?;
-                command_resource::invoke_get(&resource_manifest, &self.directory, filter, self.target_resource.as_deref())
+                command_resource::invoke_get(&resource_manifest, &self.directory, filter, self.target_resource.clone())
             },
         }
     }
@@ -414,7 +414,7 @@ impl Invoke for DscResource {
                     return Err(DscError::MissingManifest(self.type_name.to_string()));
                 };
                 let resource_manifest = import_manifest(manifest.clone())?;
-                command_resource::invoke_set(&resource_manifest, &self.directory, desired, skip_test, execution_type, self.target_resource.as_deref())
+                command_resource::invoke_set(&resource_manifest, &self.directory, desired, skip_test, execution_type, self.target_resource.clone())
             },
         }
     }
@@ -462,7 +462,7 @@ impl Invoke for DscResource {
                     Ok(test_result)
                 }
                 else {
-                    command_resource::invoke_test(&resource_manifest, &self.directory, expected, self.target_resource.as_deref())
+                    command_resource::invoke_test(&resource_manifest, &self.directory, expected, self.target_resource.clone())
                 }
             },
         }
@@ -538,7 +538,7 @@ impl Invoke for DscResource {
             return Err(DscError::MissingManifest(self.type_name.to_string()));
         };
         let resource_manifest = import_manifest(manifest.clone())?;
-        command_resource::invoke_export(&resource_manifest, &self.directory, Some(input), self.target_resource.as_deref())
+        command_resource::invoke_export(&resource_manifest, &self.directory, Some(input), self.target_resource.clone())
     }
 
     fn resolve(&self, input: &str) -> Result<ResolveResult, DscError> {
diff --git a/tools/test_group_resource/src/main.rs b/tools/test_group_resource/src/main.rs
@@ -25,7 +25,7 @@ fn main() {
                 directory: PathBuf::from("test_directory"),
                 author: Some("Microsoft".to_string()),
                 properties: vec!["Property1".to_string(), "Property2".to_string()],
-                require_adapter: Some("Test/TestGroup".to_string()),
+                require_adapter: Some("Test/TestGroup".parse().unwrap()),
                 target_resource: None,
                 manifest: Some(serde_json::to_value(ResourceManifest {
                     description: Some("This is a test resource.".to_string()),
@@ -51,7 +51,7 @@ fn main() {
                 directory: PathBuf::from("test_directory"),
                 author: Some("Microsoft".to_string()),
                 properties: vec!["Property1".to_string(), "Property2".to_string()],
-                require_adapter: Some("Test/TestGroup".to_string()),
+                require_adapter: Some("Test/TestGroup".parse().unwrap()),
                 target_resource: None,
                 manifest: Some(serde_json::to_value(ResourceManifest {
                     description: Some("This is a test resource.".to_string()),

Original file line number	Diff line number	Diff line change
`@@ -70,7 +70,7 @@ impl McpServer {`
`70`	`70`	`r#type: resource.type_name.to_string(),`
`71`	`71`	`kind: resource.kind.clone(),`
`72`	`72`	`description: resource.description.clone(),`
`73`		`- require_adapter: resource.require_adapter.clone(),`
	`73`	`+ require_adapter: resource.require_adapter.map(\|fqtn\| fqtn.to_string()),`
`74`	`74`	`};`
`75`	`75`	`resources.insert(resource.type_name.to_lowercase(), summary);`
`76`	`76`	`}`
Original file line number	Diff line number	Diff line change
`@@ -824,7 +824,7 @@ pub fn list_resources(dsc: &mut DscManager, resource_name: Option<&String>, adap`
`824`	`824`	`format!("{:?}", resource.kind),`
`825`	`825`	`resource.version,`
`826`	`826`	`capabilities,`
`827`		`- resource.require_adapter.unwrap_or_default(),`
	`827`	`+ resource.require_adapter.unwrap_or_default().to_string(),`
`828`	`828`	`resource.description.unwrap_or_default()`
`829`	`829`	`]);`
`830`	`830`	`}`
Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ pub struct DscResource {`
`57`	`57`	`#[serde(rename="requireAdapter")]`
`58`	`58`	`pub require_adapter: Option<FullyQualifiedTypeName>,`
`59`	`59`	`/// The target resource for the resource adapter.`
`60`		`- pub target_resource: Option<String>,`
	`60`	`+ pub target_resource: Option<FullyQualifiedTypeName>,`
`61`	`61`	`/// The manifest of the resource.`
`62`	`62`	`pub manifest: Option<Value>,`
`63`	`63`	`}`
`@@ -140,11 +140,11 @@ impl DscResource {`
`140`	`140`	`Ok(configurator)`
`141`	`141`	`}`
`142`	`142`
`143`		`- fn invoke_get_with_adapter(&self, adapter: &FullyQualifiedTypeName, resource_name: &str, filter: &str) -> Result<GetResult, DscError> {`
	`143`	`+ fn invoke_get_with_adapter(&self, adapter: &FullyQualifiedTypeName, resource_name: &FullyQualifiedTypeName, filter: &str) -> Result<GetResult, DscError> {`
`144`	`144`	`let mut configurator = self.clone().create_config_for_adapter(adapter, filter)?;`
`145`	`145`	`let mut adapter = Self::get_adapter_resource(&mut configurator, adapter)?;`
`146`	`146`	`if get_adapter_input_kind(&adapter)? == AdapterInputKind::Single {`
`147`		`- adapter.target_resource = Some(resource_name.to_string());`
	`147`	`+ adapter.target_resource = Some(resource_name.clone());`
`148`	`148`	`return adapter.get(filter);`
`149`	`149`	`}`
`150`	`150`
`@@ -164,11 +164,11 @@ impl DscResource {`
`164`	`164`	`Ok(get_result)`
`165`	`165`	`}`
`166`	`166`
`167`		`- fn invoke_set_with_adapter(&self, adapter: &FullyQualifiedTypeName, resource_name: &str, desired: &str, skip_test: bool, execution_type: &ExecutionKind) -> Result<SetResult, DscError> {`
	`167`	`+ fn invoke_set_with_adapter(&self, adapter: &FullyQualifiedTypeName, resource_name: &FullyQualifiedTypeName, desired: &str, skip_test: bool, execution_type: &ExecutionKind) -> Result<SetResult, DscError> {`
`168`	`168`	`let mut configurator = self.clone().create_config_for_adapter(adapter, desired)?;`
`169`	`169`	`let mut adapter = Self::get_adapter_resource(&mut configurator, adapter)?;`
`170`	`170`	`if get_adapter_input_kind(&adapter)? == AdapterInputKind::Single {`
`171`		`- adapter.target_resource = Some(resource_name.to_string());`
	`171`	`+ adapter.target_resource = Some(resource_name.clone());`
`172`	`172`	`return adapter.set(desired, skip_test, execution_type);`
`173`	`173`	`}`
`174`	`174`
`@@ -197,11 +197,11 @@ impl DscResource {`
`197`	`197`	`Ok(set_result)`
`198`	`198`	`}`
`199`	`199`
`200`		`- fn invoke_test_with_adapter(&self, adapter: &FullyQualifiedTypeName, resource_name: &str, expected: &str) -> Result<TestResult, DscError> {`
	`200`	`+ fn invoke_test_with_adapter(&self, adapter: &FullyQualifiedTypeName, resource_name: &FullyQualifiedTypeName, expected: &str) -> Result<TestResult, DscError> {`
`201`	`201`	`let mut configurator = self.clone().create_config_for_adapter(adapter, expected)?;`
`202`	`202`	`let mut adapter = Self::get_adapter_resource(&mut configurator, adapter)?;`
`203`	`203`	`if get_adapter_input_kind(&adapter)? == AdapterInputKind::Single {`
`204`		`- adapter.target_resource = Some(resource_name.to_string());`
	`204`	`+ adapter.target_resource = Some(resource_name.clone());`
`205`	`205`	`return adapter.test(expected);`
`206`	`206`	`}`
`207`	`207`
`@@ -231,12 +231,12 @@ impl DscResource {`
`231`	`231`	`Ok(test_result)`
`232`	`232`	`}`
`233`	`233`
`234`		`- fn invoke_delete_with_adapter(&self, adapter: &FullyQualifiedTypeName, resource_name: &str, filter: &str) -> Result<(), DscError> {`
	`234`	`+ fn invoke_delete_with_adapter(&self, adapter: &FullyQualifiedTypeName, resource_name: &FullyQualifiedTypeName, filter: &str) -> Result<(), DscError> {`
`235`	`235`	`let mut configurator = self.clone().create_config_for_adapter(adapter, filter)?;`
`236`	`236`	`let mut adapter = Self::get_adapter_resource(&mut configurator, adapter)?;`
`237`	`237`	`if get_adapter_input_kind(&adapter)? == AdapterInputKind::Single {`
`238`	`238`	`if adapter.capabilities.contains(&Capability::Delete) {`
`239`		`- adapter.target_resource = Some(resource_name.to_string());`
	`239`	`+ adapter.target_resource = Some(resource_name.clone());`
`240`	`240`	`return adapter.delete(filter);`
`241`	`241`	`}`
`242`	`242`	`return Err(DscError::NotSupported(t!("dscresources.dscresource.adapterDoesNotSupportDelete", adapter = adapter.type_name).to_string()));`
`@@ -250,7 +250,7 @@ impl DscResource {`
`250`	`250`	`let mut configurator = self.clone().create_config_for_adapter(adapter, input)?;`
`251`	`251`	`let mut adapter = Self::get_adapter_resource(&mut configurator, adapter)?;`
`252`	`252`	`if get_adapter_input_kind(&adapter)? == AdapterInputKind::Single {`
`253`		`- adapter.target_resource = Some(self.type_name.to_string());`
	`253`	`+ adapter.target_resource = Some(self.type_name.clone());`
`254`	`254`	`return adapter.export(input);`
`255`	`255`	`}`
`256`	`256`
`@@ -394,7 +394,7 @@ impl Invoke for DscResource {`
`394`	`394`	`return Err(DscError::MissingManifest(self.type_name.to_string()));`
`395`	`395`	`};`
`396`	`396`	`let resource_manifest = import_manifest(manifest.clone())?;`
`397`		`- command_resource::invoke_get(&resource_manifest, &self.directory, filter, self.target_resource.as_deref())`
	`397`	`+ command_resource::invoke_get(&resource_manifest, &self.directory, filter, self.target_resource.clone())`
`398`	`398`	`},`
`399`	`399`	`}`
`400`	`400`	`}`
`@@ -414,7 +414,7 @@ impl Invoke for DscResource {`
`414`	`414`	`return Err(DscError::MissingManifest(self.type_name.to_string()));`
`415`	`415`	`};`
`416`	`416`	`let resource_manifest = import_manifest(manifest.clone())?;`
`417`		`- command_resource::invoke_set(&resource_manifest, &self.directory, desired, skip_test, execution_type, self.target_resource.as_deref())`
	`417`	`+ command_resource::invoke_set(&resource_manifest, &self.directory, desired, skip_test, execution_type, self.target_resource.clone())`
`418`	`418`	`},`
`419`	`419`	`}`
`420`	`420`	`}`
`@@ -462,7 +462,7 @@ impl Invoke for DscResource {`
`462`	`462`	`Ok(test_result)`
`463`	`463`	`}`
`464`	`464`	`else {`
`465`		`- command_resource::invoke_test(&resource_manifest, &self.directory, expected, self.target_resource.as_deref())`
	`465`	`+ command_resource::invoke_test(&resource_manifest, &self.directory, expected, self.target_resource.clone())`
`466`	`466`	`}`
`467`	`467`	`},`
`468`	`468`	`}`
`@@ -538,7 +538,7 @@ impl Invoke for DscResource {`
`538`	`538`	`return Err(DscError::MissingManifest(self.type_name.to_string()));`
`539`	`539`	`};`
`540`	`540`	`let resource_manifest = import_manifest(manifest.clone())?;`
`541`		`- command_resource::invoke_export(&resource_manifest, &self.directory, Some(input), self.target_resource.as_deref())`
	`541`	`+ command_resource::invoke_export(&resource_manifest, &self.directory, Some(input), self.target_resource.clone())`
`542`	`542`	`}`
`543`	`543`
`544`	`544`	`fn resolve(&self, input: &str) -> Result<ResolveResult, DscError> {`