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

use anyhow::Result;
use clap::Parser;
use clwrap::*;
use std::env;
use tracing::debug;

/// ConsoLe wrapper runner
///
/// Auto login then execute command
/// Currently support only for linux system
#[derive(Parser, Debug)]
#[clap(version, about, long_about = None, rename_all="snake_case")]
struct Args {
    #[arg(short = 'u', long)]
    username: String,

    #[arg(short = 'p', long)]
    password: String,

    #[arg(long)]
    trim_end: bool,
}

fn main() -> Result<()> {
    {
        use tracing_subscriber::{/*filter::LevelFilter,*/ EnvFilter};
        tracing_subscriber::fmt()
            .with_env_filter(
                EnvFilter::try_from_default_env()
                    .unwrap_or_else(|_| {
                        EnvFilter::builder()
                            .parse("clwrap=warn")
                            .expect("Envfilter")
                    })
                    // Use default
                    // .add_directive(LevelFilter::WARN.into()),
            )
            .init();
    }
    futures_lite::future::block_on(async {
        let mut argv = env::args_os();
        let args = Args::parse_from(argv.by_ref().take_while(|arg| arg != "--"));
        let spawn_command = argv
            .by_ref()
            .take_while(|arg| arg != "--")
            .collect::<Vec<_>>();
        let exec_command = argv.collect::<Vec<_>>();

        let spawn_command = spawn_command
            .iter()
            .map(|s| s.to_str().unwrap_or(""))
            .collect::<Vec<&str>>()
            .join(" ");
        let exec_command = exec_command
            .iter()
            .map(|s| s.to_str().unwrap_or(""))
            .collect::<Vec<&str>>()
            .join(" ");

        debug!("{:?}", args);
        debug!("spawn_command: {:?}", spawn_command);
        debug!("exec_command: {:?}", exec_command);

        let username = args.username;
        let password = args.password;

        let session = spawn(spawn_command)?;
        let (recv, _) = linux_oneshot(session, &username, &password, None, exec_command).await?;
        let recv = std::str::from_utf8(&recv)?;
        let recv = recv.replace("\r\n", "\n");
        let recv = if args.trim_end {
            recv.trim_end_matches(|c: char| c.is_whitespace() || c == '\0')
        } else {
            &recv
        };

        println!("{}", recv);
        Ok(())
    })
}