podtender 0.5.0

A rust client for the podman API.
Documentation 
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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

use crate::error::Result;
use crate::podman_service::PodmanService;
use crate::utils;
use crate::volumes::parameter_types::*;
use crate::volumes::response_types::{
    CreateVolumeResponse, InspectVolumeResponse, ListVolumesResponseEntry,
    PruneVolumesResponseEntry,
};
use std::convert::TryInto;
#[cfg(feature = "enable-tracing")]
use tracing::instrument;

/// Volumes operations.
#[derive(Debug)]
pub struct Volumes<'service> {
    podman_service: &'service PodmanService,
}

impl<'service> Volumes<'service> {
    pub(crate) fn new(podman_service: &'service PodmanService) -> Self {
        Volumes { podman_service }
    }

    /// <https://docs.podman.io/en/latest/_static/api.html?version=v4.0#operation/VolumeCreateLibpod>
    #[cfg_attr(feature = "enable-tracing", instrument(name = "Volumes.create"))]
    pub async fn create(&self, parameter: CreateVolumeParameter) -> Result<CreateVolumeResponse> {
        let endpoint = utils::create_endpoint("/libpod/volumes/create");
        let body = serde_json::to_string(&parameter)?;
        let service_response = self
            .podman_service
            .post_request(&endpoint, None, None, Some(body))
            .await?;
        utils::deserialize_service_response(service_response)
    }

    /// <https://docs.podman.io/en/latest/_static/api.html?version=v4.0#operation/VolumeDeleteLibpod>
    #[cfg_attr(feature = "enable-tracing", instrument(name = "Volumes.remove"))]
    pub async fn remove(&self, parameter: RemoveVolumeParameter) -> Result<()> {
        let endpoint =
            utils::create_endpoint(&format!("/libpod/volumes/{}", parameter.volume_name));
        let query = serde_qs::to_string(&parameter)?;
        let service_response = self
            .podman_service
            .delete_request(&endpoint, Some(query), None, None)
            .await?;
        utils::check_service_response_for_error(service_response)
    }

    /// <https://docs.podman.io/en/latest/_static/api.html?version=v4.0#operation/VolumeExistsLibpod>
    #[cfg_attr(feature = "enable-tracing", instrument(name = "Volumes.exists"))]
    pub async fn exists(&self, param: VolumeExistsParameter) -> Result<()> {
        let endpoint =
            utils::create_endpoint(&format!("/libpod/volumes/{}/exists", param.volume_name));
        let service_response = self
            .podman_service
            .get_request(&endpoint, None, None, None)
            .await?;
        utils::check_service_response_for_error(service_response)
    }

    /// <https://docs.podman.io/en/latest/_static/api.html?version=v4.0#operation/VolumeCreateLibpod>
    #[cfg_attr(feature = "enable-tracing", instrument(name = "Volumes.inspect"))]
    pub async fn inspect(&self, param: InspectVolumeParameter) -> Result<InspectVolumeResponse> {
        let endpoint =
            utils::create_endpoint(&format!("/libpod/volumes/{}/json", param.volume_name));
        let service_response = self
            .podman_service
            .get_request(&endpoint, None, None, None)
            .await?;
        utils::deserialize_service_response(service_response)
    }

    /// <https://docs.podman.io/en/latest/_static/api.html?version=v4.0#operation/VolumeListLibpod>
    #[cfg_attr(feature = "enable-tracing", instrument(name = "Volumes.list"))]
    pub async fn list(
        &self,
        parameter: ListVolumesParameter,
    ) -> Result<Vec<ListVolumesResponseEntry>> {
        let parameter: ListVolumesParameterQuery = parameter.try_into()?;
        let endpoint = utils::create_endpoint("/libpod/volumes/json");

        let query = serde_qs::to_string(&parameter)?;
        let service_response = self
            .podman_service
            .get_request(&endpoint, Some(query), None, None)
            .await?;
        utils::deserialize_service_response(service_response)
    }

    /// <https://docs.podman.io/en/latest/_static/api.html?version=v4.0#operation/VolumePruneLibpod>
    #[cfg_attr(feature = "enable-tracing", instrument(name = "Volumes.prune"))]
    pub async fn prune(
        &self,
        parameter: PruneVolumesParameter,
    ) -> Result<Vec<PruneVolumesResponseEntry>> {
        let parameter: PruneVolumesParameterQuery = parameter.try_into()?;
        let endpoint = utils::create_endpoint("/libpod/volumes/prune");

        let query = serde_qs::to_string(&parameter)?;
        let service_response = self
            .podman_service
            .post_request(&endpoint, Some(query), None, None)
            .await?;
        utils::deserialize_service_response(service_response)
    }
}