Struct expectrl::Session

pub struct Session { /* fields omitted */ }

Session represents a process and its streams. It controlls process and communication with it.

Implementations

impl Session

pub fn spawn(cmd: &str) -> Result<Self, Error>

Spawn spawn a cmd process

pub fn spawn_cmd(command: Command) -> Result<Self, Error>

Spawn spawns a command

pub fn expect<E: Needle>(&mut self, expect: E) -> Result<Found, Error>

Expect waits until a pattern is matched.

It return error if expect_timeout is reached.

pub fn set_expect_timeout(&mut self, expect_timeout: Option<Duration>)

Set the pty session’s expect timeout.

Methods from Deref<Target = PtyProcess>

pub fn pid(&self) -> Pid

Returns a pid of a child process

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

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), Error>

Get window size of a terminal.

Default is size is 80x24.

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

Sets a terminal size

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

Waits until a echo settings were setup

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

Get_echo returns true if an echo setting is setup.

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

Sets a echo setting for a terminal

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

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, Error>

Status returns a status a of child process.

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

Kill sends a signal to a child process.

The operation is non-blocking.

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

Signal is an alias to kill.

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

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, Error>

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, Error>

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.

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

Send writes a string to a STDIN of a child.

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

Send writes a line to a STDIN of a child.

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

Send controll character to a child process.

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

Send EOF indicator to a child process.

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

Send INTR indicator to a child process.

Trait Implementations

impl Debug for Session

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

Formats the value using the given formatter.

impl Deref for Session

type Target = PtyProcess

The resulting type after dereferencing.

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

Dereferences the value.

impl DerefMut for Session

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

Mutably dereferences the value.