Struct expectrl::interact::InteractOptions

pub struct InteractOptions<C, IF, OF, IA, OA, WA> { /* private fields */ }

Interact options (aka callbacks you can set to be callled being in an interactive mode).

Implementations

impl<S, I, O, C> InteractOptions<C, NoFilter, NoFilter, NoAction<Session<OsProcess, S>, I, O, C>, NoAction<Session<OsProcess, S>, I, O, C>, NoAction<Session<OsProcess, S>, I, O, C>>

pub fn new(state: C) -> Self

Set a state.

Examples found in repository

examples/ftp_interact.rs (line 14)

fn main() -> Result<(), Error> {
    let mut auth = false;
    let mut login_lookup = Lookup::new();
    let opts = InteractOptions::new(&mut auth).on_output(|ctx| {
        if login_lookup
            .on(ctx.buf, ctx.eof, "Login successful")?
            .is_some()
        {
            **ctx.state = true;
            return Ok(true);
        }

        Ok(false)
    });

    let mut p = spawn("ftp bks4-speedtest-1.tele2.net")?;

    let mut stdin = Stdin::open()?;
    p.interact(&mut stdin, stdout()).spawn(opts)?;
    stdin.close()?;

    if !auth {
        println!("An authefication was not passed");
        return Ok(());
    }

    p.expect("ftp>")?;
    p.send_line("cd upload")?;
    p.expect("successfully changed.")?;
    p.send_line("pwd")?;
    p.expect(Regex("[0-9]+ \"/upload\""))?;
    p.send(ControlCode::EndOfTransmission)?;
    p.expect("Goodbye.")?;
    Ok(())
}

examples/interact_with_callback.rs (line 21)

fn main() {
    let mut output_action = Lookup::new();
    let mut input_action = Lookup::new();
    let mut state = State::default();
    let opts = InteractOptions::new(&mut state)
        .on_output(|mut ctx| {
            let m = output_action.on(ctx.buf, ctx.eof, "Continue [y/n]:")?;
            if m.is_some() {
                ctx.state.wait_for_continue = Some(true);
            };

            let m = output_action.on(ctx.buf, ctx.eof, Regex("status:\\s*.*\\w+.*\\r\\n"))?;
            if m.is_some() {
                ctx.state.stutus_verification_counter =
                    Some(ctx.state.stutus_verification_counter.map_or(1, |c| c + 1));
                output_action.clear();
            }

            Ok(false)
        })
        .on_input(|mut ctx| {
            let m = input_action.on(ctx.buf, ctx.eof, "y")?;
            if m.is_some() {
                if let Some(_a @ true) = ctx.state.wait_for_continue {
                    ctx.state.pressed_yes_on_continue = Some(true);
                }
            };

            let m = input_action.on(ctx.buf, ctx.eof, "n")?;
            if m.is_some() {
                if let Some(_a @ true) = ctx.state.wait_for_continue {
                    ctx.state.pressed_yes_on_continue = Some(false);
                }
            }

            Ok(false)
        });

    let mut session = spawn("python ./tests/source/ansi.py").expect("Can't spawn a session");

    let mut stdin = Stdin::open().unwrap();
    let stdout = std::io::stdout();

    let mut interact = session.interact(&mut stdin, stdout);

    let is_alive = interact.spawn(opts).expect("Failed to start interact");

    if !is_alive {
        println!("The process was exited");
        #[cfg(unix)]
        println!("Status={:?}", interact.get_status());
    }

    stdin.close().unwrap();

    println!("RESULTS");
    println!(
        "Number of time 'Y' was pressed = {}",
        state.pressed_yes_on_continue.unwrap_or_default()
    );
    println!(
        "Status counter = {}",
        state.stutus_verification_counter.unwrap_or_default()
    );
}

impl<C, IF, OF, IA, OA, WA> InteractOptions<C, IF, OF, IA, OA, WA>

pub fn get_state(&self) -> &C

Get a reference on state

pub fn get_state_mut(&mut self) -> &mut C

Get a mut reference on state

pub fn into_inner(self) -> C

Returns a inner state.

pub fn output_filter<F>( self, filter: F ) -> InteractOptions<C, IF, F, IA, OA, WA>where F: FnMut(&[u8]) -> Result<Cow<'_, [u8]>, Error>,

Sets the output filter. The output_filter will be passed all the output from the child process.

The filter isn’t applied to user’s read calls through the Context in callbacks.

pub fn input_filter<F>(self, filter: F) -> InteractOptions<C, F, OF, IA, OA, WA>where F: FnMut(&[u8]) -> Result<Cow<'_, [u8]>, Error>,

Sets the input filter. The input_filter will be passed all the keyboard input from the user.

The input_filter is run BEFORE the check for the escape_character. The filter is called BEFORE calling a on_input callback if it’s set.

impl<S, I, O, C, IF, OF, OA, WA> InteractOptions<C, IF, OF, NoAction<Session<OsProcess, S>, I, O, C>, OA, WA>

pub fn on_input<F>(self, action: F) -> InteractOptions<C, IF, OF, F, OA, WA>where F: FnMut(Context<'_, Session<OsProcess, S>, I, O, C>) -> Result<bool, Error>,

Puts a hanlder which will be called when users input is detected.

Be aware that currently async version doesn’t take a Session as an argument. See https://github.com/zhiburt/expectrl/issues/16.

Examples found in repository

examples/interact_with_callback.rs (lines 37-53)

fn main() {
    let mut output_action = Lookup::new();
    let mut input_action = Lookup::new();
    let mut state = State::default();
    let opts = InteractOptions::new(&mut state)
        .on_output(|mut ctx| {
            let m = output_action.on(ctx.buf, ctx.eof, "Continue [y/n]:")?;
            if m.is_some() {
                ctx.state.wait_for_continue = Some(true);
            };

            let m = output_action.on(ctx.buf, ctx.eof, Regex("status:\\s*.*\\w+.*\\r\\n"))?;
            if m.is_some() {
                ctx.state.stutus_verification_counter =
                    Some(ctx.state.stutus_verification_counter.map_or(1, |c| c + 1));
                output_action.clear();
            }

            Ok(false)
        })
        .on_input(|mut ctx| {
            let m = input_action.on(ctx.buf, ctx.eof, "y")?;
            if m.is_some() {
                if let Some(_a @ true) = ctx.state.wait_for_continue {
                    ctx.state.pressed_yes_on_continue = Some(true);
                }
            };

            let m = input_action.on(ctx.buf, ctx.eof, "n")?;
            if m.is_some() {
                if let Some(_a @ true) = ctx.state.wait_for_continue {
                    ctx.state.pressed_yes_on_continue = Some(false);
                }
            }

            Ok(false)
        });

    let mut session = spawn("python ./tests/source/ansi.py").expect("Can't spawn a session");

    let mut stdin = Stdin::open().unwrap();
    let stdout = std::io::stdout();

    let mut interact = session.interact(&mut stdin, stdout);

    let is_alive = interact.spawn(opts).expect("Failed to start interact");

    if !is_alive {
        println!("The process was exited");
        #[cfg(unix)]
        println!("Status={:?}", interact.get_status());
    }

    stdin.close().unwrap();

    println!("RESULTS");
    println!(
        "Number of time 'Y' was pressed = {}",
        state.pressed_yes_on_continue.unwrap_or_default()
    );
    println!(
        "Status counter = {}",
        state.stutus_verification_counter.unwrap_or_default()
    );
}

impl<S, I, O, C, IF, OF, IA, WA> InteractOptions<C, IF, OF, IA, NoAction<Session<OsProcess, S>, I, O, C>, WA>

pub fn on_output<F>(self, action: F) -> InteractOptions<C, IF, OF, IA, F, WA>where F: FnMut(Context<'_, Session<OsProcess, S>, I, O, C>) -> Result<bool, Error>,

Puts a hanlder which will be called when process output is detected.

IMPORTANT:

Please be aware that your use of Session::expect, Session::check and any read operation on session will cause the read bytes not to apeard in the output stream!

Examples found in repository

examples/ftp_interact.rs (lines 14-24)

fn main() -> Result<(), Error> {
    let mut auth = false;
    let mut login_lookup = Lookup::new();
    let opts = InteractOptions::new(&mut auth).on_output(|ctx| {
        if login_lookup
            .on(ctx.buf, ctx.eof, "Login successful")?
            .is_some()
        {
            **ctx.state = true;
            return Ok(true);
        }

        Ok(false)
    });

    let mut p = spawn("ftp bks4-speedtest-1.tele2.net")?;

    let mut stdin = Stdin::open()?;
    p.interact(&mut stdin, stdout()).spawn(opts)?;
    stdin.close()?;

    if !auth {
        println!("An authefication was not passed");
        return Ok(());
    }

    p.expect("ftp>")?;
    p.send_line("cd upload")?;
    p.expect("successfully changed.")?;
    p.send_line("pwd")?;
    p.expect(Regex("[0-9]+ \"/upload\""))?;
    p.send(ControlCode::EndOfTransmission)?;
    p.expect("Goodbye.")?;
    Ok(())
}

examples/interact_with_callback.rs (lines 22-36)

fn main() {
    let mut output_action = Lookup::new();
    let mut input_action = Lookup::new();
    let mut state = State::default();
    let opts = InteractOptions::new(&mut state)
        .on_output(|mut ctx| {
            let m = output_action.on(ctx.buf, ctx.eof, "Continue [y/n]:")?;
            if m.is_some() {
                ctx.state.wait_for_continue = Some(true);
            };

            let m = output_action.on(ctx.buf, ctx.eof, Regex("status:\\s*.*\\w+.*\\r\\n"))?;
            if m.is_some() {
                ctx.state.stutus_verification_counter =
                    Some(ctx.state.stutus_verification_counter.map_or(1, |c| c + 1));
                output_action.clear();
            }

            Ok(false)
        })
        .on_input(|mut ctx| {
            let m = input_action.on(ctx.buf, ctx.eof, "y")?;
            if m.is_some() {
                if let Some(_a @ true) = ctx.state.wait_for_continue {
                    ctx.state.pressed_yes_on_continue = Some(true);
                }
            };

            let m = input_action.on(ctx.buf, ctx.eof, "n")?;
            if m.is_some() {
                if let Some(_a @ true) = ctx.state.wait_for_continue {
                    ctx.state.pressed_yes_on_continue = Some(false);
                }
            }

            Ok(false)
        });

    let mut session = spawn("python ./tests/source/ansi.py").expect("Can't spawn a session");

    let mut stdin = Stdin::open().unwrap();
    let stdout = std::io::stdout();

    let mut interact = session.interact(&mut stdin, stdout);

    let is_alive = interact.spawn(opts).expect("Failed to start interact");

    if !is_alive {
        println!("The process was exited");
        #[cfg(unix)]
        println!("Status={:?}", interact.get_status());
    }

    stdin.close().unwrap();

    println!("RESULTS");
    println!(
        "Number of time 'Y' was pressed = {}",
        state.pressed_yes_on_continue.unwrap_or_default()
    );
    println!(
        "Status counter = {}",
        state.stutus_verification_counter.unwrap_or_default()
    );
}

impl<S, I, O, C, IF, OF, IA, OA> InteractOptions<C, IF, OF, IA, OA, NoAction<Session<OsProcess, S>, I, O, C>>

pub fn on_idle<F>(self, action: F) -> InteractOptions<C, IF, OF, IA, OA, F>where F: FnMut(Context<'_, Session<OsProcess, S>, I, O, C>) -> Result<bool, Error>,

Puts a handler which will be called on each interaction when no input is detected.

Trait Implementations

impl<C: Debug, IF: Debug, OF: Debug, IA: Debug, OA: Debug, WA: Debug> Debug for InteractOptions<C, IF, OF, IA, OA, WA>

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

Formats the value using the given formatter.

impl<S, I, O> Default for InteractOptions<(), NoFilter, NoFilter, NoAction<Session<OsProcess, S>, I, O, ()>, NoAction<Session<OsProcess, S>, I, O, ()>, NoAction<Session<OsProcess, S>, I, O, ()>>

fn default() -> Self

Returns the “default value” for a type.