Merge branch 'main' into update-reference-docs

Gijsreyn · web-flow · commit efdaa763ea8a · 2025-06-06T15:07:22.000+02:00
diff --git a/dsc/locales/en-us.toml b/dsc/locales/en-us.toml
@@ -37,6 +37,7 @@ resource = "The name of the resource to invoke"
 ctrlCReceived = "Ctrl-C received"
 failedCtrlCHandler = "Failed to set Ctrl-C handler"
 failedReadingParametersFile = "Failed to read parameters file"
+readingParametersFromStdin = "Reading parameters from STDIN"
 generatingCompleter = "Generating completion script for"
 readingParametersFile = "Reading parameters from file"
 usingDscVersion = "Running DSC version"
@@ -133,3 +134,4 @@ failedToAbsolutizePath = "Error making config path absolute"
 failedToGetParentPath = "Error reading config path parent"
 dscConfigRootAlreadySet = "The current value of DSC_CONFIG_ROOT env var will be overridden"
 settingDscConfigRoot = "Setting DSC_CONFIG_ROOT env var as"
+stdinNotAllowedForBothParametersAndInput = "Cannot read from STDIN for both parameters and input."
diff --git a/dsc/src/args.rs b/dsc/src/args.rs
@@ -19,6 +19,7 @@ pub enum OutputFormat {
 pub enum GetOutputFormat {
     Json,
     JsonArray,
+    PassThrough,
     PrettyJson,
     Yaml,
 }
diff --git a/dsc/src/main.rs b/dsc/src/main.rs
@@ -5,11 +5,13 @@ use args::{Args, SubCommand};
 use clap::{CommandFactory, Parser};
 use clap_complete::generate;
 use rust_i18n::{i18n, t};
-use std::{io, process::exit};
+use std::{io, io::Read, process::exit};
 use sysinfo::{Process, RefreshKind, System, get_current_pid, ProcessRefreshKind};
 use tracing::{error, info, warn, debug};
 use dsc_lib::progress::ProgressFormat;
 
+use crate::util::EXIT_INVALID_INPUT;
+
 #[cfg(debug_assertions)]
 use crossterm::event;
 #[cfg(debug_assertions)]
@@ -51,17 +53,40 @@ fn main() {
         },
         SubCommand::Config { subcommand, parameters, parameters_file, system_root, as_group, as_assert, as_include } => {
             if let Some(file_name) = parameters_file {
+                if file_name == "-" {
+                    info!("{}", t!("main.readingParametersFromStdin"));
+                    let mut stdin = Vec::<u8>::new();
+                    let parameters = match io::stdin().read_to_end(&mut stdin) {
+                        Ok(_) => {
+                            match String::from_utf8(stdin) {
+                                Ok(input) => {
+                                    input
+                                },
+                                Err(err) => {
+                                    error!("{}: {err}", t!("util.invalidUtf8"));
+                                    exit(EXIT_INVALID_INPUT);
+                                }
+                            }
+                        },
+                        Err(err) => {
+                            error!("{}: {err}", t!("util.failedToReadStdin"));
+                            exit(EXIT_INVALID_INPUT);
+                        }
+                    };
+                    subcommand::config(&subcommand, &Some(parameters), true, system_root.as_ref(), &as_group, &as_assert, &as_include, progress_format);
+                    return;
+                }
                 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_assert, &as_include, progress_format),
+                    Ok(parameters) => subcommand::config(&subcommand, &Some(parameters), false, system_root.as_ref(), &as_group, &as_assert, &as_include, progress_format),
                     Err(err) => {
                         error!("{} '{file_name}': {err}", t!("main.failedReadingParametersFile"));
                         exit(util::EXIT_INVALID_INPUT);
                     }
                 }
             }
             else {
-                subcommand::config(&subcommand, &parameters, system_root.as_ref(), &as_group, &as_assert, &as_include, progress_format);
+                subcommand::config(&subcommand, &parameters, false, system_root.as_ref(), &as_group, &as_assert, &as_include, progress_format);
             }
         },
         SubCommand::Extension { subcommand } => {
diff --git a/dsc/src/resource_command.rs b/dsc/src/resource_command.rs
@@ -16,7 +16,7 @@ use dsc_lib::{
 };
 use std::process::exit;
 
-pub fn get(dsc: &DscManager, resource_type: &str, input: &str, format: Option<&OutputFormat>) {
+pub fn get(dsc: &DscManager, resource_type: &str, input: &str, format: Option<&GetOutputFormat>) {
     let Some(resource) = get_resource(dsc, resource_type) else {
         error!("{}", DscError::ResourceNotFound(resource_type.to_string()).to_string());
         exit(EXIT_DSC_RESOURCE_NOT_FOUND);
@@ -30,18 +30,37 @@ pub fn get(dsc: &DscManager, resource_type: &str, input: &str, format: Option<&O
 
     match resource.get(input) {
         Ok(result) => {
+            if let GetResult::Resource(response) = &result {
+                if format == Some(&GetOutputFormat::PassThrough) {
+                    let json = match serde_json::to_string(&response.actual_state) {
+                        Ok(json) => json,
+                        Err(err) => {
+                            error!("{}", t!("resource_command.jsonError", err = err));
+                            exit(EXIT_JSON_ERROR);
+                        }
+                    };
+                    write_object(&json, Some(&OutputFormat::Json), false);
+                    return;
+                }
+            }
+
             // convert to json
             let json = match serde_json::to_string(&result) {
                 Ok(json) => json,
                 Err(err) => {
-                    error!("JSON Error: {err}");
+                    error!("{}", t!("resource_command.jsonError", err = err));
                     exit(EXIT_JSON_ERROR);
                 }
             };
+            let format = match format {
+                Some(&GetOutputFormat::PrettyJson) => Some(&OutputFormat::PrettyJson),
+                Some(&GetOutputFormat::Yaml) => Some(&OutputFormat::Yaml),
+                _ => Some(&OutputFormat::Json),
+            };
             write_object(&json, format, false);
         }
         Err(err) => {
-            error!("Error: {err}");
+            error!("{err}");
             exit(EXIT_DSC_ERROR);
         }
     }
@@ -63,7 +82,7 @@ pub fn get_all(dsc: &DscManager, resource_type: &str, format: Option<&GetOutputF
     let export_result = match resource.export(&input) {
         Ok(export) => { export }
         Err(err) => {
-            error!("Error: {err}");
+            error!("{err}");
             exit(EXIT_DSC_ERROR);
         }
     };
@@ -127,14 +146,14 @@ pub fn set(dsc: &DscManager, resource_type: &str, input: &str, format: Option<&O
             let json = match serde_json::to_string(&result) {
                 Ok(json) => json,
                 Err(err) => {
-                    error!("JSON Error: {err}");
+                    error!("{}", t!("resource_command.jsonError", err = err));
                     exit(EXIT_JSON_ERROR);
                 }
             };
             write_object(&json, format, false);
         }
         Err(err) => {
-            error!("Error: {err}");
+            error!("{err}");
             exit(EXIT_DSC_ERROR);
         }
     }
@@ -191,7 +210,7 @@ pub fn delete(dsc: &DscManager, resource_type: &str, input: &str) {
     match resource.delete(input) {
         Ok(()) => {}
         Err(err) => {
-            error!("Error: {err}");
+            error!("{err}");
             exit(EXIT_DSC_ERROR);
         }
     }
@@ -213,14 +232,14 @@ pub fn schema(dsc: &DscManager, resource_type: &str, format: Option<&OutputForma
             match serde_json::from_str::<serde_json::Value>(json.as_str()) {
                 Ok(_) => (),
                 Err(err) => {
-                    error!("Error: {err}");
+                    error!("{err}");
                     exit(EXIT_JSON_ERROR);
                 }
             }
             write_object(&json, format, false);
         }
         Err(err) => {
-            error!("Error: {err}");
+            error!("{err}");
             exit(EXIT_DSC_ERROR);
         }
     }
diff --git a/dsc/src/subcommand.rs b/dsc/src/subcommand.rs
@@ -271,15 +271,16 @@ fn initialize_config_root(path: Option<&String>) -> Option<String> {
 }
 
 #[allow(clippy::too_many_lines)]
-pub fn config(subcommand: &ConfigSubCommand, parameters: &Option<String>, mounted_path: Option<&String>, as_group: &bool, as_assert: &bool, as_include: &bool, progress_format: ProgressFormat) {
+#[allow(clippy::too_many_arguments)]
+pub fn config(subcommand: &ConfigSubCommand, parameters: &Option<String>, parameters_from_stdin: bool, mounted_path: Option<&String>, as_group: &bool, as_assert: &bool, as_include: &bool, progress_format: ProgressFormat) {
     let (new_parameters, json_string) = match subcommand {
         ConfigSubCommand::Get { input, file, .. } |
         ConfigSubCommand::Set { input, file, .. } |
         ConfigSubCommand::Test { input, file, .. } |
         ConfigSubCommand::Validate { input, file, .. } |
         ConfigSubCommand::Export { input, file, .. } => {
             let new_path = initialize_config_root(file.as_ref());
-            let document = get_input(input.as_ref(), new_path.as_ref());
+            let document = get_input(input.as_ref(), new_path.as_ref(), parameters_from_stdin);
             if *as_include {
                 let (new_parameters, config_json) = match get_contents(&document) {
                     Ok((parameters, config_json)) => (parameters, config_json),
@@ -295,7 +296,7 @@ pub fn config(subcommand: &ConfigSubCommand, parameters: &Option<String>, mounte
         },
         ConfigSubCommand::Resolve { input, file, .. } => {
             let new_path = initialize_config_root(file.as_ref());
-            let document = get_input(input.as_ref(), new_path.as_ref());
+            let document = get_input(input.as_ref(), new_path.as_ref(), parameters_from_stdin);
             let (new_parameters, config_json) = match get_contents(&document) {
                 Ok((parameters, config_json)) => (parameters, config_json),
                 Err(err) => {
@@ -391,7 +392,7 @@ pub fn config(subcommand: &ConfigSubCommand, parameters: &Option<String>, mounte
             };
             if *as_include {
                 let new_path = initialize_config_root(file.as_ref());
-                let input = get_input(input.as_ref(), new_path.as_ref());
+                let input = get_input(input.as_ref(), new_path.as_ref(), parameters_from_stdin);
                 match serde_json::from_str::<Include>(&input) {
                     Ok(_) => {
                         // valid, so do nothing
@@ -582,40 +583,36 @@ pub fn resource(subcommand: &ResourceSubCommand, progress_format: ProgressFormat
         },
         ResourceSubCommand::Export { resource, input, file, output_format } => {
             dsc.find_resources(&[resource.to_string()], progress_format);
-            let parsed_input = get_input(input.as_ref(), file.as_ref());
+            let parsed_input = get_input(input.as_ref(), file.as_ref(), false);
             resource_command::export(&mut dsc, resource, &parsed_input, output_format.as_ref());
         },
         ResourceSubCommand::Get { resource, input, file: path, all, output_format } => {
             dsc.find_resources(&[resource.to_string()], progress_format);
-            if *all { resource_command::get_all(&dsc, resource, output_format.as_ref()); }
+            if *all {
+                resource_command::get_all(&dsc, resource, output_format.as_ref());
+            }
             else {
-                let parsed_input = get_input(input.as_ref(), path.as_ref());
-                let format = match output_format {
-                    Some(GetOutputFormat::Json) => Some(OutputFormat::Json),
-                    Some(GetOutputFormat::JsonArray) => {
-                        error!("{}", t!("subcommand.jsonArrayNotSupported"));
-                        exit(EXIT_INVALID_ARGS);
-                    },
-                    Some(GetOutputFormat::PrettyJson) => Some(OutputFormat::PrettyJson),
-                    Some(GetOutputFormat::Yaml) => Some(OutputFormat::Yaml),
-                    None => None,
-                };
-                resource_command::get(&dsc, resource, &parsed_input, format.as_ref());
+                if *output_format == Some(GetOutputFormat::JsonArray) {
+                    error!("{}", t!("subcommand.jsonArrayNotSupported"));
+                    exit(EXIT_INVALID_ARGS);
+                }
+                let parsed_input = get_input(input.as_ref(), path.as_ref(), false);
+                resource_command::get(&dsc, resource, &parsed_input, output_format.as_ref());
             }
         },
         ResourceSubCommand::Set { resource, input, file: path, output_format } => {
             dsc.find_resources(&[resource.to_string()], progress_format);
-            let parsed_input = get_input(input.as_ref(), path.as_ref());
+            let parsed_input = get_input(input.as_ref(), path.as_ref(), false);
             resource_command::set(&dsc, resource, &parsed_input, output_format.as_ref());
         },
         ResourceSubCommand::Test { resource, input, file: path, output_format } => {
             dsc.find_resources(&[resource.to_string()], progress_format);
-            let parsed_input = get_input(input.as_ref(), path.as_ref());
+            let parsed_input = get_input(input.as_ref(), path.as_ref(), false);
             resource_command::test(&dsc, resource, &parsed_input, output_format.as_ref());
         },
         ResourceSubCommand::Delete { resource, input, file: path } => {
             dsc.find_resources(&[resource.to_string()], progress_format);
-            let parsed_input = get_input(input.as_ref(), path.as_ref());
+            let parsed_input = get_input(input.as_ref(), path.as_ref(), false);
             resource_command::delete(&dsc, resource, &parsed_input);
         },
     }
diff --git a/dsc/src/util.rs b/dsc/src/util.rs
@@ -426,7 +426,7 @@ pub fn validate_json(source: &str, schema: &Value, json: &Value) -> Result<(), D
     Ok(())
 }
 
-pub fn get_input(input: Option<&String>, file: Option<&String>) -> String {
+pub fn get_input(input: Option<&String>, file: Option<&String>, parameters_from_stdin: bool) -> String {
     trace!("Input: {input:?}, File: {file:?}");
     let value = if let Some(input) = input {
         debug!("{}", t!("util.readingInput"));
@@ -442,6 +442,10 @@ pub fn get_input(input: Option<&String>, file: Option<&String>) -> String {
         // check if need to read from STDIN
         if path == "-" {
             info!("{}", t!("util.readingInputFromStdin"));
+            if parameters_from_stdin {
+                error!("{}", t!("util.stdinNotAllowedForBothParametersAndInput"));
+                exit(EXIT_INVALID_INPUT);
+            }
             let mut stdin = Vec::<u8>::new();
             match std::io::stdin().read_to_end(&mut stdin) {
                 Ok(_) => {
@@ -535,13 +539,13 @@ pub fn set_dscconfigroot(config_path: &str) -> String
 
 
 /// Check if the test result is in the desired state.
-/// 
+///
 /// # Arguments
-/// 
+///
 /// * `test_result` - The test result to check
-/// 
+///
 /// # Returns
-/// 
+///
 /// * `bool` - True if the test result is in the desired state, false otherwise
 #[must_use]
 pub fn in_desired_state(test_result: &ResourceTestResult) -> bool {
diff --git a/dsc/tests/dsc_parameters.tests.ps1 b/dsc/tests/dsc_parameters.tests.ps1
@@ -316,4 +316,43 @@ Describe 'Parameters tests' {
 
       $output | Should -Match "Parameter input failure:.*?$type"
     }
+
+    It 'Parameters can be read from STDIN' {
+      $params = @{
+        parameters = @{
+          osFamily = 'Windows'
+        }
+      } | ConvertTo-Json -Compress
+
+      $out = $params | dsc config -f - test -f "$PSScriptRoot/../examples/osinfo_parameters.dsc.yaml" 2> $TestDrive/error.log | ConvertFrom-Json
+      $LASTEXITCODE | Should -Be 0 -Because (Get-Content -Path $TestDrive/error.log | Out-String)
+      $out.results[0].result.desiredState.family | Should -BeExactly 'Windows'
+      $out.results[0].result.inDesiredState | Should -Be $IsWindows
+    }
+
+    It 'Parameters and input cannot both be from STDIN' {
+      $params = @{
+        parameters = @{
+          osFamily = 'Windows'
+        }
+      } | ConvertTo-Json -Compress
+
+      $out = $params | dsc config -f - test -f - 2> $TestDrive/error.log
+      $LASTEXITCODE | Should -Be 4
+      $out | Should -BeNullOrEmpty
+      $errorMessage = Get-Content -Path $TestDrive/error.log -Raw
+      $errorMessage | Should -BeLike "*ERROR*Cannot read from STDIN for both parameters and input*"
+    }
+
+    It 'Invalid parameters read from STDIN result in error' {
+      $params = @{
+        osFamily = 'Windows'
+      } | ConvertTo-Json -Compress
+
+      $out = $params | dsc config -f - test -f "$PSScriptRoot/../examples/osinfo_parameters.dsc.yaml" 2> $TestDrive/error.log
+      $LASTEXITCODE | Should -Be 4
+      $out | Should -BeNullOrEmpty
+      $errorMessage = Get-Content -Path $TestDrive/error.log -Raw
+      $errorMessage | Should -BeLike "*ERROR*Parameter input failure: JSON: missing field ````parameters````*"
+    }
 }
diff --git a/dsc/tests/dsc_resource_get.tests.ps1 b/dsc/tests/dsc_resource_get.tests.ps1
@@ -54,4 +54,20 @@ Describe 'resource get tests' {
         $LASTEXITCODE | Should -Be 0
         ($out | Measure-Object).Count | Should -Be 1
     }
+
+    It 'pass-through format works' {
+        $out = dsc resource get -r Microsoft/OSInfo --output-format pass-through | ConvertFrom-Json
+        $LASTEXITCODE | Should -Be 0
+        $expectedFamily = if ($IsWindows) {
+            'Windows'
+        } elseif ($IsLinux) {
+            'Linux'
+        } else {
+            'macOS'
+        }
+        $out.family | Should -BeExactly $expectedFamily
+        $out.version | Should -Not -BeNullOrEmpty
+        $out.bitness | Should -BeIn @('32', '64')
+        $out.architecture | Should -BeIn @('x86', 'x86_64', 'arm64')
+    }
 }
diff --git a/dsc/tests/dsc_tracing.tests.ps1 b/dsc/tests/dsc_tracing.tests.ps1
@@ -82,7 +82,8 @@ Describe 'tracing tests' {
                 level: trace
 "@
 
-        $out = (dsc -l $level config get -i $configYaml 2> $null) | ConvertFrom-Json
+        $out = (dsc -l $level config get -i $configYaml 2> $TestDrive/error.log) | ConvertFrom-Json
+        $LASTEXITCODE | Should -Be 0 -Because (Get-Content -Path $TestDrive/error.log | Out-String)
         $out.results[0].result.actualState.level | Should -BeExactly $level -Because ($out | Out-String)
     }
 
@@ -91,7 +92,6 @@ Describe 'tracing tests' {
         $out = dsc -l info -t pass-through config get -f ../examples/groups.dsc.yaml 2> $logPath
         foreach ($line in (Get-Content $logPath)) {
             $line | Should -Not -BeNullOrEmpty
-            Write-Verbose -Verbose $line
             $json = $line | ConvertFrom-Json
             $json.timestamp | Should -Not -BeNullOrEmpty
             $json.level | Should -BeIn 'ERROR', 'WARN', 'INFO', 'DEBUG', 'TRACE'
diff --git a/reboot_pending/reboot_pending.dsc.resource.json b/reboot_pending/reboot_pending.dsc.resource.json
diff --git a/tools/dsctest/dsctrace.dsc.resource.json b/tools/dsctest/dsctrace.dsc.resource.json

Original file line number	Diff line number	Diff line change
`@@ -19,6 +19,7 @@ pub enum OutputFormat {`
`19`	`19`	`pub enum GetOutputFormat {`
`20`	`20`	`Json,`
`21`	`21`	`JsonArray,`
	`22`	`+ PassThrough,`
`22`	`23`	`PrettyJson,`
`23`	`24`	`Yaml,`
`24`	`25`	`}`