rilis 0.1.2

Local deployment tools built with Rust
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

use anyhow::Result;
use clap::Parser;
use log::{error, info};
use rilis::{
    args::Args,
    config,
    logger::setup_logger,
    pw,
    ssh::{client::Session, client_sftp::client_sftp},
};
use std::fs;

#[tokio::main]
async fn main() -> Result<()> {
    setup_logger();

    let args = Args::parse();

    let content = match fs::read_to_string(args.config) {
        Ok(content) => content,
        Err(e) => {
            error!("Failed to read configuration file: {:?}", e.to_string());
            std::process::exit(0)
        }
    };

    match toml::from_str::<config::Config>(&content) {
        // if validated do ssh connection to the server
        Ok(config) => match config.validation() {
            Ok(vc) => {
                // do connect to server via ssh
                let mut ssh = Session::connect(
                    vc.ssh.private_key.clone(),
                    &vc.ssh.username,
                    vc.ssh.password.clone(),
                    format!("{}:{}", vc.ssh.address, vc.ssh.port),
                )
                .await?;

                info!("Connected: {}@{}", vc.ssh.username, vc.ssh.address);

                // if scp exists, do execute
                match &vc.server.scp {
                    Some(scp) => {
                        for file in scp.to_vec() {
                            let session = &ssh.session;
                            client_sftp(session, file.as_str(), file.as_str()).await?;
                        }
                    }
                    None => {}
                }

                // execute commands
                for cmd in vc.server.commands.to_vec() {
                    let result = ssh.call(cmd.as_str()).await?;
                    println!("{result}")
                }

                // close the ssh connection
                ssh.close().await?;

                // run port forward
                match &vc.port_forward {
                    Some(pwc) => {
                        pw::port_forward(pwc.local_addr.as_str(), &pwc.remote_addr).await?;
                    }
                    None => {}
                }
            }
            Err(e) => error!("{e:?}"),
        },
        Err(e) => error!("{:?}", e.message()),
    }

    Ok(())
}