lade-sdk 0.16.0

Lade SDK
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
100

use anyhow::{Result, bail};
use std::collections::HashMap;

use super::{NetworkProvider, ProviderSpec, reject_unknown_query};

pub struct SshProvider;

impl NetworkProvider for SshProvider {
    fn scheme(&self) -> &'static str {
        "ssh"
    }

    fn parse(
        &self,
        authority: &str,
        segments: &[&str],
        query: &HashMap<String, String>,
    ) -> Result<ProviderSpec> {
        if segments.len() != 2 {
            bail!("ssh URI must be /<remote-host>/<remote-port>");
        }
        reject_unknown_query(query, &["local"])?;

        let (jump_host, jump_port) = match authority.rsplit_once(':') {
            Some((host, port)) => (host.to_string(), port.parse::<u16>()?),
            None => (authority.to_string(), 22),
        };

        Ok(ProviderSpec::Ssh {
            jump_host,
            jump_port,
            remote_host: segments[0].to_string(),
            remote_port: segments[1].parse::<u16>()?,
        })
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::collections::HashMap;

    #[test]
    fn test_parse_ssh_uri() {
        let provider = SshProvider;
        let query = HashMap::new();

        // Basic
        let spec = provider
            .parse("jump.host", &["remote.host", "5432"], &query)
            .unwrap();
        if let ProviderSpec::Ssh {
            jump_host,
            jump_port,
            remote_host,
            remote_port,
        } = spec
        {
            assert_eq!(jump_host, "jump.host");
            assert_eq!(jump_port, 22);
            assert_eq!(remote_host, "remote.host");
            assert_eq!(remote_port, 5432);
        } else {
            panic!("Wrong spec type");
        }

        // With jump port
        let spec = provider
            .parse("jump.host:2222", &["remote.host", "5432"], &query)
            .unwrap();
        if let ProviderSpec::Ssh { jump_port, .. } = spec {
            assert_eq!(jump_port, 2222);
        }

        // Rejections
        assert!(
            provider
                .parse("jump.host", &["remote.host"], &query)
                .is_err()
        );
        assert!(
            provider
                .parse("jump.host", &["remote.host", "5432", "extra"], &query)
                .is_err()
        );
        assert!(
            provider
                .parse("jump.host", &["remote.host", "not-a-port"], &query)
                .is_err()
        );

        let mut bad_query = HashMap::new();
        bad_query.insert("unknown".to_string(), "val".to_string());
        assert!(
            provider
                .parse("jump.host", &["remote.host", "5432"], &bad_query)
                .is_err()
        );
    }
}