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

podman_rest_client/v4/apis/
networks_compat.rs
