ssh_ui 0.4.1

Painlessly expose Rust TUI applications over ssh
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

use std::{
    error::Error,
    sync::{mpsc::Sender, Arc},
};

use cursive::Cursive;
use russh_keys::key::SignatureHash;
use ssh_ui::{
    cursive::views::{Dialog, TextView},
    russh_keys::key::{KeyPair, PublicKey},
    App, AppServer, AppSession, SessionHandle,
};

struct DialogAppSession {}

impl DialogAppSession {
    pub fn new() -> Self {
        Self {}
    }
}

impl AppSession for DialogAppSession {
    fn on_start(
        &mut self,
        _siv: &mut Cursive,
        _session_handle: SessionHandle,
        _pub_key: Option<PublicKey>,
        _force_refresh_sender: Sender<()>,
    ) -> Result<Box<dyn cursive::View>, Box<dyn Error>> {
        println!("on_start");
        Ok(Box::new(
            Dialog::around(TextView::new("Hello over ssh!"))
                .title("ssh_ui")
                .button("Quit", |s| s.quit()),
        ))
    }
}

struct DialogApp {}

impl App for DialogApp {
    fn on_load(&mut self) -> Result<(), Box<dyn Error>> {
        println!("load");
        Ok(())
    }

    fn new_session(&self) -> Box<dyn AppSession> {
        println!("new session");
        Box::new(DialogAppSession::new())
    }
}

#[tokio::main]
async fn main() {
    let key_pairs = [
        KeyPair::generate_rsa(4096, SignatureHash::SHA2_256).unwrap(),
        KeyPair::generate_ed25519().unwrap(),
    ];
    let mut server = AppServer::new_with_port(2222);
    let app = DialogApp {};
    server.run(&key_pairs, Arc::new(app)).await.unwrap();
}