sshy 0.1.2

TUI application to make SSH configuration easier
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

pub mod ssh_keygen;

use portable_pty::ChildKiller;
use std::sync::mpsc;

use color_eyre::eyre::{eyre, Result};

use crate::events::messages::Message;
use crate::utils::constants;

use std::collections::HashMap;

pub type TaskMessageRx = mpsc::Receiver<Message>;
pub type TaskMessageTx = mpsc::Sender<Message>;

/// List of available command tasks
#[derive(Clone, Copy, Eq, Hash, PartialEq, serde::Serialize, Debug)]
pub enum CmdTask {
    SshKeygen,
}

pub type PtyReader = Box<dyn std::io::Read + Send>;
pub type PtyWriter = Box<dyn std::io::Write + Send>;

/// A CmdWriterEnd has a writer to write content to the child command and a child killer to kill the
/// child command
///
/// This struct should be handled by the main thread, which forwards the input from the user to the
/// child command
pub struct CmdWriterEnd {
    writer: PtyWriter,
    child_killer: Box<dyn ChildKiller + Send + Sync>,
}

impl CmdWriterEnd {
    pub fn kill_child(&mut self) -> Result<()> {
        self.child_killer
            .kill()
            .map_err(|e| eyre!("failed to kill child command: {}", e))
    }

    pub fn write(&mut self, content: &[u8]) -> Result<()> {
        let content_with_newline: Vec<u8> = content
            .iter()
            .copied()
            .chain(constants::LINE_TERMINATOR.to_owned())
            .collect();

        self.writer
            .write_all(&content_with_newline)
            .map_err(|e| eyre!("failed to write to command: {}", e))?;
        self.writer
            .flush()
            .map_err(|e| eyre!("failed to send data to command: {}", e))
    }
}

/// A CmdReaderEnd has a reader to read content from the child command and a message sender to send
/// Messages to the main thread
///
/// This struct should be handled by the child command' thread, which, based on the read content,
/// will generate the appropiate messages for the main thread to handle
pub struct CmdReaderEnd {
    reader: PtyReader,
    msg_sender: TaskMessageTx,
}

pub type CmdWriterEnds = HashMap<CmdTask, CmdWriterEnd>;