podman-api 0.1.0

Rust interface to Podman
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

pub mod url {
    use std::{borrow::Borrow, string::ToString};
    use url::form_urlencoded;

    pub fn construct_ep<E, Q>(ep: E, query: Option<Q>) -> String
    where
        E: Into<String>,
        Q: AsRef<str>,
    {
        let mut ep = ep.into();
        if let Some(query) = query {
            append_query(&mut ep, query);
        }
        ep
    }

    pub fn append_query<Q>(ep: &mut String, query: Q)
    where
        Q: AsRef<str>,
    {
        ep.push('?');
        ep.push_str(query.as_ref());
    }

    pub fn encoded_pair<K, V>(key: K, val: V) -> String
    where
        K: AsRef<str> + 'static,
        V: ToString,
    {
        form_urlencoded::Serializer::new(String::new())
            .append_pair(key.as_ref(), &val.to_string())
            .finish()
    }

    pub fn encoded_pairs<I, K, V>(iter: I) -> String
    where
        I: IntoIterator,
        I::Item: Borrow<(K, V)>,
        K: AsRef<str>,
        V: AsRef<str>,
    {
        iter.into_iter()
            .fold(
                form_urlencoded::Serializer::new(String::new()),
                |mut acc, v| {
                    let &(ref k, ref v) = v.borrow();
                    let k = k.as_ref();
                    let v = v.as_ref();
                    if v.is_empty() {
                        acc.append_key_only(k);
                    } else {
                        acc.append_pair(k, v);
                    }
                    acc
                },
            )
            .finish()
    }
}

#[cfg(feature = "chrono")]
pub mod datetime {
    use chrono::{DateTime, Utc};
    use serde::Deserialize;

    pub(crate) fn datetime_from_unix_timestamp<'de, D>(
        deserializer: D,
    ) -> Result<DateTime<Utc>, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let timestamp = chrono::NaiveDateTime::from_timestamp(i64::deserialize(deserializer)?, 0);
        Ok(DateTime::<Utc>::from_utc(timestamp, Utc))
    }

    pub(crate) fn datetime_from_nano_timestamp<'de, D>(
        deserializer: D,
    ) -> Result<DateTime<Utc>, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let timestamp_nano = u64::deserialize(deserializer)?;
        let timestamp = chrono::NaiveDateTime::from_timestamp(
            (timestamp_nano / 1_000_000_000) as i64,
            (timestamp_nano % 1_000_000_000) as u32,
        );
        Ok(DateTime::<Utc>::from_utc(timestamp, Utc))
    }
}