Function run_process_async

lib/dsc-lib/src/dscresources/command_resource.rs:761–871

Asynchronously invoke a command and return the exit code, stdout, and stderr. # Arguments `executable` - The command to execute `args` - Optional arguments to pass to the command `input` - Optional input to pass to the command `cwd` - Optional working directory to execute the command in `env` - Optional environment variable mappings to add or update `exit_codes` - Descriptions of exit codes, eit

(executable: &str, args: Option<Vec<String>>, input: Option<&str>, cwd: Option<&Path>, env: Option<HashMap<String, String>>, exit_codes: &ExitCodesMap)

/// Error is returned if the command fails to execute or stdin/stdout/stderr cannot be opened.
///
async fn run_process_async(executable: &str, args: Option<Vec<String>>, input: Option<&str>, cwd: Option<&Path>, env: Option<HashMap<String, String>>, exit_codes: &ExitCodesMap) -> Result<(i32, String, String), DscError> {

    // use somewhat large initial buffer to avoid early string reallocations;
    // the value is based on list result of largest of built-in adapters - WMI adapter ~500KB
    const INITIAL_BUFFER_CAPACITY: usize = 1024*1024;

    let mut command = Command::new(executable);
    if input.is_some() {
        command.stdin(Stdio::piped());
    } else {
        command.stdin(Stdio::null());
    }
    command.stdout(Stdio::piped());
    command.stderr(Stdio::piped());
    if let Some(args) = args {
        command.args(args);
    }
    if let Some(cwd) = cwd {
        command.current_dir(cwd);
    }
    if let Some(env) = env {
        command.envs(env);
    }
    if executable == "dsc" && env::var("DEBUG_DSC").is_ok() {
        // remove this env var from child process as it will fail reading from keyboard to allow attaching
        command.env_remove("DEBUG_DSC");
    }

    let mut child = match command.spawn() {
        Ok(c) => c,
        Err(e) => {
            return Err(DscError::CommandOperation(e.to_string(), executable.to_string()))
        }
    };

    let Some(stdout) = child.stdout.take() else {
        return Err(DscError::CommandOperation(t!("dscresources.commandResource.processChildStdout").to_string(), executable.to_string()));
    };
    let Some(stderr) = child.stderr.take() else {
        return Err(DscError::CommandOperation(t!("dscresources.commandResource.processChildStderr").to_string(), executable.to_string()));
    };
    let mut stdout_reader = BufReader::new(stdout).lines();
    let mut stderr_reader = BufReader::new(stderr).lines();

    if let Some(input) = input {
        trace!("Writing to command STDIN: {input}");
        let Some(mut stdin) = child.stdin.take() else {
            return Err(DscError::CommandOperation(t!("dscresources.commandResource.processChildStdin").to_string(), executable.to_string()));
        };
        if stdin.write_all(input.as_bytes()).await.is_err() {
            return Err(DscError::CommandOperation(t!("dscresources.commandResource.processWriteStdin").to_string(), executable.to_string()));
        }
        drop(stdin);
    }

    let Some(child_id) = child.id() else {
        return Err(DscError::CommandOperation(t!("dscresources.commandResource.processChildId").to_string(), executable.to_string()));
    };