change to --target-path and targetPath(). add path() function

Author: SteveL-MSFT

.vscode/settings.json

@@ -2,7 +2,7 @@
     "rust-analyzer.linkedProjects": [
         "./dsc/Cargo.toml",
         "./dsc_lib/Cargo.toml",
-        "./echo/Cargo.toml",
+        "./dscecho/Cargo.toml",
         "./osinfo/Cargo.toml",
         "./registry/Cargo.toml",
         "./runcommandonset/Cargo.toml",

dsc/src/args.rs

@@ -48,8 +48,8 @@ pub enum SubCommand {
         parameters: Option<String>,
         #[clap(short = 'f', long, help = "Parameters to pass to the configuration as a JSON or YAML file", conflicts_with = "parameters")]
         parameters_file: Option<String>,
-        #[clap(short = 'm', long, help = "Mounted path to use for supported resources")]
-        mounted_path: Option<String>,
+        #[clap(short = 't', long, help = "Target path to apply configuration, requires resource support.")]
+        target_path: Option<String>,
         // Used to inform when DSC is used as a group resource to modify it's output
         #[clap(long, hide = true)]
         as_group: bool,

dsc/src/main.rs

@@ -68,19 +68,19 @@ fn main() {
             let mut cmd = Args::command();
             generate(shell, &mut cmd, "dsc", &mut io::stdout());
         },
-        SubCommand::Config { subcommand, parameters, parameters_file, mounted_path, as_group, as_include } => {
+        SubCommand::Config { subcommand, parameters, parameters_file, target_path, 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), &mounted_path, &input, &as_group, &as_include),
+                    Ok(parameters) => subcommand::config(&subcommand, &Some(parameters), &target_path, &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, &mounted_path, &input, &as_group, &as_include);
+                subcommand::config(&subcommand, &parameters, &target_path, &input, &as_group, &as_include);
             }
         },
         SubCommand::Resource { subcommand } => {

dsc/src/subcommand.rs

@@ -5,7 +5,7 @@ use crate::args::{ConfigSubCommand, DscType, OutputFormat, ResourceSubCommand};
 use crate::resolve::{get_contents, Include};
 use crate::resource_command::{get_resource, self};
 use crate::tablewriter::Table;
-use crate::util::{DSC_CONFIG_ROOT, EXIT_DSC_ERROR, EXIT_INVALID_INPUT, EXIT_JSON_ERROR, get_schema, write_output, get_input, set_dscconfigroot, validate_json};
+use crate::util::{DSC_CONFIG_ROOT, EXIT_DSC_ERROR, EXIT_INVALID_ARGS, EXIT_INVALID_INPUT, EXIT_JSON_ERROR, get_schema, write_output, get_input, set_dscconfigroot, validate_json};
 use dsc_lib::configure::{Configurator, config_doc::{Configuration, ExecutionKind}, config_result::ResourceGetResult};
 use dsc_lib::dscerror::DscError;
 use dsc_lib::dscresources::invoke_result::ResolveResult;
@@ -15,9 +15,12 @@ use dsc_lib::{
     dscresources::dscresource::{Capability, ImplementedAs, Invoke},
     dscresources::resource_manifest::{import_manifest, ResourceManifest},
 };
-use std::collections::HashMap;
-use std::io::{self, IsTerminal};
-use std::process::exit;
+use std::{
+    collections::HashMap,
+    io::{self, IsTerminal},
+    path::Path,
+    process::exit
+};
 use tracing::{debug, error, trace};
 
 pub fn config_get(configurator: &mut Configurator, format: &Option<OutputFormat>, as_group: &bool)
@@ -271,7 +274,12 @@ pub fn config(subcommand: &ConfigSubCommand, parameters: &Option<String>, mounte
     };
 
     if let Some(path) = mounted_path {
-        configurator.set_mounted_path(path);
+        if !Path::new(&path).exists() {
+            error!("Error: Target path '{path}' does not exist");
+            exit(EXIT_INVALID_ARGS);
+        }
+
+        configurator.set_target_path(path);
     }
 
     if let Err(err) = configurator.set_context(&parameters) {

dsc/tests/dsc_args.tests.ps1

@@ -308,4 +308,10 @@ resources:
         $LASTEXITCODE | Should -Be 2
         "$TestDrive/tracing.txt" | Should -FileContentMatchExactly 'Can not perform this operation on the adapter'
     }
+
+    It 'Invalid --target-path' {
+        dsc config --target-path /invalid/path get -p "$PSScriptRoot/../examples/groups.dsc.yaml" 2> $TestDrive/tracing.txt
+        $LASTEXITCODE | Should -Be 1
+        "$TestDrive/tracing.txt" | Should -FileContentMatchExactly "Target path '/invalid/path' does not exist"
+    }
 }

dsc/tests/dsc_functions.tests.ps1

@@ -2,6 +2,11 @@
 # Licensed under the MIT License.
 
 Describe 'tests for function expressions' {
+    BeforeAll {
+        $global:sep = [System.IO.Path]::DirectorySeparatorChar
+    }
+
+
     It 'function works: <text>' -TestCases @(
         @{ text = "[concat('a', 'b')]"; expected = 'ab' }
         @{ text = "[concat('a', 'b', 'c')]"; expected = 'abc' }
@@ -25,30 +30,21 @@ Describe 'tests for function expressions' {
         $out.results[0].result.actualState.output | Should -Be $expected
     }
 
-    It 'mountedpath(<path>) works' -TestCases @(
-        @{ path = '' }
-        @{ path = "hello$([System.IO.Path]::DirectorySeparatorChar)world" }
+    It 'path(<path>) works' -TestCases @(
+        @{ path = "targetPath(), 'a'"; expected = "$PSHOME${sep}a" }
+        @{ path = "'a', 'b', 'c'"; expected = "a${sep}b${sep}c" }
     ) {
-        param($path)
-
-        $testPath = if ($path.Length -gt 0) {
-            $expected = "$PSHOME$([System.IO.Path]::DirectorySeparatorChar)$path"
-            "'$($path.replace('\', '\\'))'"
-        }
-        else {
-            $expected = $PSHOME
-            $path
-        }
+        param($path, $expected)
 
         $config_yaml = @"
             `$schema: https://raw.githubusercontent.com/PowerShell/DSC/main/schemas/2024/04/config/document.json
             resources:
             - name: Echo
               type: Microsoft.DSC.Debug/Echo
               properties:
-                output: "[mountedpath($testPath)]"
+                output: "[path($path)]"
 "@
-        $out = $config_yaml | dsc config --mounted-path $PSHOME get | ConvertFrom-Json
+        $out = $config_yaml | dsc config --target-path $PSHOME get | ConvertFrom-Json
         $out.results[0].result.actualState.output | Should -BeExactly $expected
     }
 }

dsc_lib/src/configure/context.rs

@@ -5,14 +5,14 @@ use chrono::{DateTime, Local};
 use crate::configure::config_doc::ExecutionKind;
 use security_context_lib::{get_security_context, SecurityContext};
 use serde_json::Value;
-use std::collections::HashMap;
+use std::{collections::HashMap, path::PathBuf};
 
 use super::config_doc::{DataType, SecurityContextKind};
 
 pub struct Context {
     pub execution_type: ExecutionKind,
     pub outputs: HashMap<String, Value>, // this is used by the `reference()` function to retrieve output
-    pub mounted_path: String,
+    pub target_path: PathBuf,
     pub parameters: HashMap<String, (Value, DataType)>,
     pub security_context: SecurityContextKind,
     pub variables: HashMap<String, Value>,
@@ -25,7 +25,7 @@ impl Context {
         Self {
             execution_type: ExecutionKind::Actual,
             outputs: HashMap::new(),
-            mounted_path: String::new(),
+            target_path: PathBuf::new(),
             parameters: HashMap::new(),
             security_context: match get_security_context() {
                 SecurityContext::Admin => SecurityContextKind::Elevated,

dsc_lib/src/configure/mod.rs

@@ -20,6 +20,7 @@ use self::contraints::{check_length, check_number_limits, check_allowed_values};
 use indicatif::ProgressStyle;
 use security_context_lib::{SecurityContext, get_security_context};
 use serde_json::{Map, Value};
+use std::path::PathBuf;
 use std::{collections::HashMap, mem};
 use tracing::{debug, info, trace, warn_span, Span};
 use tracing_indicatif::span_ext::IndicatifSpanExt;
@@ -480,12 +481,12 @@ impl Configurator {
     }
 
     /// Set the mounted path for the configuration.
-    /// 
+    ///
     /// # Arguments
-    /// 
+    ///
     /// * `mounted_path` - The mounted path to set.
-    pub fn set_mounted_path(&mut self, mounted_path: &str) {
-        self.context.mounted_path = mounted_path.to_string();
+    pub fn set_target_path(&mut self, target_path: &str) {
+        self.context.target_path = PathBuf::from(target_path);
     }
 
     /// Set the parameters and variables context for the configuration.

dsc_lib/src/functions/mod.rs

@@ -17,12 +17,13 @@ pub mod int;
 pub mod max;
 pub mod min;
 pub mod mod_function;
-pub mod mounted_path;
 pub mod mul;
 pub mod parameters;
+pub mod path;
 pub mod reference;
 pub mod resource_id;
 pub mod sub;
+pub mod target_path;
 pub mod variables;
 
 /// The kind of argument that a function accepts.
@@ -75,12 +76,13 @@ impl FunctionDispatcher {
         functions.insert("max".to_string(), Box::new(max::Max{}));
         functions.insert("min".to_string(), Box::new(min::Min{}));
         functions.insert("mod".to_string(), Box::new(mod_function::Mod{}));
-        functions.insert("mountedpath".to_string(), Box::new(mounted_path::MountedPath{}));
         functions.insert("mul".to_string(), Box::new(mul::Mul{}));
         functions.insert("parameters".to_string(), Box::new(parameters::Parameters{}));
+        functions.insert("path".to_string(), Box::new(path::Path{}));
         functions.insert("reference".to_string(), Box::new(reference::Reference{}));
         functions.insert("resourceId".to_string(), Box::new(resource_id::ResourceId{}));
         functions.insert("sub".to_string(), Box::new(sub::Sub{}));
+        functions.insert("targetPath".to_string(), Box::new(target_path::TargetPath{}));
         functions.insert("variables".to_string(), Box::new(variables::Variables{}));
         Self {
             functions,

dsc_lib/src/functions/path.rs

@@ -0,0 +1,67 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+use crate::DscError;
+use crate::configure::context::Context;
+use crate::functions::{AcceptedArgKind, Function};
+use serde_json::Value;
+use std::path::PathBuf;
+use tracing::debug;
+
+#[derive(Debug, Default)]
+pub struct Path {}
+
+/// Implements the 'mountedpath' function.
+/// This function returns the value of the mounted path.
+/// The optional parameter is a path appended to the mounted path.
+/// Path is not validated as it might be used for creation.
+impl Function for Path {
+    fn min_args(&self) -> usize {
+        2
+    }
+
+    fn max_args(&self) -> usize {
+        usize::MAX
+    }
+
+    fn accepted_arg_types(&self) -> Vec<AcceptedArgKind> {
+        vec![AcceptedArgKind::String]
+    }
+
+    fn invoke(&self, args: &[Value], _context: &Context) -> Result<Value, DscError> {
+        debug!("Executing path function with args: {:?}", args);
+
+        let mut path = PathBuf::new();
+        for arg in args {
+            if let Value::String(s) = arg {
+                path.push(s);
+            } else {
+                return Err(DscError::Parser("Arguments must all be strings".to_string()));
+            }
+        }
+
+        Ok(Value::String(path.to_string_lossy().to_string()))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::configure::context::Context;
+    use crate::parser::Statement;
+
+    #[test]
+    fn no_arg() {
+        let mut parser = Statement::new().unwrap();
+        let separator = std::path::MAIN_SEPARATOR;
+        let result = parser.parse_and_execute("[path('a','b'", &Context::new()).unwrap();
+        assert_eq!(result, format!("a{separator}b"));
+    }
+
+    #[test]
+    fn with_arg() {
+        let mut parser = Statement::new().unwrap();
+        let separator = std::path::MAIN_SEPARATOR;
+        let result = parser.parse_and_execute("[path('a','b','c')]", &Context::new()).unwrap();
+        assert_eq!(result, format!("{separator}a{separator}b{separator}c"));
+    }
+}