podman_rest_client/v5/apis/
networks_compat.rs

1use crate::api_common::config::HasConfig;
2use crate::api_common::request;
3use crate::api_common::Error;
4use http::request::Builder;
5use std::future::Future;
6use std::pin::Pin;
7pub trait NetworksCompat: HasConfig + Send + Sync {
8    /// GET /networks
9    ///
10    /// List networks
11    ///
12    /// Display summary of network configurations
13    fn network_list<'a>(
14        &'a self,
15        params: Option<crate::v5::params::NetworkList<'a>>,
16    ) -> Pin<
17        Box<
18            dyn Future<Output = Result<Vec<crate::v5::models::NetworkResource>, Error>> + Send + 'a,
19        >,
20    > {
21        Box::pin(request::execute_request_json(
22            self.get_config(),
23            move |mut req_builder: Builder| {
24                req_builder = req_builder.method("GET");
25                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
26                let mut request_path = request_url.path().to_owned();
27                if request_path.ends_with('/') {
28                    request_path.pop();
29                }
30                request_path.push_str("/networks");
31                request_url.set_path(&request_path);
32                if let Some(params) = &params {
33                    let mut query_pairs = request_url.query_pairs_mut();
34                    if let Some(filters) = params.filters {
35                        query_pairs.append_pair("filters", filters);
36                    }
37                }
38                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
39                req_builder = req_builder.uri(hyper_uri);
40                Ok(req_builder.body(String::new())?)
41            },
42        ))
43    }
44    /// DELETE /networks/{name}
45    ///
46    /// Remove a network
47    fn network_delete<'a>(
48        &'a self,
49        name: &'a str,
50    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>> {
51        Box::pin(request::execute_request_unit(
52            self.get_config(),
53            move |mut req_builder: Builder| {
54                req_builder = req_builder.method("DELETE");
55                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
56                let mut request_path = request_url.path().to_owned();
57                if request_path.ends_with('/') {
58                    request_path.pop();
59                }
60                request_path.push_str("/networks/{name}");
61                request_path = request_path.replace("{name}", name);
62                request_url.set_path(&request_path);
63                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
64                req_builder = req_builder.uri(hyper_uri);
65                Ok(req_builder.body(String::new())?)
66            },
67        ))
68    }
69    /// GET /networks/{name}
70    ///
71    /// Inspect a network
72    ///
73    /// Display low level configuration network
74    fn network_inspect<'a>(
75        &'a self,
76        name: &'a str,
77        params: Option<crate::v5::params::NetworkInspect<'a>>,
78    ) -> Pin<Box<dyn Future<Output = Result<crate::v5::models::NetworkResource, Error>> + Send + 'a>>
79    {
80        Box::pin(request::execute_request_json(
81            self.get_config(),
82            move |mut req_builder: Builder| {
83                req_builder = req_builder.method("GET");
84                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
85                let mut request_path = request_url.path().to_owned();
86                if request_path.ends_with('/') {
87                    request_path.pop();
88                }
89                request_path.push_str("/networks/{name}");
90                request_path = request_path.replace("{name}", name);
91                request_url.set_path(&request_path);
92                if let Some(params) = &params {
93                    let mut query_pairs = request_url.query_pairs_mut();
94                    if let Some(verbose) = params.verbose {
95                        query_pairs.append_pair("verbose", &verbose.to_string());
96                    }
97                    if let Some(scope) = params.scope {
98                        query_pairs.append_pair("scope", scope);
99                    }
100                }
101                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
102                req_builder = req_builder.uri(hyper_uri);
103                Ok(req_builder.body(String::new())?)
104            },
105        ))
106    }
107    /// POST /networks/{name}/connect
108    ///
109    /// Connect container to network
110    ///
111    /// Connect a container to a network
112    fn network_connect<'a>(
113        &'a self,
114        name: &'a str,
115        create: crate::v5::models::NetworkConnect,
116    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>> {
117        Box::pin(request::execute_request_unit(
118            self.get_config(),
119            move |mut req_builder: Builder| {
120                req_builder = req_builder.method("POST");
121                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
122                let mut request_path = request_url.path().to_owned();
123                if request_path.ends_with('/') {
124                    request_path.pop();
125                }
126                request_path.push_str("/networks/{name}/connect");
127                request_path = request_path.replace("{name}", name);
128                request_url.set_path(&request_path);
129                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
130                req_builder = req_builder.uri(hyper_uri);
131                let body = serde_json::to_string(&create)?;
132                req_builder = req_builder.header(hyper::header::CONTENT_TYPE, "application/json");
133                req_builder = req_builder.header(hyper::header::CONTENT_LENGTH, body.len());
134                Ok(req_builder.body(body)?)
135            },
136        ))
137    }
138    /// POST /networks/{name}/disconnect
139    ///
140    /// Disconnect container from network
141    ///
142    /// Disconnect a container from a network
143    fn network_disconnect<'a>(
144        &'a self,
145        name: &'a str,
146        create: crate::v5::models::NetworkDisconnect,
147    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>> {
148        Box::pin(request::execute_request_unit(
149            self.get_config(),
150            move |mut req_builder: Builder| {
151                req_builder = req_builder.method("POST");
152                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
153                let mut request_path = request_url.path().to_owned();
154                if request_path.ends_with('/') {
155                    request_path.pop();
156                }
157                request_path.push_str("/networks/{name}/disconnect");
158                request_path = request_path.replace("{name}", name);
159                request_url.set_path(&request_path);
160                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
161                req_builder = req_builder.uri(hyper_uri);
162                let body = serde_json::to_string(&create)?;
163                req_builder = req_builder.header(hyper::header::CONTENT_TYPE, "application/json");
164                req_builder = req_builder.header(hyper::header::CONTENT_LENGTH, body.len());
165                Ok(req_builder.body(body)?)
166            },
167        ))
168    }
169    /// POST /networks/create
170    ///
171    /// Create network
172    ///
173    /// Create a network configuration
174    fn network_create<'a>(
175        &'a self,
176        create: crate::v5::models::NetworkCreateRequest,
177    ) -> Pin<Box<dyn Future<Output = Result<crate::v5::models::NetworkCreate201, Error>> + Send + 'a>>
178    {
179        Box::pin(request::execute_request_json(
180            self.get_config(),
181            move |mut req_builder: Builder| {
182                req_builder = req_builder.method("POST");
183                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
184                let mut request_path = request_url.path().to_owned();
185                if request_path.ends_with('/') {
186                    request_path.pop();
187                }
188                request_path.push_str("/networks/create");
189                request_url.set_path(&request_path);
190                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
191                req_builder = req_builder.uri(hyper_uri);
192                let body = serde_json::to_string(&create)?;
193                req_builder = req_builder.header(hyper::header::CONTENT_TYPE, "application/json");
194                req_builder = req_builder.header(hyper::header::CONTENT_LENGTH, body.len());
195                Ok(req_builder.body(body)?)
196            },
197        ))
198    }
199    /// POST /networks/prune
200    ///
201    /// Delete unused networks
202    ///
203    /// Remove networks that do not have containers
204    fn network_prune<'a>(
205        &'a self,
206        params: Option<crate::v5::params::NetworkPrune<'a>>,
207    ) -> Pin<Box<dyn Future<Output = Result<crate::v5::models::NetworkPrune200, Error>> + Send + 'a>>
208    {
209        Box::pin(request::execute_request_json(
210            self.get_config(),
211            move |mut req_builder: Builder| {
212                req_builder = req_builder.method("POST");
213                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
214                let mut request_path = request_url.path().to_owned();
215                if request_path.ends_with('/') {
216                    request_path.pop();
217                }
218                request_path.push_str("/networks/prune");
219                request_url.set_path(&request_path);
220                if let Some(params) = &params {
221                    let mut query_pairs = request_url.query_pairs_mut();
222                    if let Some(filters) = params.filters {
223                        query_pairs.append_pair("filters", filters);
224                    }
225                }
226                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
227                req_builder = req_builder.uri(hyper_uri);
228                Ok(req_builder.body(String::new())?)
229            },
230        ))
231    }
232}
podman_rest_client/v5/apis/networks_compat.rs

podman_rest_client/v5/apis/
networks_compat.rs
