astu 0.0.0

Astu library
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

pub mod client;
pub mod transport;

use std::fmt;

use anyhow::Result;
use async_trait::async_trait;
use bstr::ByteSlice;
use enum_dispatch::enum_dispatch;

use crate::resolve::Target;

/// Actions that a client can perform.
#[async_trait]
#[enum_dispatch]
pub trait Client {
    /// Connect to a target.
    async fn connect(&mut self) -> Result<()>;

    /// Ping a target.
    async fn ping(&mut self) -> Result<Vec<u8>>;

    /// Authenticate with a target.
    async fn auth(&mut self, auth_type: &AuthType) -> Result<()>;

    /// Execute commands on a target.
    async fn exec(&mut self, command: &str) -> Result<ExecOutput>;
}

/// All types of action clients.
#[enum_dispatch(Client)]
pub enum ClientImpl {
    Tcp(client::TcpClient),
    Ssh(client::SshClient),
}

/// Factory for building clients.
#[enum_dispatch]
pub trait ClientFactory {
    fn client(&self, target: &Target) -> Option<ClientImpl>;
}

/// All types of action client factories.
#[enum_dispatch(ClientFactory)]
#[derive(Debug, Clone)]
pub enum ClientFactoryImpl {
    Tcp(client::TcpClientFactory),
    Ssh(client::SshClientFactory),
}

/// Assortment of auth payloads that can be used with auth.
#[derive(Debug, Clone)]
pub enum AuthType {
    User(String),
    Password(String),
    SshKey(String),
    SshCert { key: String, cert: String },
    SshAgent { socket: String },
}

/// Output of a command run by exec.
#[derive(Clone)]
pub struct ExecOutput {
    pub exit_status: u32,
    pub stdout: Vec<u8>,
    pub stderr: Vec<u8>,
}

impl fmt::Debug for ExecOutput {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("ExecOutput")
            .field("exit_status", &self.exit_status)
            .field("stdout", &self.stdout.as_bstr())
            .field("stderr", &self.stderr.as_bstr())
            .finish()
    }
}