Struct ptyprocess::PtyProcess

pub struct PtyProcess { /* fields omitted */ }

PtyProcess controls a spawned process and communication with this.

It implements std::io::Read and std::io::Write to communicate with a child.

use ptyprocess::PtyProcess;
use std::io::Write;
use std::process::Command;

let mut process = PtyProcess::spawn(Command::new("cat")).unwrap();
process.write_all(b"Hello World").unwrap();
process.flush().unwrap();

Implementations

impl PtyProcess

pub fn spawn(command: Command) -> Result<Self>

Spawns a child process and create a PtyProcess.

    let proc = PtyProcess::spawn(Command::new("bash"));

pub fn pid(&self) -> Pid

Returns a pid of a child process

pub fn get_pty_handle(&self) -> Result<File>

Returns a file representation of a PTY, which can be used to communicate with it.

Safety

Be carefull changing a descriptors inner state (e.g fcntl) because it affects all structures which use it.

Example

use ptyprocess::PtyProcess;
use std::{process::Command, io::{BufReader, LineWriter}};

let mut process = PtyProcess::spawn(Command::new("cat")).unwrap();
let pty = process.get_pty_handle().unwrap();
let mut writer = LineWriter::new(&pty);
let mut reader = BufReader::new(&pty);

pub fn get_window_size(&self) -> Result<(u16, u16)>

Get window size of a terminal.

Default size is 80x24.

pub fn set_window_size(&mut self, cols: u16, rows: u16) -> Result<()>

Sets a terminal size.

pub fn wait_echo(&self, on: bool, timeout: Option<Duration>) -> Result<bool>

Waits until a echo settings is setup.

pub fn get_echo(&self) -> Result<bool>

The function returns true if an echo setting is setup.

pub fn set_echo(&mut self, on: bool) -> Result<()>

Sets a echo setting for a terminal

pub fn isatty(&self) -> Result<bool>

Returns true if a underline fd connected with a TTY.

pub fn set_terminate_approach_delay(
    &mut self,
    terminate_approach_delay: Duration
)

Set the pty process’s terminate approach delay.

pub fn status(&self) -> Result<WaitStatus>

Status returns a status a of child process.

pub fn kill(&mut self, signal: Signal) -> Result<()>

Kill sends a signal to a child process.

The operation is non-blocking.

pub fn signal(&mut self, signal: Signal) -> Result<()>

Signal is an alias to PtyProcess::kill.

pub fn wait(&self) -> Result<WaitStatus>

Wait blocks until a child process exits.

It returns a error if the child was DEAD or not exist at the time of a call.

If you need to verify that a process is dead in non-blocking way you can use is_alive method.

pub fn is_alive(&self) -> Result<bool>

Checks if a process is still exists.

It’s a non blocking operation.

pub fn exit(&mut self, force: bool) -> Result<bool>

Try to force a child to terminate.

This returns true if the child was terminated. and returns false if the child could not be terminated.

It makes 4 tries getting more thorough.

1. SIGHUP
2. SIGCONT
3. SIGINT
4. SIGTERM

If “force” is true then moves onto SIGKILL.

impl PtyProcess

pub fn send<S: AsRef<str>>(&mut self, s: S) -> Result<()>

Send text to child’s STDIN.

To write bytes you can use a std::io::Write operations instead.

pub fn send_line<S: AsRef<str>>(&mut self, s: S) -> Result<()>

Send a line to child’s STDIN.

pub fn send_control(&mut self, code: impl TryInto<ControlCode>) -> Result<()>

Send controll character to a child process.

You must be carefull passing a char or &str as an argument. If you pass an unexpected controll you’ll get a error. So it may be better to use ControlCode.

use ptyprocess::{PtyProcess, ControlCode};
use std::process::Command;

let mut process = PtyProcess::spawn(Command::new("cat")).unwrap();
process.send_control(ControlCode::EndOfText); // sends CTRL^C
process.send_control('C'); // sends CTRL^C
process.send_control("^C"); // sends CTRL^C

pub fn send_eof(&mut self) -> Result<()>

Send EOF indicator to a child process.

Often eof char handled as it would be a CTRL-C.

pub fn send_intr(&mut self) -> Result<()>

Send INTR indicator to a child process.

Often intr char handled as it would be a CTRL-D.

Trait Implementations

impl Debug for PtyProcess

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

Formats the value using the given formatter.

impl Deref for PtyProcess

type Target = Stream

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for PtyProcess

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl Drop for PtyProcess

fn drop(&mut self)

Executes the destructor for this type.