podman_rest_client/v5/apis/
containers_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 ContainersCompat: HasConfig + Send + Sync {
8    /// POST /commit
9    ///
10    /// New Image
11    ///
12    /// Create a new image from a container
13    fn image_commit<'a>(
14        &'a self,
15        params: Option<crate::v5::params::ImageCommit<'a>>,
16    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>> {
17        Box::pin(request::execute_request_unit(
18            self.get_config(),
19            move |mut req_builder: Builder| {
20                req_builder = req_builder.method("POST");
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("/commit");
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(container) = params.container {
31                        query_pairs.append_pair("container", container);
32                    }
33                    if let Some(repo) = params.repo {
34                        query_pairs.append_pair("repo", repo);
35                    }
36                    if let Some(tag) = params.tag {
37                        query_pairs.append_pair("tag", tag);
38                    }
39                    if let Some(comment) = params.comment {
40                        query_pairs.append_pair("comment", comment);
41                    }
42                    if let Some(author) = params.author {
43                        query_pairs.append_pair("author", author);
44                    }
45                    if let Some(pause) = params.pause {
46                        query_pairs.append_pair("pause", &pause.to_string());
47                    }
48                    if let Some(changes) = params.changes {
49                        query_pairs.append_pair("changes", changes);
50                    }
51                    if let Some(squash) = params.squash {
52                        query_pairs.append_pair("squash", &squash.to_string());
53                    }
54                }
55                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
56                req_builder = req_builder.uri(hyper_uri);
57                Ok(req_builder.body(String::new())?)
58            },
59        ))
60    }
61    /// DELETE /containers/{name}
62    ///
63    /// Remove a container
64    fn container_delete<'a>(
65        &'a self,
66        name: &'a str,
67        params: Option<crate::v5::params::ContainerDelete>,
68    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>> {
69        Box::pin(request::execute_request_unit(
70            self.get_config(),
71            move |mut req_builder: Builder| {
72                req_builder = req_builder.method("DELETE");
73                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
74                let mut request_path = request_url.path().to_owned();
75                if request_path.ends_with('/') {
76                    request_path.pop();
77                }
78                request_path.push_str("/containers/{name}");
79                request_path = request_path.replace("{name}", name);
80                request_url.set_path(&request_path);
81                if let Some(params) = &params {
82                    let mut query_pairs = request_url.query_pairs_mut();
83                    if let Some(force) = params.force {
84                        query_pairs.append_pair("force", &force.to_string());
85                    }
86                    if let Some(v) = params.v {
87                        query_pairs.append_pair("v", &v.to_string());
88                    }
89                    if let Some(link) = params.link {
90                        query_pairs.append_pair("link", &link.to_string());
91                    }
92                }
93                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
94                req_builder = req_builder.uri(hyper_uri);
95                Ok(req_builder.body(String::new())?)
96            },
97        ))
98    }
99    /// GET /containers/{name}/archive
100    ///
101    /// Get files from a container
102    ///
103    /// Get a tar archive of files from a container
104    fn container_archive<'a>(
105        &'a self,
106        name: &'a str,
107        params: Option<crate::v5::params::ContainerArchive<'a>>,
108    ) -> Pin<Box<dyn Future<Output = Result<String, Error>> + Send + 'a>> {
109        Box::pin(request::execute_request_json(
110            self.get_config(),
111            move |mut req_builder: Builder| {
112                req_builder = req_builder.method("GET");
113                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
114                let mut request_path = request_url.path().to_owned();
115                if request_path.ends_with('/') {
116                    request_path.pop();
117                }
118                request_path.push_str("/containers/{name}/archive");
119                request_path = request_path.replace("{name}", name);
120                request_url.set_path(&request_path);
121                if let Some(params) = &params {
122                    let mut query_pairs = request_url.query_pairs_mut();
123                    query_pairs.append_pair("path", params.path);
124                }
125                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
126                req_builder = req_builder.uri(hyper_uri);
127                Ok(req_builder.body(String::new())?)
128            },
129        ))
130    }
131    /// GET /containers/{name}/archive
132    ///
133    /// Put files into a container
134    ///
135    /// Put a tar archive of files into a container
136    fn put_container_archive<'a>(
137        &'a self,
138        name: &'a str,
139        params: Option<crate::v5::params::PutContainerArchive<'a>>,
140        request: String,
141    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>> {
142        Box::pin(request::execute_request_unit(
143            self.get_config(),
144            move |mut req_builder: Builder| {
145                req_builder = req_builder.method("GET");
146                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
147                let mut request_path = request_url.path().to_owned();
148                if request_path.ends_with('/') {
149                    request_path.pop();
150                }
151                request_path.push_str("/containers/{name}/archive");
152                request_path = request_path.replace("{name}", name);
153                request_url.set_path(&request_path);
154                if let Some(params) = &params {
155                    let mut query_pairs = request_url.query_pairs_mut();
156                    query_pairs.append_pair("path", params.path);
157                    if let Some(no_overwrite_dir_non_dir) = params.no_overwrite_dir_non_dir {
158                        query_pairs.append_pair("noOverwriteDirNonDir", no_overwrite_dir_non_dir);
159                    }
160                    if let Some(copy_uidgid) = params.copy_uidgid {
161                        query_pairs.append_pair("copyUIDGID", copy_uidgid);
162                    }
163                }
164                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
165                req_builder = req_builder.uri(hyper_uri);
166                let body = serde_json::to_string(&request)?;
167                req_builder = req_builder.header(hyper::header::CONTENT_TYPE, "application/json");
168                req_builder = req_builder.header(hyper::header::CONTENT_LENGTH, body.len());
169                Ok(req_builder.body(body)?)
170            },
171        ))
172    }
173    /// POST /containers/{name}/attach
174    ///
175    /// Attach to a container
176    ///
177    /// Attach to a container to read its output or send it input. You can attach
178    /// to the same container multiple times and you can reattach to containers
179    /// that have been detached.
180    ///
181    /// It uses the same stream format as docker, see the libpod attach endpoint for a description of the format.
182    fn container_attach<'a>(
183        &'a self,
184        name: &'a str,
185        params: Option<crate::v5::params::ContainerAttach<'a>>,
186    ) -> Pin<
187        Box<
188            dyn Future<Output = Result<hyper_util::rt::TokioIo<hyper::upgrade::Upgraded>, Error>>
189                + Send
190                + 'a,
191        >,
192    > {
193        Box::pin(request::execute_request_upgrade(
194            self.get_config(),
195            move |mut req_builder: Builder| {
196                req_builder = req_builder.method("POST");
197                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
198                let mut request_path = request_url.path().to_owned();
199                if request_path.ends_with('/') {
200                    request_path.pop();
201                }
202                request_path.push_str("/containers/{name}/attach");
203                request_path = request_path.replace("{name}", name);
204                request_url.set_path(&request_path);
205                if let Some(params) = &params {
206                    let mut query_pairs = request_url.query_pairs_mut();
207                    if let Some(detach_keys) = params.detach_keys {
208                        query_pairs.append_pair("detachKeys", detach_keys);
209                    }
210                    if let Some(logs) = params.logs {
211                        query_pairs.append_pair("logs", &logs.to_string());
212                    }
213                    if let Some(stream) = params.stream {
214                        query_pairs.append_pair("stream", &stream.to_string());
215                    }
216                    if let Some(stdout) = params.stdout {
217                        query_pairs.append_pair("stdout", &stdout.to_string());
218                    }
219                    if let Some(stderr) = params.stderr {
220                        query_pairs.append_pair("stderr", &stderr.to_string());
221                    }
222                    if let Some(stdin) = params.stdin {
223                        query_pairs.append_pair("stdin", &stdin.to_string());
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    /// GET /containers/{name}/export
233    ///
234    /// Export a container
235    ///
236    /// Export the contents of a container as a tarball.
237    fn container_export<'a>(
238        &'a self,
239        name: &'a str,
240    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>> {
241        Box::pin(request::execute_request_unit(
242            self.get_config(),
243            move |mut req_builder: Builder| {
244                req_builder = req_builder.method("GET");
245                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
246                let mut request_path = request_url.path().to_owned();
247                if request_path.ends_with('/') {
248                    request_path.pop();
249                }
250                request_path.push_str("/containers/{name}/export");
251                request_path = request_path.replace("{name}", name);
252                request_url.set_path(&request_path);
253                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
254                req_builder = req_builder.uri(hyper_uri);
255                Ok(req_builder.body(String::new())?)
256            },
257        ))
258    }
259    /// GET /containers/{name}/json
260    ///
261    /// Inspect container
262    ///
263    /// Return low-level information about a container.
264    fn container_inspect<'a>(
265        &'a self,
266        name: &'a str,
267        params: Option<crate::v5::params::ContainerInspect>,
268    ) -> Pin<Box<dyn Future<Output = Result<crate::v5::models::ContainerJson, Error>> + Send + 'a>>
269    {
270        Box::pin(request::execute_request_json(
271            self.get_config(),
272            move |mut req_builder: Builder| {
273                req_builder = req_builder.method("GET");
274                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
275                let mut request_path = request_url.path().to_owned();
276                if request_path.ends_with('/') {
277                    request_path.pop();
278                }
279                request_path.push_str("/containers/{name}/json");
280                request_path = request_path.replace("{name}", name);
281                request_url.set_path(&request_path);
282                if let Some(params) = &params {
283                    let mut query_pairs = request_url.query_pairs_mut();
284                    if let Some(size) = params.size {
285                        query_pairs.append_pair("size", &size.to_string());
286                    }
287                }
288                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
289                req_builder = req_builder.uri(hyper_uri);
290                Ok(req_builder.body(String::new())?)
291            },
292        ))
293    }
294    /// POST /containers/{name}/kill
295    ///
296    /// Kill container
297    ///
298    /// Signal to send to the container as an integer or string (e.g. SIGINT)
299    fn container_kill<'a>(
300        &'a self,
301        name: &'a str,
302        params: Option<crate::v5::params::ContainerKill<'a>>,
303    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>> {
304        Box::pin(request::execute_request_unit(
305            self.get_config(),
306            move |mut req_builder: Builder| {
307                req_builder = req_builder.method("POST");
308                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
309                let mut request_path = request_url.path().to_owned();
310                if request_path.ends_with('/') {
311                    request_path.pop();
312                }
313                request_path.push_str("/containers/{name}/kill");
314                request_path = request_path.replace("{name}", name);
315                request_url.set_path(&request_path);
316                if let Some(params) = &params {
317                    let mut query_pairs = request_url.query_pairs_mut();
318                    if let Some(all) = params.all {
319                        query_pairs.append_pair("all", &all.to_string());
320                    }
321                    if let Some(signal) = params.signal {
322                        query_pairs.append_pair("signal", signal);
323                    }
324                }
325                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
326                req_builder = req_builder.uri(hyper_uri);
327                Ok(req_builder.body(String::new())?)
328            },
329        ))
330    }
331    /// GET /containers/{name}/logs
332    ///
333    /// Get container logs
334    ///
335    /// Get stdout and stderr logs from a container.
336    fn container_logs<'a>(
337        &'a self,
338        name: &'a str,
339        params: Option<crate::v5::params::ContainerLogs<'a>>,
340    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>> {
341        Box::pin(request::execute_request_unit(
342            self.get_config(),
343            move |mut req_builder: Builder| {
344                req_builder = req_builder.method("GET");
345                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
346                let mut request_path = request_url.path().to_owned();
347                if request_path.ends_with('/') {
348                    request_path.pop();
349                }
350                request_path.push_str("/containers/{name}/logs");
351                request_path = request_path.replace("{name}", name);
352                request_url.set_path(&request_path);
353                if let Some(params) = &params {
354                    let mut query_pairs = request_url.query_pairs_mut();
355                    if let Some(follow) = params.follow {
356                        query_pairs.append_pair("follow", &follow.to_string());
357                    }
358                    if let Some(stdout) = params.stdout {
359                        query_pairs.append_pair("stdout", &stdout.to_string());
360                    }
361                    if let Some(stderr) = params.stderr {
362                        query_pairs.append_pair("stderr", &stderr.to_string());
363                    }
364                    if let Some(since) = params.since {
365                        query_pairs.append_pair("since", since);
366                    }
367                    if let Some(until) = params.until {
368                        query_pairs.append_pair("until", until);
369                    }
370                    if let Some(timestamps) = params.timestamps {
371                        query_pairs.append_pair("timestamps", &timestamps.to_string());
372                    }
373                    if let Some(tail) = params.tail {
374                        query_pairs.append_pair("tail", tail);
375                    }
376                }
377                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
378                req_builder = req_builder.uri(hyper_uri);
379                Ok(req_builder.body(String::new())?)
380            },
381        ))
382    }
383    /// POST /containers/{name}/pause
384    ///
385    /// Pause container
386    ///
387    /// Use the cgroups freezer to suspend all processes in a container.
388    fn container_pause<'a>(
389        &'a self,
390        name: &'a str,
391    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>> {
392        Box::pin(request::execute_request_unit(
393            self.get_config(),
394            move |mut req_builder: Builder| {
395                req_builder = req_builder.method("POST");
396                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
397                let mut request_path = request_url.path().to_owned();
398                if request_path.ends_with('/') {
399                    request_path.pop();
400                }
401                request_path.push_str("/containers/{name}/pause");
402                request_path = request_path.replace("{name}", name);
403                request_url.set_path(&request_path);
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    /// POST /containers/{name}/rename
411    ///
412    /// Rename an existing container
413    ///
414    /// Change the name of an existing container.
415    fn container_rename<'a>(
416        &'a self,
417        name: &'a str,
418        params: Option<crate::v5::params::ContainerRename<'a>>,
419    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>> {
420        Box::pin(request::execute_request_unit(
421            self.get_config(),
422            move |mut req_builder: Builder| {
423                req_builder = req_builder.method("POST");
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("/containers/{name}/rename");
430                request_path = request_path.replace("{name}", name);
431                request_url.set_path(&request_path);
432                if let Some(params) = &params {
433                    let mut query_pairs = request_url.query_pairs_mut();
434                    query_pairs.append_pair("name", params.name);
435                }
436                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
437                req_builder = req_builder.uri(hyper_uri);
438                Ok(req_builder.body(String::new())?)
439            },
440        ))
441    }
442    /// POST /containers/{name}/resize
443    ///
444    /// Resize a container's TTY
445    ///
446    /// Resize the terminal attached to a container (for use with Attach).
447    fn container_resize<'a>(
448        &'a self,
449        name: &'a str,
450        params: Option<crate::v5::params::ContainerResize>,
451    ) -> Pin<Box<dyn Future<Output = Result<serde_json::Value, Error>> + Send + 'a>> {
452        Box::pin(request::execute_request_json(
453            self.get_config(),
454            move |mut req_builder: Builder| {
455                req_builder = req_builder.method("POST");
456                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
457                let mut request_path = request_url.path().to_owned();
458                if request_path.ends_with('/') {
459                    request_path.pop();
460                }
461                request_path.push_str("/containers/{name}/resize");
462                request_path = request_path.replace("{name}", name);
463                request_url.set_path(&request_path);
464                if let Some(params) = &params {
465                    let mut query_pairs = request_url.query_pairs_mut();
466                    if let Some(h) = params.h {
467                        query_pairs.append_pair("h", &h.to_string());
468                    }
469                    if let Some(w) = params.w {
470                        query_pairs.append_pair("w", &w.to_string());
471                    }
472                    if let Some(running) = params.running {
473                        query_pairs.append_pair("running", &running.to_string());
474                    }
475                }
476                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
477                req_builder = req_builder.uri(hyper_uri);
478                Ok(req_builder.body(String::new())?)
479            },
480        ))
481    }
482    /// POST /containers/{name}/restart
483    ///
484    /// Restart container
485    fn container_restart<'a>(
486        &'a self,
487        name: &'a str,
488        params: Option<crate::v5::params::ContainerRestart>,
489    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>> {
490        Box::pin(request::execute_request_unit(
491            self.get_config(),
492            move |mut req_builder: Builder| {
493                req_builder = req_builder.method("POST");
494                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
495                let mut request_path = request_url.path().to_owned();
496                if request_path.ends_with('/') {
497                    request_path.pop();
498                }
499                request_path.push_str("/containers/{name}/restart");
500                request_path = request_path.replace("{name}", name);
501                request_url.set_path(&request_path);
502                if let Some(params) = &params {
503                    let mut query_pairs = request_url.query_pairs_mut();
504                    if let Some(t) = params.t {
505                        query_pairs.append_pair("t", &t.to_string());
506                    }
507                }
508                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
509                req_builder = req_builder.uri(hyper_uri);
510                Ok(req_builder.body(String::new())?)
511            },
512        ))
513    }
514    /// POST /containers/{name}/start
515    ///
516    /// Start a container
517    fn container_start<'a>(
518        &'a self,
519        name: &'a str,
520        params: Option<crate::v5::params::ContainerStart<'a>>,
521    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>> {
522        Box::pin(request::execute_request_unit(
523            self.get_config(),
524            move |mut req_builder: Builder| {
525                req_builder = req_builder.method("POST");
526                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
527                let mut request_path = request_url.path().to_owned();
528                if request_path.ends_with('/') {
529                    request_path.pop();
530                }
531                request_path.push_str("/containers/{name}/start");
532                request_path = request_path.replace("{name}", name);
533                request_url.set_path(&request_path);
534                if let Some(params) = &params {
535                    let mut query_pairs = request_url.query_pairs_mut();
536                    if let Some(detach_keys) = params.detach_keys {
537                        query_pairs.append_pair("detachKeys", detach_keys);
538                    }
539                }
540                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
541                req_builder = req_builder.uri(hyper_uri);
542                Ok(req_builder.body(String::new())?)
543            },
544        ))
545    }
546    /// GET /containers/{name}/stats
547    ///
548    /// Get stats for a container
549    ///
550    /// This returns a live stream of a container’s resource usage statistics.
551    fn container_stats<'a>(
552        &'a self,
553        name: &'a str,
554        params: Option<crate::v5::params::ContainerStats>,
555    ) -> Pin<Box<dyn Future<Output = Result<serde_json::Value, Error>> + Send + 'a>> {
556        Box::pin(request::execute_request_json(
557            self.get_config(),
558            move |mut req_builder: Builder| {
559                req_builder = req_builder.method("GET");
560                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
561                let mut request_path = request_url.path().to_owned();
562                if request_path.ends_with('/') {
563                    request_path.pop();
564                }
565                request_path.push_str("/containers/{name}/stats");
566                request_path = request_path.replace("{name}", name);
567                request_url.set_path(&request_path);
568                if let Some(params) = &params {
569                    let mut query_pairs = request_url.query_pairs_mut();
570                    if let Some(stream) = params.stream {
571                        query_pairs.append_pair("stream", &stream.to_string());
572                    }
573                    if let Some(one_shot) = params.one_shot {
574                        query_pairs.append_pair("one-shot", &one_shot.to_string());
575                    }
576                }
577                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
578                req_builder = req_builder.uri(hyper_uri);
579                Ok(req_builder.body(String::new())?)
580            },
581        ))
582    }
583    /// POST /containers/{name}/stop
584    ///
585    /// Stop a container
586    fn container_stop<'a>(
587        &'a self,
588        name: &'a str,
589        params: Option<crate::v5::params::ContainerStop>,
590    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>> {
591        Box::pin(request::execute_request_unit(
592            self.get_config(),
593            move |mut req_builder: Builder| {
594                req_builder = req_builder.method("POST");
595                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
596                let mut request_path = request_url.path().to_owned();
597                if request_path.ends_with('/') {
598                    request_path.pop();
599                }
600                request_path.push_str("/containers/{name}/stop");
601                request_path = request_path.replace("{name}", name);
602                request_url.set_path(&request_path);
603                if let Some(params) = &params {
604                    let mut query_pairs = request_url.query_pairs_mut();
605                    if let Some(t) = params.t {
606                        query_pairs.append_pair("t", &t.to_string());
607                    }
608                }
609                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
610                req_builder = req_builder.uri(hyper_uri);
611                Ok(req_builder.body(String::new())?)
612            },
613        ))
614    }
615    /// GET /containers/{name}/top
616    ///
617    /// List processes running inside a container
618    fn container_top<'a>(
619        &'a self,
620        name: &'a str,
621        params: Option<crate::v5::params::ContainerTop<'a>>,
622    ) -> Pin<
623        Box<dyn Future<Output = Result<crate::v5::models::ContainerTopOkBody, Error>> + Send + 'a>,
624    > {
625        Box::pin(request::execute_request_json(
626            self.get_config(),
627            move |mut req_builder: Builder| {
628                req_builder = req_builder.method("GET");
629                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
630                let mut request_path = request_url.path().to_owned();
631                if request_path.ends_with('/') {
632                    request_path.pop();
633                }
634                request_path.push_str("/containers/{name}/top");
635                request_path = request_path.replace("{name}", name);
636                request_url.set_path(&request_path);
637                if let Some(params) = &params {
638                    let mut query_pairs = request_url.query_pairs_mut();
639                    if let Some(ps_args) = params.ps_args {
640                        query_pairs.append_pair("ps_args", ps_args);
641                    }
642                }
643                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
644                req_builder = req_builder.uri(hyper_uri);
645                Ok(req_builder.body(String::new())?)
646            },
647        ))
648    }
649    /// POST /containers/{name}/unpause
650    ///
651    /// Unpause container
652    ///
653    /// Resume a paused container
654    fn container_unpause<'a>(
655        &'a self,
656        name: &'a str,
657    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>> {
658        Box::pin(request::execute_request_unit(
659            self.get_config(),
660            move |mut req_builder: Builder| {
661                req_builder = req_builder.method("POST");
662                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
663                let mut request_path = request_url.path().to_owned();
664                if request_path.ends_with('/') {
665                    request_path.pop();
666                }
667                request_path.push_str("/containers/{name}/unpause");
668                request_path = request_path.replace("{name}", name);
669                request_url.set_path(&request_path);
670                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
671                req_builder = req_builder.uri(hyper_uri);
672                Ok(req_builder.body(String::new())?)
673            },
674        ))
675    }
676    /// POST /containers/{name}/update
677    ///
678    /// Update configuration of an existing container
679    ///
680    /// Change configuration settings for an existing container without requiring recreation.
681    fn container_update<'a>(
682        &'a self,
683        name: &'a str,
684        resources: crate::v5::models::UpdateConfig,
685    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>> {
686        Box::pin(request::execute_request_unit(
687            self.get_config(),
688            move |mut req_builder: Builder| {
689                req_builder = req_builder.method("POST");
690                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
691                let mut request_path = request_url.path().to_owned();
692                if request_path.ends_with('/') {
693                    request_path.pop();
694                }
695                request_path.push_str("/containers/{name}/update");
696                request_path = request_path.replace("{name}", name);
697                request_url.set_path(&request_path);
698                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
699                req_builder = req_builder.uri(hyper_uri);
700                let body = serde_json::to_string(&resources)?;
701                req_builder = req_builder.header(hyper::header::CONTENT_TYPE, "application/json");
702                req_builder = req_builder.header(hyper::header::CONTENT_LENGTH, body.len());
703                Ok(req_builder.body(body)?)
704            },
705        ))
706    }
707    /// POST /containers/{name}/wait
708    ///
709    /// Wait on a container
710    ///
711    /// Block until a container stops or given condition is met.
712    fn container_wait<'a>(
713        &'a self,
714        name: &'a str,
715        params: Option<crate::v5::params::ContainerWait<'a>>,
716    ) -> Pin<
717        Box<
718            dyn Future<Output = Result<crate::v5::models::ContainerWaitResponse, Error>>
719                + Send
720                + 'a,
721        >,
722    > {
723        Box::pin(request::execute_request_json(
724            self.get_config(),
725            move |mut req_builder: Builder| {
726                req_builder = req_builder.method("POST");
727                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
728                let mut request_path = request_url.path().to_owned();
729                if request_path.ends_with('/') {
730                    request_path.pop();
731                }
732                request_path.push_str("/containers/{name}/wait");
733                request_path = request_path.replace("{name}", name);
734                request_url.set_path(&request_path);
735                if let Some(params) = &params {
736                    let mut query_pairs = request_url.query_pairs_mut();
737                    if let Some(condition) = params.condition {
738                        query_pairs.append_pair("condition", condition);
739                    }
740                    if let Some(interval) = params.interval {
741                        query_pairs.append_pair("interval", interval);
742                    }
743                }
744                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
745                req_builder = req_builder.uri(hyper_uri);
746                Ok(req_builder.body(String::new())?)
747            },
748        ))
749    }
750    /// POST /containers/create
751    ///
752    /// Create a container
753    fn container_create<'a>(
754        &'a self,
755        params: Option<crate::v5::params::ContainerCreate<'a>>,
756        body: crate::v5::models::CreateContainerConfig,
757    ) -> Pin<
758        Box<
759            dyn Future<Output = Result<crate::v5::models::ContainerCreateResponse, Error>>
760                + Send
761                + 'a,
762        >,
763    > {
764        Box::pin(request::execute_request_json(
765            self.get_config(),
766            move |mut req_builder: Builder| {
767                req_builder = req_builder.method("POST");
768                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
769                let mut request_path = request_url.path().to_owned();
770                if request_path.ends_with('/') {
771                    request_path.pop();
772                }
773                request_path.push_str("/containers/create");
774                request_url.set_path(&request_path);
775                if let Some(params) = &params {
776                    let mut query_pairs = request_url.query_pairs_mut();
777                    if let Some(name) = params.name {
778                        query_pairs.append_pair("name", name);
779                    }
780                }
781                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
782                req_builder = req_builder.uri(hyper_uri);
783                let body = serde_json::to_string(&body)?;
784                req_builder = req_builder.header(hyper::header::CONTENT_TYPE, "application/json");
785                req_builder = req_builder.header(hyper::header::CONTENT_LENGTH, body.len());
786                Ok(req_builder.body(body)?)
787            },
788        ))
789    }
790    /// GET /containers/json
791    ///
792    /// List containers
793    ///
794    /// Returns a list of containers
795    fn container_list<'a>(
796        &'a self,
797        params: Option<crate::v5::params::ContainerList<'a>>,
798    ) -> Pin<Box<dyn Future<Output = Result<Vec<crate::v5::models::Container>, Error>> + Send + 'a>>
799    {
800        Box::pin(request::execute_request_json(
801            self.get_config(),
802            move |mut req_builder: Builder| {
803                req_builder = req_builder.method("GET");
804                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
805                let mut request_path = request_url.path().to_owned();
806                if request_path.ends_with('/') {
807                    request_path.pop();
808                }
809                request_path.push_str("/containers/json");
810                request_url.set_path(&request_path);
811                if let Some(params) = &params {
812                    let mut query_pairs = request_url.query_pairs_mut();
813                    if let Some(all) = params.all {
814                        query_pairs.append_pair("all", &all.to_string());
815                    }
816                    if let Some(external) = params.external {
817                        query_pairs.append_pair("external", &external.to_string());
818                    }
819                    if let Some(limit) = params.limit {
820                        query_pairs.append_pair("limit", &limit.to_string());
821                    }
822                    if let Some(size) = params.size {
823                        query_pairs.append_pair("size", &size.to_string());
824                    }
825                    if let Some(filters) = params.filters {
826                        query_pairs.append_pair("filters", filters);
827                    }
828                }
829                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
830                req_builder = req_builder.uri(hyper_uri);
831                Ok(req_builder.body(String::new())?)
832            },
833        ))
834    }
835    /// POST /containers/prune
836    ///
837    /// Delete stopped containers
838    ///
839    /// Remove containers not in use
840    fn container_prune<'a>(
841        &'a self,
842        params: Option<crate::v5::params::ContainerPrune<'a>>,
843    ) -> Pin<
844        Box<
845            dyn Future<Output = Result<Vec<crate::v5::models::ContainersPruneReport>, Error>>
846                + Send
847                + 'a,
848        >,
849    > {
850        Box::pin(request::execute_request_json(
851            self.get_config(),
852            move |mut req_builder: Builder| {
853                req_builder = req_builder.method("POST");
854                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
855                let mut request_path = request_url.path().to_owned();
856                if request_path.ends_with('/') {
857                    request_path.pop();
858                }
859                request_path.push_str("/containers/prune");
860                request_url.set_path(&request_path);
861                if let Some(params) = &params {
862                    let mut query_pairs = request_url.query_pairs_mut();
863                    if let Some(filters) = params.filters {
864                        query_pairs.append_pair("filters", filters);
865                    }
866                }
867                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
868                req_builder = req_builder.uri(hyper_uri);
869                Ok(req_builder.body(String::new())?)
870            },
871        ))
872    }
873    /// GET /libpod/containers/{name}/archive
874    ///
875    /// Copy files from a container
876    ///
877    /// Copy a tar archive of files from a container
878    fn container_archive_libpod<'a>(
879        &'a self,
880        name: &'a str,
881        params: Option<crate::v5::params::ContainerArchiveLibpod<'a>>,
882    ) -> Pin<Box<dyn Future<Output = Result<String, Error>> + Send + 'a>> {
883        Box::pin(request::execute_request_json(
884            self.get_config(),
885            move |mut req_builder: Builder| {
886                req_builder = req_builder.method("GET");
887                let mut request_url = url::Url::parse(self.get_config().get_base_path())?;
888                let mut request_path = request_url.path().to_owned();
889                if request_path.ends_with('/') {
890                    request_path.pop();
891                }
892                request_path.push_str("/libpod/containers/{name}/archive");
893                request_path = request_path.replace("{name}", name);
894                request_url.set_path(&request_path);
895                if let Some(params) = &params {
896                    let mut query_pairs = request_url.query_pairs_mut();
897                    query_pairs.append_pair("path", params.path);
898                    if let Some(rename) = params.rename {
899                        query_pairs.append_pair("rename", rename);
900                    }
901                }
902                let hyper_uri: hyper::Uri = request_url.as_str().parse()?;
903                req_builder = req_builder.uri(hyper_uri);
904                Ok(req_builder.body(String::new())?)
905            },
906        ))
907    }
908}
podman_rest_client/v5/apis/containers_compat.rs

podman_rest_client/v5/apis/
containers_compat.rs
