Struct ptyprocess::PtyProcess

pub struct PtyProcess { /* fields omitted */ }

PtyProcess represents a controller for a spawned process.

The structure implements std::io::Read and std::io::Write which communicates 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 creates a PtyProcess structure which controll communication with a child

    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.

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 is 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 were setup

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

Get_echo 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>

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 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. So sometimes it’s better to use a is_alive method

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

Checks if a process is still exists.

It’s a non blocking operation. It’s takes in mind errors which indicates that the child is gone.

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

Try to force a child to terminate.

It starts nicely with SIGHUP, SIGCONT, SIGINT, SIGTERM. If “force” is True then moves onto SIGKILL.

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

impl PtyProcess

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

Send writes a string to a STDIN of a child.

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

Send writes a line to a STDIN of a child.

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

Send controll character to a child process.

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

Send EOF indicator to a child process.

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

Send INTR indicator to a child process.

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.