podman_rest_client/v5/apis/
images_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 ImagesCompat: HasConfig + Send + Sync {
8    /// POST /build
9    ///
10    /// Create image
11    ///
12    /// Build an image from the given Dockerfile(s)
13    fn image_build<'a>(
14        &'a self,
15        params: Option<crate::v5::params::ImageBuild<'a>>,
16        input_stream: String,
17    ) -> Pin<Box<dyn Future<Output = Result<crate::v5::models::ImageBuild200, Error>> + Send + 'a>>
18    {
19        Box::pin(request::execute_request_json(
20            self.get_config(),
21            move |mut req_builder: Builder| {
22                req_builder = req_builder.method("POST");
23                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
24                let mut request_path = request_url.path().to_owned();
25                if request_path.ends_with('/') {
26                    request_path.pop();
27                }
28                request_path.push_str("/build");
29                request_url.set_path(&request_path);
30                if let Some(params) = &params {
31                    let mut query_pairs = request_url.query_pairs_mut();
32                    if let Some(dockerfile) = params.dockerfile {
33                        query_pairs.append_pair("dockerfile", dockerfile);
34                    }
35                    if let Some(t) = params.t {
36                        query_pairs.append_pair("t", t);
37                    }
38                    if let Some(extrahosts) = params.extrahosts {
39                        query_pairs.append_pair("extrahosts", extrahosts);
40                    }
41                    if let Some(remote) = params.remote {
42                        query_pairs.append_pair("remote", remote);
43                    }
44                    if let Some(q) = params.q {
45                        query_pairs.append_pair("q", &q.to_string());
46                    }
47                    if let Some(nocache) = params.nocache {
48                        query_pairs.append_pair("nocache", &nocache.to_string());
49                    }
50                    if let Some(cachefrom) = params.cachefrom {
51                        query_pairs.append_pair("cachefrom", cachefrom);
52                    }
53                    if let Some(pull) = params.pull {
54                        query_pairs.append_pair("pull", &pull.to_string());
55                    }
56                    if let Some(rm) = params.rm {
57                        query_pairs.append_pair("rm", &rm.to_string());
58                    }
59                    if let Some(forcerm) = params.forcerm {
60                        query_pairs.append_pair("forcerm", &forcerm.to_string());
61                    }
62                    if let Some(memory) = params.memory {
63                        query_pairs.append_pair("memory", &memory.to_string());
64                    }
65                    if let Some(memswap) = params.memswap {
66                        query_pairs.append_pair("memswap", &memswap.to_string());
67                    }
68                    if let Some(cpushares) = params.cpushares {
69                        query_pairs.append_pair("cpushares", &cpushares.to_string());
70                    }
71                    if let Some(cpusetcpus) = params.cpusetcpus {
72                        query_pairs.append_pair("cpusetcpus", cpusetcpus);
73                    }
74                    if let Some(cpuperiod) = params.cpuperiod {
75                        query_pairs.append_pair("cpuperiod", &cpuperiod.to_string());
76                    }
77                    if let Some(cpuquota) = params.cpuquota {
78                        query_pairs.append_pair("cpuquota", &cpuquota.to_string());
79                    }
80                    if let Some(buildargs) = params.buildargs {
81                        query_pairs.append_pair("buildargs", buildargs);
82                    }
83                    if let Some(shmsize) = params.shmsize {
84                        query_pairs.append_pair("shmsize", &shmsize.to_string());
85                    }
86                    if let Some(squash) = params.squash {
87                        query_pairs.append_pair("squash", &squash.to_string());
88                    }
89                    if let Some(labels) = params.labels {
90                        query_pairs.append_pair("labels", labels);
91                    }
92                    if let Some(networkmode) = params.networkmode {
93                        query_pairs.append_pair("networkmode", networkmode);
94                    }
95                    if let Some(platform) = params.platform {
96                        query_pairs.append_pair("platform", platform);
97                    }
98                    if let Some(target) = params.target {
99                        query_pairs.append_pair("target", target);
100                    }
101                    if let Some(outputs) = params.outputs {
102                        query_pairs.append_pair("outputs", outputs);
103                    }
104                    if let Some(content_type) = params.content_type {
105                        req_builder = req_builder.header("Content-Type", content_type);
106                    }
107                    if let Some(x_registry_config) = params.x_registry_config {
108                        req_builder = req_builder.header("X-Registry-Config", x_registry_config);
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(&input_stream)?;
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    /// DELETE /images/{name}
121    ///
122    /// Remove Image
123    ///
124    /// Delete an image from local storage
125    fn image_delete<'a>(
126        &'a self,
127        name: &'a str,
128        params: Option<crate::v5::params::ImageDelete>,
129    ) -> Pin<
130        Box<
131            dyn Future<Output = Result<Vec<crate::v5::models::ImageDeleteResponseItems>, Error>>
132                + Send
133                + 'a,
134        >,
135    > {
136        Box::pin(request::execute_request_json(
137            self.get_config(),
138            move |mut req_builder: Builder| {
139                req_builder = req_builder.method("DELETE");
140                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
141                let mut request_path = request_url.path().to_owned();
142                if request_path.ends_with('/') {
143                    request_path.pop();
144                }
145                request_path.push_str("/images/{name}");
146                request_path = request_path.replace("{name}", name);
147                request_url.set_path(&request_path);
148                if let Some(params) = &params {
149                    let mut query_pairs = request_url.query_pairs_mut();
150                    if let Some(force) = params.force {
151                        query_pairs.append_pair("force", &force.to_string());
152                    }
153                    if let Some(noprune) = params.noprune {
154                        query_pairs.append_pair("noprune", &noprune.to_string());
155                    }
156                }
157                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
158                req_builder = req_builder.uri(hyper_uri);
159                Ok(req_builder.body(String::new())?)
160            },
161        ))
162    }
163    /// GET /images/{name}/get
164    ///
165    /// Export an image
166    ///
167    /// Export an image in tarball format
168    fn image_get<'a>(
169        &'a self,
170        name: &'a str,
171    ) -> Pin<Box<dyn futures::stream::Stream<Item = Result<bytes::Bytes, Error>> + Send + 'a>> {
172        request::execute_request_stream(self.get_config(), move |mut req_builder: Builder| {
173            req_builder = req_builder.method("GET");
174            let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
175            let mut request_path = request_url.path().to_owned();
176            if request_path.ends_with('/') {
177                request_path.pop();
178            }
179            request_path.push_str("/images/{name}/get");
180            request_path = request_path.replace("{name}", name);
181            request_url.set_path(&request_path);
182            let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
183            req_builder = req_builder.uri(hyper_uri);
184            Ok(req_builder.body(String::new())?)
185        })
186    }
187    /// GET /images/{name}/history
188    ///
189    /// History of an image
190    ///
191    /// Return parent layers of an image.
192    fn image_history<'a>(
193        &'a self,
194        name: &'a str,
195    ) -> Pin<Box<dyn Future<Output = Result<crate::v5::models::HistoryResponse, Error>> + Send + 'a>>
196    {
197        Box::pin(request::execute_request_json(
198            self.get_config(),
199            move |mut req_builder: Builder| {
200                req_builder = req_builder.method("GET");
201                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
202                let mut request_path = request_url.path().to_owned();
203                if request_path.ends_with('/') {
204                    request_path.pop();
205                }
206                request_path.push_str("/images/{name}/history");
207                request_path = request_path.replace("{name}", name);
208                request_url.set_path(&request_path);
209                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
210                req_builder = req_builder.uri(hyper_uri);
211                Ok(req_builder.body(String::new())?)
212            },
213        ))
214    }
215    /// GET /images/{name}/json
216    ///
217    /// Inspect an image
218    ///
219    /// Return low-level information about an image.
220    fn image_inspect<'a>(
221        &'a self,
222        name: &'a str,
223    ) -> Pin<Box<dyn Future<Output = Result<crate::v5::models::ImageInspect, Error>> + Send + 'a>>
224    {
225        Box::pin(request::execute_request_json(
226            self.get_config(),
227            move |mut req_builder: Builder| {
228                req_builder = req_builder.method("GET");
229                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
230                let mut request_path = request_url.path().to_owned();
231                if request_path.ends_with('/') {
232                    request_path.pop();
233                }
234                request_path.push_str("/images/{name}/json");
235                request_path = request_path.replace("{name}", name);
236                request_url.set_path(&request_path);
237                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
238                req_builder = req_builder.uri(hyper_uri);
239                Ok(req_builder.body(String::new())?)
240            },
241        ))
242    }
243    /// POST /images/{name}/push
244    ///
245    /// Push Image
246    ///
247    /// Push an image to a container registry
248    fn image_push<'a>(
249        &'a self,
250        name: &'a str,
251        params: Option<crate::v5::params::ImagePush<'a>>,
252    ) -> Pin<Box<dyn Future<Output = Result<String, Error>> + Send + 'a>> {
253        Box::pin(request::execute_request_json(
254            self.get_config(),
255            move |mut req_builder: Builder| {
256                req_builder = req_builder.method("POST");
257                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
258                let mut request_path = request_url.path().to_owned();
259                if request_path.ends_with('/') {
260                    request_path.pop();
261                }
262                request_path.push_str("/images/{name}/push");
263                request_path = request_path.replace("{name}", name);
264                request_url.set_path(&request_path);
265                if let Some(params) = &params {
266                    let mut query_pairs = request_url.query_pairs_mut();
267                    if let Some(tag) = params.tag {
268                        query_pairs.append_pair("tag", tag);
269                    }
270                    if let Some(all) = params.all {
271                        query_pairs.append_pair("all", &all.to_string());
272                    }
273                    if let Some(compress) = params.compress {
274                        query_pairs.append_pair("compress", &compress.to_string());
275                    }
276                    if let Some(destination) = params.destination {
277                        query_pairs.append_pair("destination", destination);
278                    }
279                    if let Some(x_registry_auth) = params.x_registry_auth {
280                        req_builder = req_builder.header("X-Registry-Auth", x_registry_auth);
281                    }
282                }
283                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
284                req_builder = req_builder.uri(hyper_uri);
285                Ok(req_builder.body(String::new())?)
286            },
287        ))
288    }
289    /// POST /images/{name}/tag
290    ///
291    /// Tag an image
292    ///
293    /// Tag an image so that it becomes part of a repository.
294    fn image_tag<'a>(
295        &'a self,
296        name: &'a str,
297        params: Option<crate::v5::params::ImageTag<'a>>,
298    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>> {
299        Box::pin(request::execute_request_unit(
300            self.get_config(),
301            move |mut req_builder: Builder| {
302                req_builder = req_builder.method("POST");
303                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
304                let mut request_path = request_url.path().to_owned();
305                if request_path.ends_with('/') {
306                    request_path.pop();
307                }
308                request_path.push_str("/images/{name}/tag");
309                request_path = request_path.replace("{name}", name);
310                request_url.set_path(&request_path);
311                if let Some(params) = &params {
312                    let mut query_pairs = request_url.query_pairs_mut();
313                    if let Some(repo) = params.repo {
314                        query_pairs.append_pair("repo", repo);
315                    }
316                    if let Some(tag) = params.tag {
317                        query_pairs.append_pair("tag", tag);
318                    }
319                }
320                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
321                req_builder = req_builder.uri(hyper_uri);
322                Ok(req_builder.body(String::new())?)
323            },
324        ))
325    }
326    /// POST /images/create
327    ///
328    /// Create an image
329    ///
330    /// Create an image by either pulling it from a registry or importing it.
331    fn image_create<'a>(
332        &'a self,
333        params: Option<crate::v5::params::ImageCreate<'a>>,
334        input_image: String,
335    ) -> Pin<Box<dyn Future<Output = Result<String, Error>> + Send + 'a>> {
336        Box::pin(request::execute_request_json(
337            self.get_config(),
338            move |mut req_builder: Builder| {
339                req_builder = req_builder.method("POST");
340                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
341                let mut request_path = request_url.path().to_owned();
342                if request_path.ends_with('/') {
343                    request_path.pop();
344                }
345                request_path.push_str("/images/create");
346                request_url.set_path(&request_path);
347                if let Some(params) = &params {
348                    let mut query_pairs = request_url.query_pairs_mut();
349                    if let Some(from_image) = params.from_image {
350                        query_pairs.append_pair("fromImage", from_image);
351                    }
352                    if let Some(from_src) = params.from_src {
353                        query_pairs.append_pair("fromSrc", from_src);
354                    }
355                    if let Some(repo) = params.repo {
356                        query_pairs.append_pair("repo", repo);
357                    }
358                    if let Some(tag) = params.tag {
359                        query_pairs.append_pair("tag", tag);
360                    }
361                    if let Some(message) = params.message {
362                        query_pairs.append_pair("message", message);
363                    }
364                    if let Some(platform) = params.platform {
365                        query_pairs.append_pair("platform", platform);
366                    }
367                    if let Some(x_registry_auth) = params.x_registry_auth {
368                        req_builder = req_builder.header("X-Registry-Auth", x_registry_auth);
369                    }
370                }
371                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
372                req_builder = req_builder.uri(hyper_uri);
373                let body = serde_json::to_string(&input_image)?;
374                req_builder = req_builder.header(hyper::header::CONTENT_TYPE, "application/json");
375                req_builder = req_builder.header(hyper::header::CONTENT_LENGTH, body.len());
376                Ok(req_builder.body(body)?)
377            },
378        ))
379    }
380    /// GET /images/get
381    ///
382    /// Export several images
383    ///
384    /// Get a tarball containing all images and metadata for several image repositories
385    fn image_get_all<'a>(
386        &'a self,
387        params: Option<crate::v5::params::ImageGetAll<'a>>,
388    ) -> Pin<Box<dyn Future<Output = Result<String, Error>> + Send + 'a>> {
389        Box::pin(request::execute_request_json(
390            self.get_config(),
391            move |mut req_builder: Builder| {
392                req_builder = req_builder.method("GET");
393                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
394                let mut request_path = request_url.path().to_owned();
395                if request_path.ends_with('/') {
396                    request_path.pop();
397                }
398                request_path.push_str("/images/get");
399                request_url.set_path(&request_path);
400                if let Some(params) = &params {
401                    let mut query_pairs = request_url.query_pairs_mut();
402                    query_pairs.append_pair("names", params.names);
403                }
404                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
405                req_builder = req_builder.uri(hyper_uri);
406                Ok(req_builder.body(String::new())?)
407            },
408        ))
409    }
410    /// GET /images/json
411    ///
412    /// List Images
413    ///
414    /// Returns a list of images on the server. Note that it uses a different, smaller representation of an image than inspecting a single image.
415    fn image_list<'a>(
416        &'a self,
417        params: Option<crate::v5::params::ImageList<'a>>,
418    ) -> Pin<Box<dyn Future<Output = Result<Vec<crate::v5::models::Summary>, Error>> + Send + 'a>>
419    {
420        Box::pin(request::execute_request_json(
421            self.get_config(),
422            move |mut req_builder: Builder| {
423                req_builder = req_builder.method("GET");
424                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
425                let mut request_path = request_url.path().to_owned();
426                if request_path.ends_with('/') {
427                    request_path.pop();
428                }
429                request_path.push_str("/images/json");
430                request_url.set_path(&request_path);
431                if let Some(params) = &params {
432                    let mut query_pairs = request_url.query_pairs_mut();
433                    if let Some(all) = params.all {
434                        query_pairs.append_pair("all", &all.to_string());
435                    }
436                    if let Some(filters) = params.filters {
437                        query_pairs.append_pair("filters", filters);
438                    }
439                    if let Some(digests) = params.digests {
440                        query_pairs.append_pair("digests", &digests.to_string());
441                    }
442                }
443                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
444                req_builder = req_builder.uri(hyper_uri);
445                Ok(req_builder.body(String::new())?)
446            },
447        ))
448    }
449    /// POST /images/load
450    ///
451    /// Import image
452    ///
453    /// Load a set of images and tags into a repository.
454    fn image_load<'a>(
455        &'a self,
456        params: Option<crate::v5::params::ImageLoad>,
457        request: String,
458    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>> {
459        Box::pin(request::execute_request_unit(
460            self.get_config(),
461            move |mut req_builder: Builder| {
462                req_builder = req_builder.method("POST");
463                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
464                let mut request_path = request_url.path().to_owned();
465                if request_path.ends_with('/') {
466                    request_path.pop();
467                }
468                request_path.push_str("/images/load");
469                request_url.set_path(&request_path);
470                if let Some(params) = &params {
471                    let mut query_pairs = request_url.query_pairs_mut();
472                    if let Some(quiet) = params.quiet {
473                        query_pairs.append_pair("quiet", &quiet.to_string());
474                    }
475                }
476                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
477                req_builder = req_builder.uri(hyper_uri);
478                let body = serde_json::to_string(&request)?;
479                req_builder = req_builder.header(hyper::header::CONTENT_TYPE, "application/json");
480                req_builder = req_builder.header(hyper::header::CONTENT_LENGTH, body.len());
481                Ok(req_builder.body(body)?)
482            },
483        ))
484    }
485    /// POST /images/prune
486    ///
487    /// Prune unused images
488    ///
489    /// Remove images from local storage that are not being used by a container
490    fn image_prune<'a>(
491        &'a self,
492        params: Option<crate::v5::params::ImagePrune<'a>>,
493    ) -> Pin<
494        Box<
495            dyn Future<Output = Result<Vec<crate::v5::models::ImageDeleteResponseItems>, Error>>
496                + Send
497                + 'a,
498        >,
499    > {
500        Box::pin(request::execute_request_json(
501            self.get_config(),
502            move |mut req_builder: Builder| {
503                req_builder = req_builder.method("POST");
504                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
505                let mut request_path = request_url.path().to_owned();
506                if request_path.ends_with('/') {
507                    request_path.pop();
508                }
509                request_path.push_str("/images/prune");
510                request_url.set_path(&request_path);
511                if let Some(params) = &params {
512                    let mut query_pairs = request_url.query_pairs_mut();
513                    if let Some(filters) = params.filters {
514                        query_pairs.append_pair("filters", filters);
515                    }
516                }
517                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
518                req_builder = req_builder.uri(hyper_uri);
519                Ok(req_builder.body(String::new())?)
520            },
521        ))
522    }
523    /// GET /images/search
524    ///
525    /// Search images
526    ///
527    /// Search registries for an image
528    fn image_search<'a>(
529        &'a self,
530        params: Option<crate::v5::params::ImageSearch<'a>>,
531    ) -> Pin<
532        Box<
533            dyn Future<Output = Result<Vec<crate::v5::models::RegistrySearchResponse>, Error>>
534                + Send
535                + 'a,
536        >,
537    > {
538        Box::pin(request::execute_request_json(
539            self.get_config(),
540            move |mut req_builder: Builder| {
541                req_builder = req_builder.method("GET");
542                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
543                let mut request_path = request_url.path().to_owned();
544                if request_path.ends_with('/') {
545                    request_path.pop();
546                }
547                request_path.push_str("/images/search");
548                request_url.set_path(&request_path);
549                if let Some(params) = &params {
550                    let mut query_pairs = request_url.query_pairs_mut();
551                    if let Some(term) = params.term {
552                        query_pairs.append_pair("term", term);
553                    }
554                    if let Some(limit) = params.limit {
555                        query_pairs.append_pair("limit", &limit.to_string());
556                    }
557                    if let Some(filters) = params.filters {
558                        query_pairs.append_pair("filters", filters);
559                    }
560                    if let Some(tls_verify) = params.tls_verify {
561                        query_pairs.append_pair("tlsVerify", &tls_verify.to_string());
562                    }
563                    if let Some(list_tags) = params.list_tags {
564                        query_pairs.append_pair("listTags", &list_tags.to_string());
565                    }
566                }
567                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
568                req_builder = req_builder.uri(hyper_uri);
569                Ok(req_builder.body(String::new())?)
570            },
571        ))
572    }
573}
podman_rest_client/v5/apis/images_compat.rs

podman_rest_client/v5/apis/
images_compat.rs
