add helper

Author: Steve Lee (POWERSHELL HE/HIM) (from Dev Box)

dsc/tests/dsc_discovery.tests.ps1

@@ -280,7 +280,7 @@ Describe 'tests for resource discovery' {
         try {
             $env:DSC_RESOURCE_PATH = $subfolder
             $out = dsc resource get -r 'Microsoft.DSC.Debug/Echo' -i '{"output":"RelativePathTest"}' 2> "$testdrive/error.txt" | ConvertFrom-Json
-            $LASTEXITCODE | Should -Be 0
+            $LASTEXITCODE | Should -Be 0 -Because (Get-Content -Raw -Path "$testdrive/error.txt")
             $out.actualState.output | Should -BeExactly 'RelativePathTest'
         }
         finally {

lib/dsc-lib/locales/en-us.toml

@@ -169,7 +169,6 @@ invalidKey = "Unsupported value for key '%{key}'.  Only string, bool, number, an
 inDesiredStateNotBool = "'_inDesiredState' is not a boolean"
 exportNotSupportedUsingGet = "Export is not supported by resource '%{resource}' using get operation"
 runProcessError = "Failed to run process '%{executable}': %{error}"
-executableNotFound = "Executable '%{executable}' not found"
 
 [dscresources.dscresource]
 invokeGet = "Invoking get for '%{resource}'"
@@ -699,3 +698,4 @@ failedToGetExePath = "Can't get 'dsc' executable path"
 settingNotFound = "Setting '%{name}' not found"
 failedToAbsolutizePath = "Failed to absolutize path '%{path}'"
 invalidExitCodeKey = "Invalid exit code key '%{key}'"
+executableNotFound = "Executable '%{executable}' not found with working directory '%{cwd}'"

lib/dsc-lib/src/discovery/command_discovery.rs

@@ -20,14 +20,13 @@ use serde::Deserialize;
 use std::{collections::{BTreeMap, HashMap, HashSet}, sync::{LazyLock, RwLock}};
 use std::env;
 use std::ffi::OsStr;
-use std::fs;
+use std::fs::{create_dir_all, read, read_to_string, write};
 use std::path::{Path, PathBuf};
 use std::str::FromStr;
 use tracing::{debug, info, trace, warn};
-use which::which;
 
 use crate::util::get_setting;
-use crate::util::get_exe_path;
+use crate::util::{canonicalize_which, get_exe_path};
 
 const DSC_EXTENSION_EXTENSIONS: [&str; 3] = [".dsc.extension.json", ".dsc.extension.yaml", ".dsc.extension.yml"];
 const DSC_MANIFEST_LIST_EXTENSIONS: [&str; 3] = [".dsc.manifests.json", ".dsc.manifests.yaml", ".dsc.manifests.yml"];
@@ -621,7 +620,7 @@ fn insert_resource(resources: &mut BTreeMap<String, Vec<DscResource>>, resource:
 ///
 /// * Returns a `DscError` if the manifest could not be loaded or parsed.
 pub fn load_manifest(path: &Path) -> Result<Vec<ImportedManifest>, DscError> {
-    let contents = fs::read_to_string(path)?;
+    let contents = read_to_string(path)?;
     let file_name_lowercase = path.file_name().and_then(OsStr::to_str).unwrap_or("").to_lowercase();
     let extension_is_json = path.extension().is_some_and(|ext| ext.eq_ignore_ascii_case("json"));
     if DSC_RESOURCE_EXTENSIONS.iter().any(|ext| file_name_lowercase.ends_with(ext)) {
@@ -804,17 +803,7 @@ fn load_extension_manifest(path: &Path, manifest: &ExtensionManifest) -> Result<
 }
 
 fn verify_executable(resource: &str, operation: &str, executable: &str, directory: &Path) {
-    if which(executable).is_err() {
-        if !Path::new(executable).is_absolute() {
-            // combine with directory and see if it exists
-            let exe_path = directory.join(executable);
-            if exe_path.exists() {
-                return;
-            }
-            info!("{}", t!("discovery.commandDiscovery.executableNotFound", resource = resource, operation = operation, executable = exe_path.to_string_lossy()));
-            return;
-        }
-
+    if canonicalize_which(executable, Some(directory.to_string_lossy().as_ref())).is_err() {
         info!("{}", t!("discovery.commandDiscovery.executableNotFound", resource = resource, operation = operation, executable = executable));
     }
 }
@@ -849,8 +838,8 @@ fn save_adapted_resources_lookup_table(lookup_table: &HashMap<String, String>)
 
         let path = std::path::Path::new(&file_path);
         if let Some(prefix) = path.parent() {
-            if fs::create_dir_all(prefix).is_ok()  {
-                if fs::write(file_path.clone(), lookup_table_json).is_err() {
+            if create_dir_all(prefix).is_ok()  {
+                if write(file_path.clone(), lookup_table_json).is_err() {
                     info!("Unable to write lookup_table file {file_path:?}");
                 }
             } else {
@@ -868,7 +857,7 @@ fn load_adapted_resources_lookup_table() -> HashMap<String, String>
 {
     let file_path = get_lookup_table_file_path();
 
-    let lookup_table: HashMap<String, String> = match fs::read(file_path.clone()){
+    let lookup_table: HashMap<String, String> = match read(file_path.clone()){
         Ok(data) => { serde_json::from_slice(&data).unwrap_or_default() },
         Err(_) => { HashMap::new() }
     };

lib/dsc-lib/src/dscerror.rs

@@ -26,6 +26,9 @@ pub enum DscError {
     #[error("{t} '{0}' [{t2} {1}] {t3}: {2}", t = t!("dscerror.commandResource"), t2 = t!("dscerror.exitCode"), t3 = t!("dscerror.manifestDescription"))]
     CommandExitFromManifest(String, i32, String),
 
+    #[error("{0}")]
+    CommandNotFound(String),
+
     #[error("{t} {0} {t2} '{1}'", t = t!("dscerror.commandOperation"), t2 = t!("dscerror.forExecutable"))]
     CommandOperation(String, String),
 

lib/dsc-lib/src/dscresources/command_resource.rs

@@ -6,13 +6,12 @@ use jsonschema::Validator;
 use rust_i18n::t;
 use serde::Deserialize;
 use serde_json::{Map, Value};
-use std::{collections::HashMap, env, path::Path, process::Stdio};
-use crate::configure::{config_doc::ExecutionKind, config_result::{ResourceGetResult, ResourceTestResult}};
+use std::{collections::HashMap, env, process::Stdio};
+use crate::{configure::{config_doc::ExecutionKind, config_result::{ResourceGetResult, ResourceTestResult}}, util::canonicalize_which};
 use crate::dscerror::DscError;
 use super::{dscresource::{get_diff, redact}, invoke_result::{ExportResult, GetResult, ResolveResult, SetResult, TestResult, ValidateResult, ResourceGetResponse, ResourceSetResponse, ResourceTestResponse, get_in_desired_state}, resource_manifest::{ArgKind, InputKind, Kind, ResourceManifest, ReturnKind, SchemaKind}};
 use tracing::{error, warn, info, debug, trace};
 use tokio::{io::{AsyncBufReadExt, AsyncWriteExt, BufReader}, process::Command};
-use which::which;
 
 pub const EXIT_PROCESS_TERMINATED: i32 = 0x102;
 
@@ -764,17 +763,7 @@ fn convert_hashmap_string_keys_to_i32(input: Option<&HashMap<String, String>>) -
 #[allow(clippy::implicit_hasher)]
 pub fn invoke_command(executable: &str, args: Option<Vec<String>>, input: Option<&str>, cwd: Option<&str>, env: Option<HashMap<String, String>>, exit_codes: Option<&HashMap<String, String>>) -> Result<(i32, String, String), DscError> {
     let exit_codes = convert_hashmap_string_keys_to_i32(exit_codes)?;
-    let mut executable = executable.to_string();
-    if which(&executable).is_err() && !Path::new(&executable).is_absolute() && cwd.is_some() {
-        if let Some(cwd) = cwd {
-            let cwd_path = Path::new(cwd);
-            let executable_path = cwd_path.join(&executable);
-            if !executable_path.exists() {
-                return Err(DscError::CommandOperation(t!("dscresources.commandResource.executableNotFound", executable = executable_path.display()).to_string(), executable.to_string()));
-            }
-            executable = executable_path.to_string_lossy().to_string();
-        }
-    }
+    let executable = canonicalize_which(executable, cwd)?;
 
     tokio::runtime::Builder::new_multi_thread().enable_all().build().unwrap().block_on(
         async {

lib/dsc-lib/src/util.rs

@@ -6,12 +6,13 @@ use rust_i18n::t;
 use serde_json::Value;
 use std::{
     fs,
-    fs::File,
+    fs::{canonicalize, File},
     io::BufReader,
     path::{Path, PathBuf},
     env,
 };
 use tracing::debug;
+use which::which;
 
 pub struct DscSettingValue {
     pub setting:  Value,
@@ -232,6 +233,29 @@ pub fn resource_id(type_name: &str, name: &str) -> String {
     result
 }
 
+pub fn canonicalize_which(executable: &str, cwd: Option<&str>) -> Result<String, DscError> {
+    let mut executable = executable.to_string().replace("/", std::path::MAIN_SEPARATOR_STR);
+    if cfg!(target_os = "windows") && !executable.ends_with(".exe") {
+        let mut exe_path = PathBuf::from(&executable);
+        exe_path.set_extension("exe");
+        executable = exe_path.to_string_lossy().to_string();
+    }
+    if which(&executable).is_err() && !Path::new(&executable).is_absolute() && cwd.is_some() {
+        if let Some(cwd) = cwd {
+            let cwd_path = Path::new(cwd);
+            match canonicalize(cwd_path.join(&executable)) {
+                Err(_err) => {
+                    return Err(DscError::CommandOperation(t!("util.executableNotFound", executable = &executable, cwd = cwd).to_string(), executable.to_string()));
+                },
+                Ok(canonical_path) => {
+                    executable = canonical_path.to_string_lossy().to_string();
+                }
+            }
+        }
+    }
+    Ok(executable)
+}
+
 #[macro_export]
 macro_rules! locked_is_empty {
     ($lockable:expr) => {{