Struct WslProcess

pub struct WslProcess {
    pub stdin: Option<ChildStdin>,
    pub stdout: Option<ChildStdout>,
    pub stderr: Option<ChildStderr>,
    /* private fields */
}

Fields

stdin: Option<ChildStdin>

stdout: Option<ChildStdout>

stderr: Option<ChildStderr>

Implementations

impl WslProcess

pub fn wait(self) -> Result<ExitStatus, WslError>

Examples found in repository

examples/basic_usage.rs (line 57)

fn run_command(wsl: &Wsl2, distro_uuid: uuid::Uuid) -> Result<(), Box<dyn std::error::Error>> {
    println!("Running command...");
    let result = wsl.launch(
        distro_uuid,
        "/bin/echo",
        &["echo", "Hello, world!"],
        None,
        "root",
    );
    let mut process = {
        match result {
            Ok(process) => {
                println!("Successfully ran command: {process:?}");
                process
            }
            Err(e) => {
                eprintln!("Failed to run command: {:?}", e);
                return Err(e.into());
            }
        }
    };

    let stdout = process.stdout.take().unwrap();
    let stderr = process.stderr.take().unwrap();

    let stdout_thread = std::thread::spawn(move || {
        let reader = std::io::BufReader::new(stdout);
        for line in reader.lines() {
            match line {
                Ok(line) => println!("stdout: {}", line),
                Err(e) => {
                    eprintln!("Error reading stdout: {}", e);
                    return;
                }
            }
        }
    });

    let stderr_thread = std::thread::spawn(move || {
        let reader = std::io::BufReader::new(stderr);
        for line in reader.lines() {
            match line {
                Ok(line) => println!("stderr: {}", line),
                Err(e) => {
                    eprintln!("Error reading stderr: {}", e);
                    return;
                }
            }
        }
    });

    println!("Waiting for process to finish...");
    let status = process.wait()?;
    println!("Process finished with status: {status:?}");

    stdout_thread.join().unwrap();
    stderr_thread.join().unwrap();

    Ok(())
}

Trait Implementations

impl Debug for WslProcess

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for WslProcess

fn drop(&mut self)

Executes the destructor for this type.