podman_client/images/
list.rs

1use std::collections::HashMap;
2
3use http_body_util::Empty;
4use hyper::body::Bytes;
5use url::form_urlencoded::{self, byte_serialize};
6
7use crate::{
8    client::Client,
9    models::{
10        connection::SendRequestOptions,
11        lib::Error,
12        podman::images::list::{ImageList, ImageListOptions},
13    },
14    utils::bool_to_str::bool_to_str,
15};
16
17impl Client {
18    pub async fn image_list(
19        &self,
20        options: Option<ImageListOptions<'_>>,
21    ) -> Result<ImageList, Error> {
22        let mut path = "/libpod/images/json".to_owned();
23
24        if let Some(options) = options {
25            let mut query = form_urlencoded::Serializer::new(String::new());
26            if let Some(all) = options.all {
27                query.append_pair("all", bool_to_str(all));
28            }
29            if let Some(opt_filters) = options.filters {
30                let mut filters = HashMap::new();
31                if let Some(before) = opt_filters.before
32                    && !before.is_empty()
33                {
34                    filters.insert("before", before);
35                }
36                if let Some(dangling) = opt_filters.dangling
37                    && !dangling.is_empty()
38                {
39                    filters.insert(
40                        "dangling",
41                        dangling.iter().map(|&d| bool_to_str(d)).collect(),
42                    );
43                }
44                if let Some(label) = opt_filters.label
45                    && !label.is_empty()
46                {
47                    filters.insert("label", label);
48                }
49                if let Some(reference) = opt_filters.reference
50                    && !reference.is_empty()
51                {
52                    filters.insert("reference", reference);
53                }
54                if let Some(id) = opt_filters.id
55                    && !id.is_empty()
56                {
57                    filters.insert("id", id);
58                }
59                if let Some(since) = opt_filters.since
60                    && !since.is_empty()
61                {
62                    filters.insert("since", since);
63                }
64
65                if !filters.is_empty() {
66                    let filters_json = serde_json::to_string(&filters)?;
67                    let filters_encoded: String = byte_serialize(filters_json.as_bytes()).collect();
68                    query.append_pair("filters", &filters_encoded);
69                }
70
71                let query_string = query.finish();
72
73                if !query_string.is_empty() {
74                    path += &["?", &query_string].concat();
75                }
76            }
77        }
78
79        let (_, data) = self
80            .send_request::<_, (), _>(SendRequestOptions {
81                method: "GET",
82                path: &path,
83                header: None,
84                body: Empty::<Bytes>::new(),
85            })
86            .await?;
87
88        Ok(data)
89    }
90}