Struct pwner::process::Duplex

pub struct Duplex(_, _);

An implementation of Process that uses std::process as the launcher.

All read and write operations are sync.

Note: On *nix platforms, the owned process will have 2 seconds between signals, which is a blocking wait.

Implementations

impl Duplex

pub fn id(&self) -> u32

Returns the OS-assigned process identifier associated with this child.

Examples

Basic usage:

use std::process::Command;
use pwner::Spawner;

let mut command = Command::new("ls");
if let Ok(child) = command.spawn_owned() {
    println!("Child's ID is {}", child.id());
} else {
    println!("ls command didn't start");
}

pub fn read_from(&mut self, read_source: ReadSource) -> &mut Self

Choose which pipe to read form next.

Examples

Basic usage:

use std::io::Read;
use std::process::Command;
use pwner::Spawner;
use pwner::process::ReadSource;

let mut child = Command::new("ls").spawn_owned().unwrap();
let mut buffer = [0_u8; 1024];
child.read_from(ReadSource::Stdout).read(&mut buffer).unwrap();

pub fn wait(self) -> Result<(ExitStatus, ChildStdout, ChildStderr), Error>

Waits for the child to exit completely, returning the status with which it exited, stdout, and stderr.

The stdin handle to the child process, if any, will be closed before waiting. This helps avoid deadlock: it ensures that the child does not block waiting for input from the parent, while the parent waits for the child to exit.

Examples

Basic usage:

use pwner::Spawner;
use std::io::{BufReader, Read};
use std::process::Command;

let child = Command::new("ls").spawn_owned().unwrap();
let (status, stdout, stderr) = child.wait().unwrap();

let mut buffer = String::new();
if status.success() {
    let mut reader = BufReader::new(stdout);
    reader.read_to_string(&mut buffer).unwrap();
} else {
    let mut reader = BufReader::new(stderr);
    reader.read_to_string(&mut buffer).unwrap();
}

Errors

Relays the error from std::process::Child::wait()

pub fn pipes(&mut self) -> (&mut ChildStdin, &mut ChildStdout, &mut ChildStderr)

Decomposes the handle into mutable references to the pipes.

Examples

Basic usage:

use std::io::{ Read, Write };
use std::process::Command;
use pwner::Spawner;

let mut child = Command::new("cat").spawn_owned().unwrap();
let mut buffer = [0_u8; 1024];
let (stdin, stdout, _) = child.pipes();

stdin.write_all(b"hello\n").unwrap();
stdout.read(&mut buffer).unwrap();

pub fn decompose(self) -> (Simplex, Output)

Separates the process and its input from the output pipes. Ownership is retained by a Simplex which still implements a graceful drop of the child process.

Examples

Basic usage:

use std::io::{Read, Write};
use std::process::Command;
use pwner::Spawner;

let child = Command::new("cat").spawn_owned().unwrap();
let (mut input_only_process, mut output) = child.decompose();

// Spawn printing thread
std::thread::spawn(move || {
    let mut buffer = [0; 1024];
    while let Ok(bytes) = output.read(&mut buffer) {
        if let Ok(string) = std::str::from_utf8(&buffer[..bytes]) {
            print!("{}", string);
        }
    }
});

// Interact normally with the child process
input_only_process.write_all(b"hello\n").unwrap();

pub fn eject(self) -> (Child, ChildStdin, ChildStdout, ChildStderr)

Completely releases the ownership of the child process. The raw underlying process and pipes are returned and no wrapping function is applicable any longer.

Note: By ejecting the process, graceful drop will no longer be available.

Examples

Basic usage:

use std::io::{ Read, Write };
use std::process::Command;
use pwner::Spawner;

let mut child = Command::new("cat").spawn_owned().unwrap();
let mut buffer = [0_u8; 1024];
let (process, mut stdin, mut stdout, _) = child.eject();

stdin.write_all(b"hello\n").unwrap();
stdout.read(&mut buffer).unwrap();

// Graceful drop will not be executed for `child` as the ejected variable leaves scope here

Trait Implementations

impl Read for Duplex

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Reader has an efficient read_vectored implementation.

fn read_to_end(&mut self, buf: &mut Vec<u8, Global>) -> Result<usize, Error>

Read all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Read all bytes until EOF in this source, appending them to buf.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>

Read the exact number of bytes required to fill buf.

fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Pull some bytes from this source into the specified buffer.

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Read the exact number of bytes required to fill cursor.

fn by_ref(&mut self) -> &mut Selfwhere
    Self: Sized,

Creates a “by reference” adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>where
    Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R>where
    R: Read,
    Self: Sized,

Creates an adapter which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>where
    Self: Sized,

Creates an adapter which will read at most limit bytes from it.

impl Write for Duplex

fn write(&mut self, buf: &[u8]) -> Result<usize>

Write a buffer into this writer, returning how many bytes were written.

fn flush(&mut self) -> Result<()>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Selfwhere
    Self: Sized,

Creates a “by reference” adapter for this instance of Write.

impl Process for Duplex