atsh-lib 0.1.5

autossh/@shell library is used to ssh login and allow automatically login without password
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

use serde::{Deserialize, Serialize};
use std::env::home_dir;
use std::io::{Error, ErrorKind};
use std::path::{Path, PathBuf};
use std::sync::LazyLock;
use tracing::{debug, warn};

use crate::WORK_DIR_FILE;

const DEFAULT: &str = include_str!("default.toml");
pub static CONFIG: LazyLock<Config> = LazyLock::new(|| Config::new());

#[derive(Debug, Default, Serialize, Deserialize)]
struct SSHKey {
    /// the public key location.
    public: PathBuf,
    /// the private key location.
    private: PathBuf,
}

#[derive(Debug, Default, Serialize, Deserialize)]
pub struct Config {
    sshkey: Option<SSHKey>,
}

impl Config {
    pub fn new() -> Self {
        let config = WORK_DIR_FILE("config.toml");
        // if config file not exists, create it
        if !config.is_file() {
            let mut default: Config =
                toml::from_str(DEFAULT).expect("Failed to parse default config");
            if default.sshkey.is_none() {
                let home = home_dir().expect("Failed to get home directory");
                let (public, private) = (
                    home.join(".ssh").join("id_rsa.pub"),
                    home.join(".ssh").join("id_rsa"),
                );
                let msg = format!(
                    r#"
  🔹 No SSH key specified. Defaulting to: {:?}
  🔹 SSH key used for remote host authentication.
  🔹 To generate a new key (passphrase-free):
        ssh-keygen -t rsa -b 2048 -C "atsh" -N "" -f {:?}"#,
                    private,
                    WORK_DIR_FILE("atsh_key")
                );
                warn!("💡 The first run to create a default config{}", msg);
                default.sshkey = Some(SSHKey { public, private });
            }
            std::fs::write(
                &config,
                toml::to_string(&default).expect("Failed to serialize config"),
            )
            .expect("Failed to write config.toml");
        }

        Self::load_from_file(config.as_path())
    }

    pub fn load_from_file(f: &Path) -> Self {
        debug!(file = ?f, "Loading config");
        let content = std::fs::read_to_string(f).expect("Failed to read config.toml");
        let config: Config = toml::from_str(&content).expect("Failed to parse config.toml");
        config
    }

    pub fn get_public_key(&self) -> &Path {
        self.sshkey.as_ref().unwrap().public.as_path()
    }

    pub fn get_private_key(&self) -> &Path {
        self.sshkey.as_ref().unwrap().private.as_path()
    }

    pub fn read_public_key(&self) -> Result<String, Error> {
        let key = self.get_public_key();
        if !key.is_file() {
            return Err(Error::new(
                ErrorKind::NotFound,
                "public key not found, you can generate it by `ssh-keygen` and set it to config",
            ));
        }
        std::fs::read_to_string(key)
    }
}

#[cfg(test)]
mod tests {

    use super::*;

    #[test]
    fn test_config() {
        let config = &CONFIG;
        println!("config: {:#?}", config.sshkey);
        assert!(config.sshkey.is_some());
    }
}