fix clippy

Author: SteveL-MSFT

dsc_lib/src/configure/mod.rs

@@ -6,11 +6,10 @@ use crate::configure::context::{Context, ProcessMode};
 use crate::configure::{config_doc::RestartRequired, parameters::Input};
 use crate::discovery::discovery_trait::DiscoveryFilter;
 use crate::dscerror::DscError;
-use crate::dscresources::invoke_result::ExportResult;
 use crate::dscresources::{
-    {dscresource::{Capability, Invoke, get_diff, validate_properties},
-    invoke_result::{GetResult, SetResult, TestResult,  ResourceSetResponse}},
-    resource_manifest::Kind,
+    {dscresource::{Capability, Invoke, get_diff, validate_properties, get_adapter_input_kind},
+    invoke_result::{GetResult, SetResult, TestResult, ExportResult, ResourceSetResponse}},
+    resource_manifest::{AdapterInputKind, Kind},
 };
 use crate::DscResource;
 use crate::discovery::Discovery;
@@ -177,7 +176,7 @@ fn escape_property_values(properties: &Map<String, Value>) -> Result<Option<Map<
 }
 
 fn add_metadata(dsc_resource: &DscResource, mut properties: Option<Map<String, Value>>, resource_metadata: Option<Metadata> ) -> Result<String, DscError> {
-    if dsc_resource.kind == Kind::Adapter {
+    if dsc_resource.kind == Kind::Adapter && get_adapter_input_kind(dsc_resource)? == AdapterInputKind::Full {
         // add metadata to the properties so the adapter knows this is a config
         let mut metadata: Map<String, Value> = Map::new();
         if let Some(resource_metadata) = resource_metadata {
@@ -319,6 +318,15 @@ impl Configurator {
         &self.config
     }
 
+    /// Get the discovery.
+    ///
+    /// # Returns
+    ///
+    /// * `&Discovery` - The discovery.
+    pub fn discovery(&mut self) -> &mut Discovery {
+        &mut self.discovery
+    }
+
     fn get_properties(&mut self, resource: &Resource, resource_kind: &Kind) -> Result<Option<Map<String, Value>>, DscError> {
         match resource_kind {
             Kind::Group => {
@@ -342,14 +350,14 @@ impl Configurator {
     /// This function will return an error if the underlying resource fails.
     pub fn invoke_get(&mut self) -> Result<ConfigurationGetResult, DscError> {
         self.unroll_copy_loops()?;
-        
+
         let mut result = ConfigurationGetResult::new();
         let resources = get_resource_invocation_order(&self.config, &mut self.statement_parser, &self.context)?;
         let mut progress = ProgressBar::new(resources.len() as u64, self.progress_format)?;
         let discovery = &mut self.discovery.clone();
         for resource in resources {
             let evaluated_name = self.evaluate_resource_name(&resource.name)?;
-            
+
             progress.set_resource(&evaluated_name, &resource.resource_type);
             progress.write_activity(format!("Get '{evaluated_name}'").as_str());
             if self.skip_resource(&resource)? {
@@ -424,14 +432,14 @@ impl Configurator {
     #[allow(clippy::too_many_lines)]
     pub fn invoke_set(&mut self, skip_test: bool) -> Result<ConfigurationSetResult, DscError> {
         self.unroll_copy_loops()?;
-        
+
         let mut result = ConfigurationSetResult::new();
         let resources = get_resource_invocation_order(&self.config, &mut self.statement_parser, &self.context)?;
         let mut progress = ProgressBar::new(resources.len() as u64, self.progress_format)?;
         let discovery = &mut self.discovery.clone();
         for resource in resources {
             let evaluated_name = self.evaluate_resource_name(&resource.name)?;
-            
+
             progress.set_resource(&evaluated_name, &resource.resource_type);
             progress.write_activity(format!("Set '{evaluated_name}'").as_str());
             if self.skip_resource(&resource)? {
@@ -580,14 +588,14 @@ impl Configurator {
     /// This function will return an error if the underlying resource fails.
     pub fn invoke_test(&mut self) -> Result<ConfigurationTestResult, DscError> {
         self.unroll_copy_loops()?;
-        
+
         let mut result = ConfigurationTestResult::new();
         let resources = get_resource_invocation_order(&self.config, &mut self.statement_parser, &self.context)?;
         let mut progress = ProgressBar::new(resources.len() as u64, self.progress_format)?;
         let discovery = &mut self.discovery.clone();
         for resource in resources {
             let evaluated_name = self.evaluate_resource_name(&resource.name)?;
-            
+
             progress.set_resource(&evaluated_name, &resource.resource_type);
             progress.write_activity(format!("Test '{evaluated_name}'").as_str());
             if self.skip_resource(&resource)? {
@@ -658,7 +666,7 @@ impl Configurator {
     /// This function will return an error if the underlying resource fails.
     pub fn invoke_export(&mut self) -> Result<ConfigurationExportResult, DscError> {
         self.unroll_copy_loops()?;
-        
+
         let mut result = ConfigurationExportResult::new();
         let mut conf = config_doc::Configuration::new();
         conf.metadata.clone_from(&self.config.metadata);
@@ -668,7 +676,7 @@ impl Configurator {
         let discovery = &mut self.discovery.clone();
         for resource in &resources {
             let evaluated_name = self.evaluate_resource_name(&resource.name)?;
-            
+
             progress.set_resource(&evaluated_name, &resource.resource_type);
             progress.write_activity(format!("Export '{evaluated_name}'").as_str());
             if self.skip_resource(resource)? {
@@ -916,7 +924,7 @@ impl Configurator {
     fn unroll_copy_loops(&mut self) -> Result<(), DscError> {
         let mut config = self.config.clone();
         let config_copy = config.clone();
-        
+
         for resource in config_copy.resources {
             // if the resource contains `Copy`, unroll it
             if let Some(copy) = &resource.copy {
@@ -931,7 +939,7 @@ impl Configurator {
                         return Err(DscError::Parser(t!("configure.mod.copyNameResultNotString").to_string()))
                     };
                     new_resource.name = new_name.to_string();
-                    
+
                     new_resource.copy = None;
                     copy_resources.push(new_resource);
                 }
@@ -941,7 +949,7 @@ impl Configurator {
                 config.resources.extend(copy_resources);
             }
         }
-        
+
         self.config = config;
         Ok(())
     }
@@ -967,12 +975,12 @@ impl Configurator {
         if self.context.process_mode == ProcessMode::Copy {
             return Ok(name.to_string());
         }
-        
+
         // evaluate the resource name (handles both expressions and literals)
         let Value::String(evaluated_name) = self.statement_parser.parse_and_execute(name, &self.context)? else {
             return Err(DscError::Parser(t!("configure.mod.nameResultNotString").to_string()))
         };
-        
+
         Ok(evaluated_name)
     }
 

dsc_lib/src/dscresources/command_resource.rs

@@ -31,7 +31,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.as_ref(), filter);
+    let args = process_args(get.args.as_ref(), filter, &resource.resource_type);
     if !filter.is_empty() {
         verify_json(resource, cwd, filter)?;
         command_input = get_command_input(get.input.as_ref(), filter)?;
@@ -136,7 +136,7 @@ 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);
+    let args = process_args(get.args.as_ref(), desired, &resource.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 +168,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);
+    let args = process_args(set.args.as_ref(), desired, &resource.resource_type);
     match &set.input {
         Some(InputKind::Env) => {
             env = Some(json_to_hashmap(desired)?);
@@ -272,7 +272,7 @@ pub fn invoke_test(resource: &ResourceManifest, cwd: &str, expected: &str) -> Re
 
     verify_json(resource, cwd, expected)?;
 
-    let args = process_args(test.args.as_ref(), expected);
+    let args = process_args(test.args.as_ref(), expected, &resource.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));
@@ -410,7 +410,7 @@ pub fn invoke_delete(resource: &ResourceManifest, cwd: &str, filter: &str) -> Re
 
     verify_json(resource, cwd, filter)?;
 
-    let args = process_args(delete.args.as_ref(), filter);
+    let args = process_args(delete.args.as_ref(), filter, &resource.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));
@@ -441,7 +441,7 @@ pub fn invoke_validate(resource: &ResourceManifest, cwd: &str, config: &str) ->
         return Err(DscError::NotImplemented("validate".to_string()));
     };
 
-    let args = process_args(validate.args.as_ref(), config);
+    let args = process_args(validate.args.as_ref(), config, &resource.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));
@@ -525,9 +525,9 @@ pub fn invoke_export(resource: &ResourceManifest, cwd: &str, input: Option<&str>
             command_input = get_command_input(export.input.as_ref(), input)?;
         }
 
-        args = process_args(export.args.as_ref(), input);
+        args = process_args(export.args.as_ref(), input, &resource.resource_type);
     } else {
-        args = process_args(export.args.as_ref(), "");
+        args = process_args(export.args.as_ref(), "", &resource.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())?;
@@ -572,7 +572,7 @@ pub fn invoke_resolve(resource: &ResourceManifest, cwd: &str, input: &str) -> Re
         return Err(DscError::Operation(t!("dscresources.commandResource.resolveNotSupported", resource = &resource.resource_type).to_string()));
     };
 
-    let args = process_args(resolve.args.as_ref(), input);
+    let args = process_args(resolve.args.as_ref(), input, &resource.resource_type);
     let command_input = get_command_input(resolve.input.as_ref(), input)?;
 
     info!("{}", t!("dscresources.commandResource.invokeResolveUsing", resource = &resource.resource_type, executable = &resolve.executable));
@@ -749,7 +749,7 @@ pub async fn invoke_command(executable: &str, args: Option<Vec<String>>, input:
 /// # Returns
 ///
 /// A vector of strings representing the processed arguments
-pub fn process_args(args: Option<&Vec<ArgKind>>, value: &str) -> Option<Vec<String>> {
+pub fn process_args(args: Option<&Vec<ArgKind>>, input: &str, resource_type: &str) -> Option<Vec<String>> {
     let Some(arg_values) = args else {
         debug!("{}", t!("dscresources.commandResource.noArgs"));
         return None;
@@ -762,13 +762,17 @@ pub fn process_args(args: Option<&Vec<ArgKind>>, value: &str) -> Option<Vec<Stri
                 processed_args.push(s.clone());
             },
             ArgKind::Json { json_input_arg, mandatory } => {
-                if value.is_empty() && *mandatory != Some(true) {
+                if input.is_empty() && *mandatory != Some(true) {
                     continue;
                 }
 
                 processed_args.push(json_input_arg.clone());
-                processed_args.push(value.to_string());
+                processed_args.push(input.to_string());
             },
+            ArgKind::ResourceType { resource_type_arg } => {
+                processed_args.push(resource_type_arg.clone());
+                processed_args.push(resource_type.to_string());
+            }
         }
     }
 

dsc_lib/src/dscresources/dscresource.rs

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-use crate::{configure::{Configurator, config_doc::{Configuration, ExecutionKind, Resource}, context::ProcessMode, parameters::{SECURE_VALUE_REDACTED, is_secure_value}}, dscresources::resource_manifest::Kind};
+use crate::{configure::{Configurator, config_doc::{Configuration, ExecutionKind, Resource}, context::ProcessMode, parameters::{SECURE_VALUE_REDACTED, is_secure_value}}, dscresources::resource_manifest::{AdapterInputKind, Kind}};
 use crate::dscresources::invoke_result::{ResourceGetResponse, ResourceSetResponse};
 use dscerror::DscError;
 use jsonschema::Validator;
@@ -129,6 +129,36 @@ impl DscResource {
         configurator.context.process_mode = ProcessMode::NoExpressionEvaluation;
         Ok(configurator)
     }
+
+    fn invoke_get_with_adapter(&self, adapter: &str, filter: &str) -> Result<GetResult, DscError> {
+        let mut configurator = self.clone().create_config_for_adapter(adapter, filter)?;
+        let adapter = Self::get_adapter_resource(&mut configurator, adapter)?;
+        if get_adapter_input_kind(&adapter)? == AdapterInputKind::Single {
+            return adapter.get(filter);
+        }
+
+        let result = configurator.invoke_get()?;
+        let GetResult::Resource(ref resource_result) = result.results[0].result else {
+            return Err(DscError::Operation(t!("dscresources.dscresource.invokeReturnedWrongResult", operation = "get", resource = self.type_name).to_string()));
+        };
+        let properties = resource_result.actual_state
+            .as_object().ok_or(DscError::Operation(t!("dscresources.dscresource.propertyIncorrectType", property = "actualState", property_type = "object").to_string()))?
+            .get("result").ok_or(DscError::Operation(t!("dscresources.dscresource.propertyNotFound", property = "result").to_string()))?
+            .as_array().ok_or(DscError::Operation(t!("dscresources.dscresource.propertyIncorrectType", property = "result", property_type = "array").to_string()))?[0]
+            .as_object().ok_or(DscError::Operation(t!("dscresources.dscresource.propertyIncorrectType", property = "result", property_type = "object").to_string()))?
+            .get("properties").ok_or(DscError::Operation(t!("dscresources.dscresource.propertyNotFound", property = "properties").to_string()))?.clone();
+        let get_result = GetResult::Resource(ResourceGetResponse {
+            actual_state: properties.clone(),
+        });
+        Ok(get_result)
+    }
+
+    fn get_adapter_resource(configurator: &mut Configurator, adapter: &str) -> Result<DscResource, DscError> {
+        if let Some(adapter_resource) = configurator.discovery().find_resource(adapter, None) {
+            return Ok(adapter_resource.clone());
+        }
+        Err(DscError::Operation(t!("dscresources.dscresource.adapterResourceNotFound", adapter = adapter).to_string()))
+    }
 }
 
 impl Default for DscResource {
@@ -229,21 +259,7 @@ impl Invoke for DscResource {
     fn get(&self, filter: &str) -> Result<GetResult, DscError> {
         debug!("{}", t!("dscresources.dscresource.invokeGet", resource = self.type_name));
         if let Some(adapter) = &self.require_adapter {
-            let mut configurator = self.clone().create_config_for_adapter(adapter, filter)?;
-            let result = configurator.invoke_get()?;
-            let GetResult::Resource(ref resource_result) = result.results[0].result else {
-                return Err(DscError::Operation(t!("dscresources.dscresource.invokeReturnedWrongResult", operation = "get", resource = self.type_name).to_string()));
-            };
-            let properties = resource_result.actual_state
-                .as_object().ok_or(DscError::Operation(t!("dscresources.dscresource.propertyIncorrectType", property = "actualState", property_type = "object").to_string()))?
-                .get("result").ok_or(DscError::Operation(t!("dscresources.dscresource.propertyNotFound", property = "result").to_string()))?
-                .as_array().ok_or(DscError::Operation(t!("dscresources.dscresource.propertyIncorrectType", property = "result", property_type = "array").to_string()))?[0]
-                .as_object().ok_or(DscError::Operation(t!("dscresources.dscresource.propertyIncorrectType", property = "result", property_type = "object").to_string()))?
-                .get("properties").ok_or(DscError::Operation(t!("dscresources.dscresource.propertyNotFound", property = "properties").to_string()))?.clone();
-            let get_result = GetResult::Resource(ResourceGetResponse {
-                actual_state: properties.clone(),
-            });
-            return Ok(get_result);
+            return self.invoke_get_with_adapter(adapter, filter);
         }
 
         match &self.implemented_as {
@@ -523,6 +539,28 @@ pub fn redact(value: &Value) -> Value {
     value.clone()
 }
 
+/// Gets the input kind for an adapter resource
+///
+/// # Arguments
+/// * `adapter` - The adapter resource to get the input kind for
+///
+/// # Returns
+/// * `Result<AdapterInputKind, DscError>` - The input kind of the adapter or an error if not found
+///
+/// # Errors
+/// * `DscError` - The adapter manifest is not found or invalid
+pub fn get_adapter_input_kind(adapter: &DscResource) -> Result<AdapterInputKind, DscError> {
+        if let Some(manifest) = &adapter.manifest {
+            if let Ok(manifest) = serde_json::from_value::<ResourceManifest>(manifest.clone()) {
+                if let Some(adapter_operation) = manifest.adapter {
+                    return Ok(adapter_operation.input_kind);
+                }
+            }
+        }
+        Err(DscError::Operation(t!("dscresources.dscresource.adapterManifestNotFound", adapter = adapter.type_name).to_string()))
+    }
+
+
 #[must_use]
 /// Performs a comparison of two JSON Values if the expected is a strict subset of the actual
 ///

dsc_lib/src/dscresources/resource_manifest.rs

@@ -86,6 +86,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>,
     },
+    ResourceType {
+        /// The argument that accepts the resource type name.
+        #[serde(rename = "resourceTypArg")]
+        resource_type_arg: String,
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
@@ -213,18 +218,22 @@ pub struct ResolveMethod {
 pub struct Adapter {
     /// The way to list adapter supported resources.
     pub list: ListMethod,
-    /// Defines how the adapter supports accepting configuraiton.
-    pub config: ConfigKind,
+    /// Defines how the adapter supports accepting configuration.
+    #[serde(alias = "config", rename = "inputKind")]
+    pub input_kind: AdapterInputKind,
 }
 
 #[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
-pub enum ConfigKind {
+pub enum AdapterInputKind {
     /// The adapter accepts full unprocessed configuration.
     #[serde(rename = "full")]
     Full,
     /// The adapter accepts configuration as a sequence.
     #[serde(rename = "sequence")]
     Sequence,
+    /// The adapter accepts a single resource input.
+    #[serde(rename = "single")]
+    Single,
 }
 
 #[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]