podman_rest_client/v4/apis/
manifests.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 Manifests: HasConfig + Send + Sync {
8    /// POST /libpod/manifests
9    ///
10    /// Create
11    ///
12    /// Create a manifest list
13    fn manifest_create_libpod<'a>(
14        &'a self,
15        params: Option<crate::v4::params::ManifestCreateLibpod<'a>>,
16        options: (),
17    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>> {
18        Box::pin(request::execute_request_unit(
19            self.get_config(),
20            move |mut req_builder: Builder| {
21                req_builder = req_builder.method("POST");
22                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
23                let mut request_path = request_url.path().to_owned();
24                if request_path.ends_with('/') {
25                    request_path.pop();
26                }
27                request_path.push_str("/libpod/manifests");
28                request_url.set_path(&request_path);
29                if let Some(params) = &params {
30                    let mut query_pairs = request_url.query_pairs_mut();
31                    query_pairs.append_pair("name", params.name);
32                    query_pairs.append_pair("images", params.images);
33                    if let Some(all) = params.all {
34                        query_pairs.append_pair("all", &all.to_string());
35                    }
36                    if let Some(amend) = params.amend {
37                        query_pairs.append_pair("amend", &amend.to_string());
38                    }
39                }
40                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
41                req_builder = req_builder.uri(hyper_uri);
42                let body = serde_json::to_string(&options)?;
43                req_builder = req_builder.header(hyper::header::CONTENT_TYPE, "application/json");
44                req_builder = req_builder.header(hyper::header::CONTENT_LENGTH, body.len());
45                Ok(req_builder.body(body)?)
46            },
47        ))
48    }
49    /// DELETE /libpod/manifests/{name}
50    ///
51    /// Delete manifest list
52    ///
53    /// Delete named manifest list
54    ///
55    /// As of v4.0.0
56    fn manifest_delete_libpod<'a>(
57        &'a self,
58        name: &'a str,
59    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>> {
60        Box::pin(request::execute_request_unit(
61            self.get_config(),
62            move |mut req_builder: Builder| {
63                req_builder = req_builder.method("DELETE");
64                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
65                let mut request_path = request_url.path().to_owned();
66                if request_path.ends_with('/') {
67                    request_path.pop();
68                }
69                request_path.push_str("/libpod/manifests/{name}");
70                request_path = request_path.replace("{name}", name);
71                request_url.set_path(&request_path);
72                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
73                req_builder = req_builder.uri(hyper_uri);
74                Ok(req_builder.body(String::new())?)
75            },
76        ))
77    }
78    /// GET /libpod/manifests/{name}
79    ///
80    /// Modify manifest list
81    ///
82    /// Add/Remove an image(s) to a manifest list
83    ///
84    /// Note: operations are not atomic when multiple Images are provided.
85    ///
86    /// As of v4.0.0
87    fn manifest_modify_libpod<'a>(
88        &'a self,
89        name: &'a str,
90        params: Option<crate::v4::params::ManifestModifyLibpod>,
91        options: (),
92    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>> {
93        Box::pin(request::execute_request_unit(
94            self.get_config(),
95            move |mut req_builder: Builder| {
96                req_builder = req_builder.method("GET");
97                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
98                let mut request_path = request_url.path().to_owned();
99                if request_path.ends_with('/') {
100                    request_path.pop();
101                }
102                request_path.push_str("/libpod/manifests/{name}");
103                request_path = request_path.replace("{name}", name);
104                request_url.set_path(&request_path);
105                if let Some(params) = &params {
106                    let mut query_pairs = request_url.query_pairs_mut();
107                    if let Some(tls_verify) = params.tls_verify {
108                        query_pairs.append_pair("tlsVerify", &tls_verify.to_string());
109                    }
110                }
111                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
112                req_builder = req_builder.uri(hyper_uri);
113                let body = serde_json::to_string(&options)?;
114                req_builder = req_builder.header(hyper::header::CONTENT_TYPE, "application/json");
115                req_builder = req_builder.header(hyper::header::CONTENT_LENGTH, body.len());
116                Ok(req_builder.body(body)?)
117            },
118        ))
119    }
120    /// POST /libpod/manifests/{name}/add
121    ///
122    /// Add image
123    ///
124    /// Add an image to a manifest list
125    ///
126    /// Deprecated: As of 4.0.0 use ManifestModifyLibpod instead
127    fn manifest_add_libpod<'a>(
128        &'a self,
129        name: &'a str,
130        options: (),
131    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>> {
132        Box::pin(request::execute_request_unit(
133            self.get_config(),
134            move |mut req_builder: Builder| {
135                req_builder = req_builder.method("POST");
136                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
137                let mut request_path = request_url.path().to_owned();
138                if request_path.ends_with('/') {
139                    request_path.pop();
140                }
141                request_path.push_str("/libpod/manifests/{name}/add");
142                request_path = request_path.replace("{name}", name);
143                request_url.set_path(&request_path);
144                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
145                req_builder = req_builder.uri(hyper_uri);
146                let body = serde_json::to_string(&options)?;
147                req_builder = req_builder.header(hyper::header::CONTENT_TYPE, "application/json");
148                req_builder = req_builder.header(hyper::header::CONTENT_LENGTH, body.len());
149                Ok(req_builder.body(body)?)
150            },
151        ))
152    }
153    /// GET /libpod/manifests/{name}/exists
154    ///
155    /// Exists
156    ///
157    /// Check if manifest list exists
158    ///
159    /// Note: There is no contract that the manifest list will exist for a follow-on operation
160    fn manifest_exists_libpod<'a>(
161        &'a self,
162        name: &'a str,
163    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>> {
164        Box::pin(request::execute_request_unit(
165            self.get_config(),
166            move |mut req_builder: Builder| {
167                req_builder = req_builder.method("GET");
168                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
169                let mut request_path = request_url.path().to_owned();
170                if request_path.ends_with('/') {
171                    request_path.pop();
172                }
173                request_path.push_str("/libpod/manifests/{name}/exists");
174                request_path = request_path.replace("{name}", name);
175                request_url.set_path(&request_path);
176                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
177                req_builder = req_builder.uri(hyper_uri);
178                Ok(req_builder.body(String::new())?)
179            },
180        ))
181    }
182    /// GET /libpod/manifests/{name}/json
183    ///
184    /// Inspect
185    ///
186    /// Display attributes of given manifest list
187    fn manifest_inspect_libpod<'a>(
188        &'a self,
189        name: &'a str,
190        params: Option<crate::v4::params::ManifestInspectLibpod>,
191    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>> {
192        Box::pin(request::execute_request_unit(
193            self.get_config(),
194            move |mut req_builder: Builder| {
195                req_builder = req_builder.method("GET");
196                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
197                let mut request_path = request_url.path().to_owned();
198                if request_path.ends_with('/') {
199                    request_path.pop();
200                }
201                request_path.push_str("/libpod/manifests/{name}/json");
202                request_path = request_path.replace("{name}", name);
203                request_url.set_path(&request_path);
204                if let Some(params) = &params {
205                    let mut query_pairs = request_url.query_pairs_mut();
206                    if let Some(tls_verify) = params.tls_verify {
207                        query_pairs.append_pair("tlsVerify", &tls_verify.to_string());
208                    }
209                }
210                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
211                req_builder = req_builder.uri(hyper_uri);
212                Ok(req_builder.body(String::new())?)
213            },
214        ))
215    }
216    /// POST /libpod/manifests/{name}/push
217    ///
218    /// Push manifest to registry
219    ///
220    /// Push a manifest list or image index to a registry
221    ///
222    /// Deprecated: As of 4.0.0 use ManifestPushLibpod instead
223    fn manifest_push_v_3_libpod<'a>(
224        &'a self,
225        name: &'a str,
226        params: Option<crate::v4::params::ManifestPushV3Libpod<'a>>,
227    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>> {
228        Box::pin(request::execute_request_unit(
229            self.get_config(),
230            move |mut req_builder: Builder| {
231                req_builder = req_builder.method("POST");
232                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
233                let mut request_path = request_url.path().to_owned();
234                if request_path.ends_with('/') {
235                    request_path.pop();
236                }
237                request_path.push_str("/libpod/manifests/{name}/push");
238                request_path = request_path.replace("{name}", name);
239                request_url.set_path(&request_path);
240                if let Some(params) = &params {
241                    let mut query_pairs = request_url.query_pairs_mut();
242                    query_pairs.append_pair("destination", params.destination);
243                    if let Some(all) = params.all {
244                        query_pairs.append_pair("all", &all.to_string());
245                    }
246                }
247                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
248                req_builder = req_builder.uri(hyper_uri);
249                Ok(req_builder.body(String::new())?)
250            },
251        ))
252    }
253    /// POST /libpod/manifests/{name}/registry/{destination}
254    ///
255    /// Push manifest list to registry
256    ///
257    /// Push a manifest list or image index to the named registry
258    ///
259    /// As of v4.0.0
260    fn manifest_push_libpod<'a>(
261        &'a self,
262        name: &'a str,
263        destination: &'a str,
264        params: Option<crate::v4::params::ManifestPushLibpod<'a>>,
265    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>> {
266        Box::pin(request::execute_request_unit(
267            self.get_config(),
268            move |mut req_builder: Builder| {
269                req_builder = req_builder.method("POST");
270                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
271                let mut request_path = request_url.path().to_owned();
272                if request_path.ends_with('/') {
273                    request_path.pop();
274                }
275                request_path.push_str("/libpod/manifests/{name}/registry/{destination}");
276                request_path = request_path.replace("{name}", name);
277                request_path = request_path.replace("{destination}", destination);
278                request_url.set_path(&request_path);
279                if let Some(params) = &params {
280                    let mut query_pairs = request_url.query_pairs_mut();
281                    if let Some(add_compression) = &params.add_compression {
282                        for value in add_compression {
283                            query_pairs.append_pair("addCompression", &value.to_string());
284                        }
285                    }
286                    if let Some(force_compression_format) = params.force_compression_format {
287                        query_pairs.append_pair(
288                            "forceCompressionFormat",
289                            &force_compression_format.to_string(),
290                        );
291                    }
292                    if let Some(all) = params.all {
293                        query_pairs.append_pair("all", &all.to_string());
294                    }
295                    if let Some(tls_verify) = params.tls_verify {
296                        query_pairs.append_pair("tlsVerify", &tls_verify.to_string());
297                    }
298                    if let Some(quiet) = params.quiet {
299                        query_pairs.append_pair("quiet", &quiet.to_string());
300                    }
301                }
302                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
303                req_builder = req_builder.uri(hyper_uri);
304                Ok(req_builder.body(String::new())?)
305            },
306        ))
307    }
308}
podman_rest_client/v4/apis/manifests.rs

podman_rest_client/v4/apis/
manifests.rs
