rust-mediamtx-http-api 0.0.8

rust-mediamtx-http-api with optional rust native tls feature
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

use reqwest::header::HeaderMap;
use url::Url;
pub mod structs;
#[cfg(test)]
mod tests;

#[derive(Clone, Debug)]
pub struct MediamtxHttpClient {
    client: simplerusthttpsclient::HttpClient,
}

impl MediamtxHttpClient {
    #[cfg(feature = "tls")]

    pub fn new(
        base_url: Url,
        tls_config: Option<simplerusthttpsclient::TlsConfig>,
        default_headers: Option<HeaderMap>,
    ) -> Self {
        Self {
            client: simplerusthttpsclient::HttpClient::new(base_url, tls_config, default_headers),
        }
    }
    #[cfg(not(feature = "tls"))]

    pub fn new(base_url: Url, default_headers: Option<HeaderMap>) -> Self {
        Self {
            client: simplerusthttpsclient::HttpClient::new(base_url, default_headers),
        }
    }
    pub async fn get_global_config(&self) -> anyhow::Result<structs::TMediaMTXGlobalConfig> {
        let url = "/v3/config/global/get";
        let obj: structs::TMediaMTXGlobalConfig = self.client.get(url, None).await?;
        Ok(obj)
    }
    pub async fn patch_global_config(
        &self,
        data: structs::TMediaMTXGlobalConfig,
    ) -> anyhow::Result<()> {
        let url = "/v3/config/global/patch";
        self.client.patch(url, &data, None).await?;
        Ok(())
    }
    pub async fn get_default_path(&self) -> anyhow::Result<structs::TMediaMTXGetDefaultPath> {
        let url = "/v3/config/pathdefaults/get";
        let obj: structs::TMediaMTXGetDefaultPath = self.client.get(url, None).await?;
        Ok(obj)
    }
    pub async fn patch_default_path(
        &self,
        data: structs::TMediaMTXPatchDefaultPath,
    ) -> anyhow::Result<()> {
        let url = "/v3/config/pathdefaults/patch";
        self.client.patch(url, &data, None).await?;
        Ok(())
    }
    pub async fn get_paths_configs(&self) -> anyhow::Result<structs::MediaMTXPathsConfigs> {
        let url = "/v3/config/paths/list";
        let obj: structs::MediaMTXPathsConfigs = self.client.get(url, None).await?;
        Ok(obj)
    }
    pub async fn get_path_config(
        &self,
        path_name: &str,
    ) -> anyhow::Result<structs::TMediaMTXGetDefaultPath> {
        let url = String::from("/v3/config/paths/get/") + path_name;
        let obj: structs::TMediaMTXGetDefaultPath = self.client.get(&url, None).await?;
        Ok(obj)
    }
    pub async fn add_path(&self, path_config: structs::TMediaMTXAddPath) -> anyhow::Result<()> {
        let url = String::from("/v3/config/paths/add/") + path_config.name.as_str();
        self.client.post(&url, &path_config, None).await?;
        Ok(())
    }
    pub async fn patch_path(&self, path_config: structs::TMediaMTXAddPath) -> anyhow::Result<()> {
        let url = String::from("/v3/config/paths/patch/") + path_config.name.as_str();
        self.client.patch(&url, &path_config, None).await?;
        Ok(())
    }
    pub async fn replace_path(&self, path_config: structs::TMediaMTXAddPath) -> anyhow::Result<()> {
        let url = String::from("/v3/config/paths/replace/") + path_config.name.as_str();
        self.client.post(&url, &path_config, None).await?;
        Ok(())
    }
    pub async fn delete_path(&self, path_name: &str) -> anyhow::Result<()> {
        let url = String::from("/v3/config/paths/delete/") + path_name;
        self.client.delete(&url, None).await?;
        Ok(())
    }
    pub async fn get_paths_status(&self) -> anyhow::Result<structs::MediaMTXPathsStatusList> {
        let url = "/v3/paths/list";
        let obj: structs::MediaMTXPathsStatusList = self.client.get(url, None).await?;
        Ok(obj)
    }
    pub async fn get_path_status(
        &self,
        path_name: &str,
    ) -> anyhow::Result<structs::MediaMTXPathStatus> {
        let url = String::from("/v3/paths/get/") + path_name;
        let obj: structs::MediaMTXPathStatus = self.client.get(&url, None).await?;
        Ok(obj)
    }

    pub async fn sync_paths(
        &self,
        paths: Vec<structs::TMediaMTXAddPath>,
        remove_unused: bool,
    ) -> anyhow::Result<()> {
        let current_paths = self.get_paths_configs().await?;
        for path in paths.clone() {
            let get_path = self.get_path_config(&path.name).await;
            if let Err(e) = get_path {
                println!("Adding path: {}", path.name);
                self.add_path(path).await?;
            }
        }
        if remove_unused {
            for path in current_paths.items {
                if paths.iter().any(|p| p.name == path.name) {
                    continue;
                }
                println!("Deleting path: {}", path.name);
                self.delete_path(&path.name).await?;
            }
        }

        Ok(())
    }
}