Merge branch 'PowerShell:main' into main

Author: Gijsreyn

README.md

@@ -18,14 +18,11 @@ With DSCv3, you can:
 
 ### Differences from PowerShell DSC
 
-This project is the next generation of DSC and leverages the
-[PSDesiredStateConfiguration module][00] to maintain compatibility with existing PowerShell based
-resources.
-
 DSCv3 differs from PowerShell DSC in a few important ways:
 
 - DSCv3 doesn't depend on PowerShell. You can use DSCv3 without PowerShell installed and manage
   resources written in bash, python, C#, Go, or any other language.
+- DSCv3 use of PowerShell based resources does not depend on PSDesiredStateConfiguration module
 - DSCv3 doesn't include a local configuration manager. DSCv3 is invoked as a command. It doesn't
   run as a service.
 - Non-PowerShell resources define their schemas with JSON files, not MOF files.

dsc/Cargo.lock

@@ -9,7 +9,7 @@ resources:
     - name: os_check
       type: Microsoft/OSInfo
       properties:
-        family: MacOS
+        family: macOS
 - name: brew
   type: DSC.PackageManagement/Brew
   properties:

dsc/examples/brew_uninstall.dsc.yaml

@@ -0,0 +1,5 @@
+{
+  "parameters": {
+    "osFamily": "macOS"
+  }
+}

dsc/examples/osinfo.parameters.json

@@ -0,0 +1,37 @@
+{
+  "$schema": "https://raw.githubusercontent.com/PowerShell/DSC/main/schemas/2024/04/config/document.json",
+  "parameters": {
+    "osFamily": {
+      "type": "string",
+      "defaultValue": "[concat('Win','dows')]",
+      "allowedValues": [
+        "Windows",
+        "Linux",
+        "macOS"
+      ]
+    }
+  },
+  "resources": [
+    {
+      "name": "os",
+      "type": "Microsoft/OSInfo",
+      "properties": {
+        "family": "[parameters('osFamily')]"
+      }
+    },
+    {
+      "name": "another os instance",
+      "type": "Microsoft/OSInfo",
+      "properties": {
+        "family": "macOS"
+      }
+    },
+    {
+      "name": "path",
+      "type": "Microsoft.DSC.Debug/Echo",
+      "properties": {
+        "output": "[envvar('PATH')]"
+      }
+    }
+  ]
+}

dsc/examples/osinfo_parameters.dsc.json

@@ -4,6 +4,7 @@ _version = 1
 about = "Apply configuration or invoke specific DSC resources"
 traceFormat = "Trace format to use"
 traceLevel = "Trace level to use"
+progressFormat = "Progress format to use"
 completer = "Generate a shell completion script"
 configAbout = "Apply a configuration document"
 parameters = "Parameters to pass to the configuration as JSON or YAML"
@@ -41,7 +42,7 @@ foundProcesses = "Found processes"
 failedToGetPid = "Could not get current process id"
 currentPid = "Current process id"
 failedToGetProcess = "Could not get current process"
-terminatingSubprocess ="Terminating subprocesses of process"
+terminatingSubprocess = "Terminating subprocesses of process"
 terminatingProcess = "Terminating process"
 failedTerminatingProcess = "Failed to terminate process"
 storeMessage = """DSC.exe is a command-line tool and cannot be run directly from the Windows Store or Explorer.
@@ -57,11 +58,11 @@ failedToOpenFile = "Failed to open included file"
 invalidFileContent = "Invalid UTF-8 sequence in included file"
 invalidFile = "Failed to read the configuration file as YAML or JSON"
 resolvingParameters = "Resolving parameters from file"
-failedParseParametersFile = "Failed to parse parameters file to JSON"
-failedResolveParametersFile = "Failed to resolve parameters file"
-noParametersFile = "No parameters file found"
+failedParseParametersFile = "Failed to parse parameters file or conetnt to JSON"
+couldNotReadParametersFile = "Could not read parameters file"
 invalidPath = "Include path must not contain '..'"
 failedGetCurrentDirectory = "Failed to get current directory"
+noParameters = "No parameters specified"
 
 [resource_command]
 implementedAs = "implemented as"
@@ -99,7 +100,7 @@ noManifest = "Resource does not have a manifest"
 tableHeader_type = "Type"
 tableHeader_kind = "Kind"
 tableHeader_version = "Version"
-tableheader_capabilities = "Capabilities"
+tableHeader_capabilities = "Capabilities"
 tableHeader_adapter = "RequireAdapter"
 tableHeader_description = "Description"
 invalidManifest = "Error in manifest for"

dsc/locales/en-us.toml

@@ -4,6 +4,7 @@
 use clap::{Parser, Subcommand, ValueEnum};
 use clap_complete::Shell;
 use dsc_lib::dscresources::command_resource::TraceLevel;
+use dsc_lib::util::ProgressFormat;
 use rust_i18n::t;
 use serde::Deserialize;
 
@@ -33,6 +34,8 @@ pub struct Args {
     pub trace_level: Option<TraceLevel>,
     #[clap(short = 't', long, help = t!("args.traceFormat").to_string(), value_enum)]
     pub trace_format: Option<TraceFormat>,
+    #[clap(short = 'p', long, help = t!("args.progressFormat").to_string(), value_enum)]
+    pub progress_format: Option<ProgressFormat>,
 }
 
 #[derive(Debug, PartialEq, Eq, Subcommand)]

dsc/src/args.rs

@@ -8,6 +8,7 @@ use rust_i18n::{i18n, t};
 use std::{io, process::exit};
 use sysinfo::{Process, RefreshKind, System, get_current_pid, ProcessRefreshKind};
 use tracing::{error, info, warn, debug};
+use dsc_lib::util::ProgressFormat;
 
 #[cfg(debug_assertions)]
 use crossterm::event;
@@ -40,6 +41,8 @@ fn main() {
 
     debug!("{}: {}", t!("main.usingDscVersion"), env!("CARGO_PKG_VERSION"));
 
+    let progress_format = args.progress_format.unwrap_or( ProgressFormat::Default );
+
     match args.subcommand {
         SubCommand::Completer { shell } => {
             info!("{} {:?}", t!("main.generatingCompleter"), shell);
@@ -50,19 +53,19 @@ fn main() {
             if let Some(file_name) = parameters_file {
                 info!("{}: {file_name}", t!("main.readingParametersFile"));
                 match std::fs::read_to_string(&file_name) {
-                    Ok(parameters) => subcommand::config(&subcommand, &Some(parameters), system_root.as_ref(), &as_group, &as_include),
+                    Ok(parameters) => subcommand::config(&subcommand, &Some(parameters), system_root.as_ref(), &as_group, &as_include, progress_format),
                     Err(err) => {
-                        error!("{} '{file_name}': {err}", t!("main.failedToReadParametersFile"));
+                        error!("{} '{file_name}': {err}", t!("main.failedReadingParametersFile"));
                         exit(util::EXIT_INVALID_INPUT);
                     }
                 }
             }
             else {
-                subcommand::config(&subcommand, &parameters, system_root.as_ref(), &as_group, &as_include);
+                subcommand::config(&subcommand, &parameters, system_root.as_ref(), &as_group, &as_include, progress_format);
             }
         },
         SubCommand::Resource { subcommand } => {
-            subcommand::resource(&subcommand);
+            subcommand::resource(&subcommand, progress_format);
         },
         SubCommand::Schema { dsc_type , output_format } => {
             let schema = util::get_schema(dsc_type);
@@ -102,13 +105,13 @@ fn ctrlc_handler() {
 
 fn terminate_subprocesses(sys: &System, process: &Process) {
     info!("{}: {:?} {}", t!("main.terminatingSubprocess"), process.name(), process.pid());
-    for subprocess in sys.processes().values().filter(|p| p.parent().map_or(false, |parent| parent == process.pid())) {
+    for subprocess in sys.processes().values().filter(|p| p.parent().is_some_and(|parent| parent == process.pid())) {
         terminate_subprocesses(sys, subprocess);
     }
 
     info!("{}: {:?} {}", t!("main.terminatingProcess"), process.name(), process.pid());
     if !process.kill() {
-        error!("{}: {:?} {}", t!("main.failedTerminateProcess"), process.name(), process.pid());
+        error!("{}: {:?} {}", t!("main.failedTerminatingProcess"), process.name(), process.pid());
     }
 }
 
@@ -157,7 +160,7 @@ fn check_store() {
     };
 
     // MS Store runs app using `sihost.exe`
-    if parent_process.name().to_ascii_lowercase() == "sihost.exe" || parent_process.name().to_ascii_lowercase() == "explorer.exe"{
+    if parent_process.name().eq_ignore_ascii_case("sihost.exe") || parent_process.name().eq_ignore_ascii_case("explorer.exe") {
         eprintln!("{}", t!("main.storeMessage"));
         // wait for keypress
         let _ = io::stdin().read(&mut [0u8]).unwrap();

dsc/src/main.rs

@@ -1,7 +1,6 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-use dsc_lib::configure::config_doc::Configuration;
 use dsc_lib::util::parse_input_to_json;
 use rust_i18n::t;
 use schemars::JsonSchema;
@@ -14,14 +13,30 @@ use tracing::{debug, info};
 use crate::util::DSC_CONFIG_ROOT;
 
 #[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
-pub struct Include {
+pub enum IncludeKind {
     /// The path to the file to include.  Path is relative to the file containing the include
     /// and not allowed to reference parent directories.  If a configuration document is used
     /// instead of a file, then the path is relative to the current working directory.
     #[serde(rename = "configurationFile")]
-    pub configuration_file: String,
+    ConfigurationFile(String),
+    #[serde(rename = "configurationContent")]
+    ConfigurationContent(String),
+}
+
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
+pub enum IncludeParametersKind {
     #[serde(rename = "parametersFile")]
-    pub parameters_file: Option<String>,
+    ParametersFile(String),
+    #[serde(rename = "parametersContent")]
+    ParametersContent(String),
+}
+
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
+pub struct Include {
+    #[serde(flatten)]
+    pub configuration: IncludeKind,
+    #[serde(flatten)]
+    pub parameters: Option<IncludeParametersKind>,
 }
 
 /// Read the file specified in the Include input and return the content as a JSON string.
@@ -51,74 +66,83 @@ pub fn get_contents(input: &str) -> Result<(Option<String>, String), String> {
         }
     };
 
-    let include_path = normalize_path(Path::new(&include.configuration_file))?;
+    let config_json = match include.configuration {
+        IncludeKind::ConfigurationFile(file_path) => {
+            let include_path = normalize_path(Path::new(&file_path))?;
 
-    // read the file specified in the Include input
-    let mut buffer: Vec<u8> = Vec::new();
-    match File::open(&include_path) {
-        Ok(mut file) => {
-            match file.read_to_end(&mut buffer) {
-                Ok(_) => (),
+            // read the file specified in the Include input
+            let mut buffer: Vec<u8> = Vec::new();
+            match File::open(&include_path) {
+                Ok(mut file) => {
+                    match file.read_to_end(&mut buffer) {
+                        Ok(_) => (),
+                        Err(err) => {
+                            return Err(format!("{} '{include_path:?}': {err}", t!("resolve.failedToReadFile")));
+                        }
+                    }
+                },
                 Err(err) => {
-                    return Err(format!("{} '{include_path:?}': {err}", t!("resolve.failedToReadFile")));
+                    return Err(format!("{} '{include_path:?}': {err}", t!("resolve.failedToOpenFile")));
                 }
             }
-        },
-        Err(err) => {
-            return Err(format!("{} '{include_path:?}': {err}", t!("resolve.failedToOpenFile")));
-        }
-    }
-    // convert the buffer to a string
-    let include_content = match String::from_utf8(buffer) {
-        Ok(input) => input,
-        Err(err) => {
-            return Err(format!("{} '{include_path:?}': {err}", t!("resolve.invalidFileContent")));
-        }
-    };
+            // convert the buffer to a string
+            let include_content = match String::from_utf8(buffer) {
+                Ok(input) => input,
+                Err(err) => {
+                    return Err(format!("{} '{include_path:?}': {err}", t!("resolve.invalidFileContent")));
+                }
+            };
 
-    // try to deserialize the Include content as YAML first
-    let configuration: Configuration = match serde_yaml::from_str(&include_content) {
-        Ok(configuration) => configuration,
-        Err(_err) => {
-            // if that fails, try to deserialize it as JSON
-            match serde_json::from_str(&include_content) {
-                Ok(configuration) => configuration,
+            match parse_input_to_json(&include_content) {
+                Ok(json) => json,
                 Err(err) => {
                     return Err(format!("{} '{include_path:?}': {err}", t!("resolve.invalidFile")));
                 }
             }
+        },
+        IncludeKind::ConfigurationContent(text) => {
+            match parse_input_to_json(&text) {
+                Ok(json) => json,
+                Err(err) => {
+                    return Err(format!("{}: {err}", t!("resolve.invalidFile")));
+                }
+            }
         }
     };
 
-    // serialize the Configuration as JSON
-    let config_json = match serde_json::to_string(&configuration) {
-        Ok(json) => json,
-        Err(err) => {
-            return Err(format!("JSON: {err}"));
-        }
-    };
-
-    let parameters = if let Some(parameters_file) = include.parameters_file {
-        // combine the path with DSC_CONFIG_ROOT
-        let parameters_file = normalize_path(Path::new(&parameters_file))?;
-        info!("{} '{parameters_file:?}'", t!("resolve.resolvingParameters"));
-        match std::fs::read_to_string(&parameters_file) {
-            Ok(parameters) => {
-                let parameters_json = match parse_input_to_json(&parameters) {
-                    Ok(json) => json,
-                    Err(err) => {
-                        return Err(format!("{} '{parameters_file:?}': {err}", t!("resolve.failedParseParametersFile")));
-                    }
-                };
-                Some(parameters_json)
-            },
-            Err(err) => {
-                return Err(format!("{} '{parameters_file:?}': {err}", t!("resolve.failedResolveParametersFile")));
+    let parameters = match include.parameters {
+        Some(IncludeParametersKind::ParametersFile(file_path)) => {
+            // combine the path with DSC_CONFIG_ROOT
+            let parameters_file = normalize_path(Path::new(&file_path))?;
+            info!("{} '{parameters_file:?}'", t!("resolve.resolvingParameters"));
+            match std::fs::read_to_string(&parameters_file) {
+                Ok(parameters) => {
+                    let parameters_json = match parse_input_to_json(&parameters) {
+                        Ok(json) => json,
+                        Err(err) => {
+                            return Err(format!("{} '{parameters_file:?}': {err}", t!("resolve.failedParseParametersFile")));
+                        }
+                    };
+                    Some(parameters_json)
+                },
+                Err(err) => {
+                    return Err(format!("{} '{parameters_file:?}': {err}", t!("resolve.couldNotReadParametersFile")));
+                }
             }
+        },
+        Some(IncludeParametersKind::ParametersContent(text)) => {
+            let parameters_json = match parse_input_to_json(&text) {
+                Ok(json) => json,
+                Err(err) => {
+                    return Err(format!("{}: {err}", t!("resolve.failedParseParametersFile")));
+                }
+            };
+            Some(parameters_json)
+        },
+        None => {
+            debug!("{}", t!("resolve.noParameters"));
+            None
         }
-    } else {
-        debug!("{}", t!("resolve.noParametersFile"));
-        None
     };
 
     Ok((parameters, config_json))