mikrotik 0.0.15

REST API Wrapper for Mikrotik API
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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

pub use crate::ip::types::{DhcpServer, Lease, Network};
use crate::{Client, ClientError};

/// list all dhcp servers
pub async fn list(client: &mut Client) -> Result<Vec<DhcpServer>, ClientError> {
    let url = format!("{}/dhcp-server", super::BASE);

    client.execute_get::<Vec<DhcpServer>>(&url).await
}

/// get details of a specific dhcp server. takes dhcp server name as input
pub async fn get(client: &mut Client, dhcp_server_id: &str) -> Result<DhcpServer, ClientError> {
    let url = format!("{}/dhcp-server/{}", super::BASE, dhcp_server_id);

    client.execute_get::<DhcpServer>(&url).await
}

/// list all networks
pub async fn list_network(client: &mut Client) -> Result<Vec<Network>, ClientError> {
    let url = format!("{}/dhcp-server/network", super::BASE);

    client.execute_get::<Vec<Network>>(&url).await
}

/// get details of a specific network
pub async fn get_network(client: &mut Client, nid: &str) -> Result<Network, ClientError> {
    let url = format!("{}/dhcp-server/network/{}", super::BASE, nid);

    client.execute_get::<Network>(&url).await
}

/// list all dhcp leases from all dhcp servers
pub async fn list_leases(client: &mut Client) -> Result<Vec<Lease>, ClientError> {
    let url = format!("{}/dhcp-server/lease", super::BASE);

    client.execute_get::<Vec<Lease>>(&url).await
}

/// get details of a specific lease
pub async fn get_lease(client: &mut Client, lease_id: &str) -> Result<Lease, ClientError> {
    let url = format!("{}/dhcp-server/lease/{}", super::BASE, lease_id);

    client.execute_get::<Lease>(&url).await
}

#[cfg(test)]
mod test {
    use super::*;
    use reqwest::Url;

    #[tokio::test]
    async fn list_dhcp_servers() -> Result<(), ClientError> {
        let base = Url::parse("https://10.0.10.1")?;
        let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true)
            .expect("error in creating client");

        let response = crate::ip::dhcp_server::list(&mut client).await?;

        println!("{:?}", response);

        Ok(())
    }

    #[tokio::test]
    async fn get_dhcp_server() -> Result<(), ClientError> {
        let base = Url::parse("https://10.0.10.1")?;
        let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true)
            .expect("error in creating client");
        let response = crate::ip::dhcp_server::get(&mut client, "vlan-150").await?;

        println!("{:?}", response);

        Ok(())
    }

    #[tokio::test]
    async fn list_network() -> Result<(), ClientError> {
        let base = Url::parse("https://10.0.10.1")?;
        let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true)
            .expect("error in creating client");

        let response = crate::ip::dhcp_server::list_network(&mut client).await?;

        println!("{:?}", response);

        Ok(())
    }

    #[tokio::test]
    async fn get_network() -> Result<(), ClientError> {
        let base = Url::parse("https://10.0.10.1")?;
        let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true)
            .expect("error in creating client");

        let response = crate::ip::dhcp_server::list_network(&mut client).await?;

        let response = crate::ip::dhcp_server::get_network(&mut client, &response[0].id).await?;

        println!("{:?}", response);

        Ok(())
    }

    #[tokio::test]
    async fn list_leases() -> Result<(), ClientError> {
        let base = Url::parse("https://10.0.10.1")?;
        let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true)
            .expect("error in creating client");

        let response = crate::ip::dhcp_server::list_leases(&mut client).await?;

        println!("{:?}", response);

        Ok(())
    }

    #[tokio::test]
    async fn get_lease() -> Result<(), ClientError> {
        let base = Url::parse("https://10.0.10.1")?;
        let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true)
            .expect("error in creating client");

        let response = crate::ip::dhcp_server::list_leases(&mut client).await?;

        let response = crate::ip::dhcp_server::get_lease(&mut client, &response[0].id).await?;

        println!("{:?}", response);

        Ok(())
    }
}