turn include into a group resource

SteveL-MSFT · SteveL-MSFT · commit 86ed4a8ae9f3 · 2024-07-16T10:29:03.000-07:00
diff --git a/dsc/include.dsc.resource.json b/dsc/include.dsc.resource.json
@@ -1,34 +1,55 @@
 {
-    "$schema": "https://raw.githubusercontent.com/PowerShell/DSC/main/schemas/2024/04/bundled/resource/manifest.json",
-    "type": "Microsoft.DSC/Include",
-    "version": "0.1.0",
-    "description": "Allows including a configuration file contents into current configuration.",
-    "kind": "Import",
-    "resolve": {
-      "executable": "dsc",
-      "args": [
-        "config",
-        "resolve"
-      ],
-      "input": "stdin"
-    },
-    "exitCodes": {
-      "0": "Success",
-      "1": "Invalid argument",
-      "2": "Resource error",
-      "3": "JSON Serialization error",
-      "4": "Invalid input format",
-      "5": "Resource instance failed schema validation",
-      "6": "Command cancelled"
-    },
-    "schema": {
-        "command": {
-            "executable": "dsc",
-            "args": [
-                "schema",
-                "--type",
-                "include"
-            ]
-        }
-    }
+  "$schema": "https://raw.githubusercontent.com/PowerShell/DSC/main/schemas/2024/04/bundled/resource/manifest.json",
+  "type": "Microsoft.DSC/Include",
+  "version": "0.1.0",
+  "description": "Allows including a configuration file with optional parameter file.",
+  "kind": "Group",
+  "get": {
+    "executable": "dsc",
+    "args": [
+      "config",
+      "--as-include",
+      "get"
+    ],
+    "input": "stdin"
+  },
+  "set": {
+    "executable": "dsc",
+    "args": [
+      "config",
+      "--as-include",
+      "set"
+    ],
+    "input": "stdin",
+    "implementsPretest": true,
+    "return": "state"
+  },
+  "test": {
+    "executable": "dsc",
+    "args": [
+      "config",
+      "--as-include",
+      "test"
+    ],
+    "input": "stdin",
+    "return": "state"
+  },
+  "exitCodes": {
+    "0": "Success",
+    "1": "Invalid argument",
+    "2": "Resource error",
+    "3": "JSON Serialization error",
+    "4": "Invalid input format",
+    "5": "Resource instance failed schema validation",
+    "6": "Command cancelled"
+  },
+  "validate": {
+    "executable": "dsc",
+    "args": [
+      "config",
+      "--as-include",
+      "validate"
+    ],
+    "input": "stdin"
   }
+}
diff --git a/dsc/src/args.rs b/dsc/src/args.rs
@@ -57,6 +57,9 @@ pub enum SubCommand {
         // Used to inform when DSC is used as a group resource to modify it's output
         #[clap(long, hide = true)]
         as_group: bool,
+        // Used to inform when DSC is used as a include group resource
+        #[clap(long, hide = true)]
+        as_include: bool,
     },
     #[clap(name = "resource", about = "Invoke a specific DSC resource")]
     Resource {
diff --git a/dsc/src/main.rs b/dsc/src/main.rs
@@ -69,19 +69,19 @@ fn main() {
             let mut cmd = Args::command();
             generate(shell, &mut cmd, "dsc", &mut io::stdout());
         },
-        SubCommand::Config { subcommand, parameters, parameters_file, as_group } => {
+        SubCommand::Config { subcommand, parameters, parameters_file, as_group, as_include } => {
             if let Some(file_name) = parameters_file {
                 info!("Reading parameters from file {file_name}");
                 match std::fs::read_to_string(&file_name) {
-                    Ok(parameters) => subcommand::config(&subcommand, &Some(parameters), &input, &as_group),
+                    Ok(parameters) => subcommand::config(&subcommand, &Some(parameters), &input, &as_group, &as_include),
                     Err(err) => {
                         error!("Error: Failed to read parameters file '{file_name}': {err}");
                         exit(util::EXIT_INVALID_INPUT);
                     }
                 }
             }
             else {
-                subcommand::config(&subcommand, &parameters, &input, &as_group);
+                subcommand::config(&subcommand, &parameters, &input, &as_group, &as_include);
             }
         },
         SubCommand::Resource { subcommand } => {
diff --git a/dsc/src/subcommand.rs b/dsc/src/subcommand.rs
@@ -7,7 +7,7 @@ use crate::resource_command::{get_resource, self};
 use crate::Stream;
 use crate::tablewriter::Table;
 use crate::util::{DSC_CONFIG_ROOT, EXIT_DSC_ERROR, EXIT_INVALID_INPUT, EXIT_JSON_ERROR, EXIT_VALIDATION_FAILED, get_schema, write_output, get_input, set_dscconfigroot, validate_json};
-use dsc_lib::configure::{Configurator, config_doc::ExecutionKind, config_result::ResourceGetResult};
+use dsc_lib::configure::{Configurator, config_doc::{Configuration, ExecutionKind}, config_result::ResourceGetResult};
 use dsc_lib::dscerror::DscError;
 use dsc_lib::dscresources::invoke_result::ResolveResult;
 use dsc_lib::{
@@ -186,15 +186,27 @@ fn initialize_config_root(path: &Option<String>) -> Option<String> {
 }
 
 #[allow(clippy::too_many_lines)]
-pub fn config(subcommand: &ConfigSubCommand, parameters: &Option<String>, stdin: &Option<String>, as_group: &bool) {
+pub fn config(subcommand: &ConfigSubCommand, parameters: &Option<String>, stdin: &Option<String>, as_group: &bool, as_include: &bool) {
     let (new_parameters, json_string) = match subcommand {
         ConfigSubCommand::Get { document, path, .. } |
         ConfigSubCommand::Set { document, path, .. } |
         ConfigSubCommand::Test { document, path, .. } |
         ConfigSubCommand::Validate { document, path, .. } |
         ConfigSubCommand::Export { document, path, .. } => {
             let new_path = initialize_config_root(path);
-            (None, get_input(document, stdin, &new_path))
+            let input = get_input(document, stdin, &new_path);
+            if *as_include {
+                let (new_parameters, config_json) = match get_contents(&input) {
+                    Ok((parameters, config_json)) => (parameters, config_json),
+                    Err(err) => {
+                        error!("{err}");
+                        exit(EXIT_DSC_ERROR);
+                    }
+                };
+                (new_parameters, config_json)
+            } else {
+                (None, input)
+            }
         },
         ConfigSubCommand::Resolve { document, path, .. } => {
             let new_path = initialize_config_root(path);
@@ -278,7 +290,7 @@ pub fn config(subcommand: &ConfigSubCommand, parameters: &Option<String>, stdin:
                 valid: true,
                 reason: None,
             };
-            let valid = match validate_config(&json_string) {
+            let valid = match validate_config(&configurator.get_config()) {
                 Ok(()) => {
                     true
                 },
@@ -349,11 +361,11 @@ pub fn config(subcommand: &ConfigSubCommand, parameters: &Option<String>, stdin:
 /// # Errors
 ///
 /// * `DscError` - The error that occurred.
-pub fn validate_config(config: &str) -> Result<(), DscError> {
+pub fn validate_config(config: &Configuration) -> Result<(), DscError> {
     // first validate against the config schema
     debug!("Validating configuration against schema");
     let schema = serde_json::to_value(get_schema(DscType::Configuration))?;
-    let config_value = serde_json::from_str(config)?;
+    let config_value = serde_json::to_value(config)?;
     validate_json("Configuration", &schema, &config_value)?;
     let mut dsc = DscManager::new()?;
 
diff --git a/dsc_lib/src/configure/mod.rs b/dsc_lib/src/configure/mod.rs
@@ -31,7 +31,8 @@ pub mod depends_on;
 pub mod parameters;
 
 pub struct Configurator {
-    config: String,
+    json: String,
+    config: Configuration,
     pub context: Context,
     discovery: Discovery,
     statement_parser: Statement,
@@ -200,14 +201,26 @@ impl Configurator {
     /// # Errors
     ///
     /// This function will return an error if the configuration is invalid or the underlying discovery fails.
-    pub fn new(config: &str) -> Result<Configurator, DscError> {
+    pub fn new(json: &str) -> Result<Configurator, DscError> {
         let discovery = Discovery::new()?;
-        Ok(Configurator {
-            config: config.to_owned(),
+        let mut config = Configurator {
+            json: json.to_owned(),
+            config: Configuration::new(),
             context: Context::new(),
             discovery,
             statement_parser: Statement::new()?,
-        })
+        };
+        config.validate_config()?;
+        Ok(config)
+    }
+
+    /// Get the configuration.
+    ///
+    /// # Returns
+    ///
+    /// * `&Configuration` - The configuration.
+    pub fn get_config(&self) -> &Configuration {
+        &self.config
     }
 
     /// Invoke the get operation on a resource.
@@ -220,9 +233,8 @@ impl Configurator {
     ///
     /// This function will return an error if the underlying resource fails.
     pub fn invoke_get(&mut self) -> Result<ConfigurationGetResult, DscError> {
-        let config = self.validate_config()?;
         let mut result = ConfigurationGetResult::new();
-        let resources = get_resource_invocation_order(&config, &mut self.statement_parser, &self.context)?;
+        let resources = get_resource_invocation_order(&self.config, &mut self.statement_parser, &self.context)?;
         let pb_span = get_progress_bar_span(resources.len() as u64)?;
         let pb_span_enter = pb_span.enter();
         for resource in resources {
@@ -279,9 +291,8 @@ impl Configurator {
     ///
     /// This function will return an error if the underlying resource fails.
     pub fn invoke_set(&mut self, skip_test: bool) -> Result<ConfigurationSetResult, DscError> {
-        let config = self.validate_config()?;
         let mut result = ConfigurationSetResult::new();
-        let resources = get_resource_invocation_order(&config, &mut self.statement_parser, &self.context)?;
+        let resources = get_resource_invocation_order(&self.config, &mut self.statement_parser, &self.context)?;
         let pb_span = get_progress_bar_span(resources.len() as u64)?;
         let pb_span_enter = pb_span.enter();
         for resource in resources {
@@ -388,9 +399,8 @@ impl Configurator {
     ///
     /// This function will return an error if the underlying resource fails.
     pub fn invoke_test(&mut self) -> Result<ConfigurationTestResult, DscError> {
-        let config = self.validate_config()?;
         let mut result = ConfigurationTestResult::new();
-        let resources = get_resource_invocation_order(&config, &mut self.statement_parser, &self.context)?;
+        let resources = get_resource_invocation_order(&self.config, &mut self.statement_parser, &self.context)?;
         let pb_span = get_progress_bar_span(resources.len() as u64)?;
         let pb_span_enter = pb_span.enter();
         for resource in resources {
@@ -443,14 +453,13 @@ impl Configurator {
     ///
     /// This function will return an error if the underlying resource fails.
     pub fn invoke_export(&mut self) -> Result<ConfigurationExportResult, DscError> {
-        let config = self.validate_config()?;
-
         let mut result = ConfigurationExportResult::new();
         let mut conf = config_doc::Configuration::new();
 
-        let pb_span = get_progress_bar_span(config.resources.len() as u64)?;
+        let pb_span = get_progress_bar_span(self.config.resources.len() as u64)?;
         let pb_span_enter = pb_span.enter();
-        for resource in config.resources {
+        let resources = self.config.resources.clone();
+        for resource in &resources {
             Span::current().pb_inc(1);
             pb_span.pb_set_message(format!("Export '{}'", resource.name).as_str());
             let properties = self.invoke_property_expressions(&resource.properties)?;
@@ -480,7 +489,7 @@ impl Configurator {
     /// This function will return an error if the parameters are invalid.
     pub fn set_parameters(&mut self, parameters_input: &Option<Value>) -> Result<(), DscError> {
         // set default parameters first
-        let config = serde_json::from_str::<Configuration>(self.config.as_str())?;
+        let config = serde_json::from_str::<Configuration>(self.json.as_str())?;
         let Some(parameters) = &config.parameters else {
             if parameters_input.is_none() {
                 debug!("No parameters defined in configuration and no parameters input");
@@ -534,6 +543,12 @@ impl Configurator {
                     info!("Set parameter '{name}' to '{value}'");
                 }
                 self.context.parameters.insert(name.clone(), (value.clone(), constraint.parameter_type.clone()));
+                // also update the configuration with the parameter value
+                if let Some(parameters) = &mut self.config.parameters {
+                    if let Some(parameter) = parameters.get_mut(&name) {
+                        parameter.default_value = Some(value);
+                    }
+                }
             }
             else {
                 return Err(DscError::Validation(format!("Parameter '{name}' not defined in configuration")));
@@ -592,14 +607,15 @@ impl Configurator {
         Ok(())
     }
 
-    fn validate_config(&mut self) -> Result<Configuration, DscError> {
-        let config: Configuration = serde_json::from_str(self.config.as_str())?;
+    fn validate_config(&mut self) -> Result<(), DscError> {
+        let config: Configuration = serde_json::from_str(self.json.as_str())?;
         check_security_context(&config.metadata)?;
 
         // Perform discovery of resources used in config
         let required_resources = config.resources.iter().map(|p| p.resource_type.clone()).collect::<Vec<String>>();
         self.discovery.find_resources(&required_resources);
-        Ok(config)
+        self.config = config;
+        Ok(())
     }
 
     fn invoke_property_expressions(&mut self, properties: &Option<Map<String, Value>>) -> Result<Option<Map<String, Value>>, DscError> {

Original file line number	Diff line number	Diff line change
`@@ -69,19 +69,19 @@ fn main() {`
`69`	`69`	`let mut cmd = Args::command();`
`70`	`70`	`generate(shell, &mut cmd, "dsc", &mut io::stdout());`
`71`	`71`	`},`
`72`		`- SubCommand::Config { subcommand, parameters, parameters_file, as_group } => {`
	`72`	`+ SubCommand::Config { subcommand, parameters, parameters_file, as_group, as_include } => {`
`73`	`73`	`if let Some(file_name) = parameters_file {`
`74`	`74`	`info!("Reading parameters from file {file_name}");`
`75`	`75`	`match std::fs::read_to_string(&file_name) {`
`76`		`- Ok(parameters) => subcommand::config(&subcommand, &Some(parameters), &input, &as_group),`
	`76`	`+ Ok(parameters) => subcommand::config(&subcommand, &Some(parameters), &input, &as_group, &as_include),`
`77`	`77`	`Err(err) => {`
`78`	`78`	`error!("Error: Failed to read parameters file '{file_name}': {err}");`
`79`	`79`	`exit(util::EXIT_INVALID_INPUT);`
`80`	`80`	`}`
`81`	`81`	`}`
`82`	`82`	`}`
`83`	`83`	`else {`
`84`		`- subcommand::config(&subcommand, &parameters, &input, &as_group);`
	`84`	`+ subcommand::config(&subcommand, &parameters, &input, &as_group, &as_include);`
`85`	`85`	`}`
`86`	`86`	`},`
`87`	`87`	`SubCommand::Resource { subcommand } => {`