Function spawn

pub fn spawn(
    program: &str,
    timeout_ms: Option<u64>,
) -> Result<PtySession, Error>

Start command in background in a pty session (pty fork) and return a struct with writer and buffered reader (for unblocking reads).

#Arguments:

• program: This is split at spaces and turned into a process::Command if you wish more control over this, use spawn_command
• timeout: If Some: all exp_* commands time out after x milliseconds, if None: never times out. It’s highly recommended to put a timeout there, as otherwise in case of a problem the program just hangs instead of exiting with an error message indicating where it stopped. For automation 30’000 (30s, the default in pexpect) is a good value.

Examples found in repository

examples/ftp.rs (line 5)

fn main() -> Result<(), Error> {
    let mut p = spawn("ftp speedtest.tele2.net", Some(2000))?;
    p.exp_regex("Name \\(.*\\):")?;
    p.send_line("anonymous")?;
    p.exp_string("Password")?;
    p.send_line("test")?;
    p.exp_string("ftp>")?;
    p.send_line("cd upload")?;
    p.exp_string("successfully changed.\r\nftp>")?;
    p.send_line("pwd")?;
    p.exp_regex("[0-9]+ \"/upload\"")?;
    p.send_line("exit")?;
    p.exp_eof()?;
    Ok(())
}

examples/repl.rs (line 15)

fn ed_session() -> Result<PtyReplSession, Error> {
    let mut ed = PtyReplSession {
        // for `echo_on` you need to figure that out by trial and error.
        // For bash and python repl it is false
        echo_on: false,

        // used for `wait_for_prompt()`
        prompt: "> ".to_owned(),
        pty_session: spawn("/bin/ed -p '> '", Some(2000))?,
        // command which is sent when the instance of this struct is dropped
        // in the below example this is not needed, but if you don't explicitly
        // exit a REPL then rexpect tries to send a SIGTERM and depending on the repl
        // this does not end the repl and would end up in an error
        quit_command: Some("Q".to_owned()),
    };
    ed.wait_for_prompt()?;
    Ok(ed)
}

examples/exit_code.rs (line 10)

fn main() -> Result<(), Error> {
    let p = spawn("cat /etc/passwd", Some(2000))?;
    match p.process.wait() {
        Ok(wait::WaitStatus::Exited(_, 0)) => println!("cat exited with code 0, all good!"),
        _ => println!("cat exited with code >0, or it was killed"),
    }

    let mut p = spawn("cat /this/does/not/exist", Some(2000))?;
    match p.process.wait() {
        Ok(wait::WaitStatus::Exited(_, 0)) => println!("cat succeeded"),
        Ok(wait::WaitStatus::Exited(_, c)) => {
            println!("Cat failed with exit code {c}");
            println!("Output (stdout and stderr): {}", p.exp_eof()?);
        }
        // for other possible return types of wait()
        // see here: https://tailhook.github.io/rotor/nix/sys/wait/enum.WaitStatus.html
        _ => println!("cat was probably killed"),
    }

    Ok(())
}