clwrap 0.3.0

Command line wrapper for autologin then execute command
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

use crate::{Error, Session};
use futures_lite::{AsyncRead, AsyncWrite};
use std::time::Duration;
use tracing::{trace, warn};
use typed_builder::TypedBuilder;

#[derive(TypedBuilder)]
pub struct UserPassLoginRunner {
    prompt_username: String,
    prompt_password: String,

    #[builder(default = Some(3))]
    retry_prompt_username: Option<u64>,
}

impl UserPassLoginRunner {
    pub async fn login<P, S: AsyncRead + AsyncWrite + Unpin>(
        self,
        mut session: Session<P, S>,
        username: &str,
        password: &str,
        prompt: Option<&regex::Regex>,
    ) -> core::result::Result<Session<P, S>, Error> {
        // First time is quick
        session.set_expect_timeout(Some(Duration::from_millis(1)));

        trace!("Start expect prompt username");
        let mut counter = 0;
        while counter < self.retry_prompt_username.unwrap_or(1) {
            trace!("counter={}: try..", counter);
            match session.expect(self.prompt_username.clone()).await {
                Ok(_) => break,
                Err(expectrl::Error::ExpectTimeout) => {
                    if let Some(prompt) = prompt {
                        // already login check
                        let prompt = prompt.as_str().to_string();
                        if session.is_matched(expectrl::Regex(prompt)).await? {
                            trace!("Already logged in");
                            return Ok(session);
                        }
                    }
                    trace!("send new line");
                    session.send_line("").await?;
                }
                Err(e) => return Err(e.into()),
            }
            session.set_expect_timeout(Some(Duration::from_secs(1)));

            if self.retry_prompt_username.is_some() {
                counter += 1;
            }
        }

        // Set to normal operation
        session.set_expect_timeout(Some(Duration::from_secs(1)));

        trace!("send username");
        session.send_line(username).await?;
        if let Err(e) = session.expect(self.prompt_password).await {
            warn!("Could not found password prompt");
            return Err(e.into());
        };
        trace!("send password");
        session.send_line(password).await?;

        Ok(session)
    }
}

#[derive(TypedBuilder)]
#[builder(build_method(vis = "", name = build_inner))]
pub struct LinuxLoginRunner {
    #[builder(default = Some(Duration::from_secs_f32(3.)))]
    timeout: Option<Duration>,
}

impl LinuxLoginRunnerBuilder<((),)> {
    pub fn build(self) -> UserPassLoginRunner {
        let runner = self.build_inner();
        UserPassLoginRunner::builder()
            .prompt_username("login: ".to_string())
            .prompt_password("Password:".to_string())
            .retry_prompt_username(runner.timeout.map(|t| t.as_secs() + 1))
            .build()
    }
}

#[derive(TypedBuilder)]
#[builder(build_method(vis = "", name = build_inner))]
pub struct SwitchLoginRunner {
    #[builder(default = Some(Duration::from_secs_f32(3.)))]
    timeout: Option<Duration>,
}

impl SwitchLoginRunnerBuilder<((),)> {
    pub fn build(self) -> UserPassLoginRunner {
        let runner = self.build_inner();
        UserPassLoginRunner::builder()
            .prompt_username("Username: ".to_string())
            .prompt_password("Password:".to_string())
            .retry_prompt_username(runner.timeout.map(|t| t.as_secs() + 1))
            .build()
    }
}