docker_pyo3/
volume.rs

1use std::collections::HashMap;
2
3use docker_api::{
4    models::VolumeList200Response,
5    models::VolumePrune200Response,
6    opts::{VolumeCreateOpts, VolumeListOpts, VolumePruneOpts},
7    Volume, Volumes,
8};
9use pyo3::prelude::*;
10
11use crate::Pyo3Docker;
12use pyo3::exceptions;
13use pyo3::types::PyDict;
14use pythonize::pythonize;
15
16#[pymodule]
17pub fn volume(_py: Python<'_>, m: &Bound<'_, PyModule>) -> PyResult<()> {
18    m.add_class::<Pyo3Volumes>()?;
19    m.add_class::<Pyo3Volume>()?;
20    Ok(())
21}
22
23#[derive(Debug)]
24#[pyclass(name = "Volumes")]
25pub struct Pyo3Volumes(pub Volumes);
26
27#[derive(Debug)]
28#[pyclass(name = "Volume")]
29pub struct Pyo3Volume(pub Volume);
30
31#[pymethods]
32impl Pyo3Volumes {
33    #[new]
34    pub fn new(docker: Pyo3Docker) -> Self {
35        Pyo3Volumes(Volumes::new(docker.0))
36    }
37
38    pub fn get(&self, name: &str) -> Pyo3Volume {
39        Pyo3Volume(self.0.get(name))
40    }
41
42    pub fn prune(&self) -> PyResult<Py<PyAny>> {
43        let rv = __volumes_prune(&self.0, &Default::default());
44
45        match rv {
46            Ok(rv) => Ok(pythonize_this!(rv)),
47            Err(rv) => Err(py_sys_exception!(rv)),
48        }
49    }
50
51    pub fn list(&self) -> PyResult<Py<PyAny>> {
52        let rv = __volumes_list(&self.0, &Default::default());
53
54        match rv {
55            Ok(rv) => Ok(pythonize_this!(rv)),
56            Err(rv) => Err(py_sys_exception!(rv)),
57        }
58    }
59
60    #[pyo3(signature = (name=None, driver=None, driver_opts=None, labels=None))]
61    pub fn create(
62        &self,
63        name: Option<&str>,
64        driver: Option<&str>,
65        driver_opts: Option<&Bound<'_, PyDict>>,
66        labels: Option<&Bound<'_, PyDict>>,
67    ) -> PyResult<Py<PyAny>> {
68        let mut opts = VolumeCreateOpts::builder();
69
70        let driver_opts_map: Option<HashMap<String, String>> = if driver_opts.is_some() {
71            Some(driver_opts.unwrap().extract().unwrap())
72        } else {
73            None
74        };
75        let driver_opts: Option<HashMap<&str, &str>> = driver_opts_map
76            .as_ref()
77            .map(|m| m.iter().map(|(k, v)| (k.as_str(), v.as_str())).collect());
78
79        let labels_map: Option<HashMap<String, String>> = if labels.is_some() {
80            Some(labels.unwrap().extract().unwrap())
81        } else {
82            None
83        };
84        let labels: Option<HashMap<&str, &str>> = labels_map
85            .as_ref()
86            .map(|m| m.iter().map(|(k, v)| (k.as_str(), v.as_str())).collect());
87
88        bo_setter!(name, opts);
89        bo_setter!(driver, opts);
90        bo_setter!(driver_opts, opts);
91        bo_setter!(labels, opts);
92
93        let rv = __volumes_create(&self.0, &opts.build());
94
95        match rv {
96            Ok(rv) => Ok(pythonize_this!(rv)),
97            Err(rv) => Err(py_sys_exception!(rv)),
98        }
99    }
100}
101
102#[tokio::main]
103async fn __volumes_prune(
104    volumes: &Volumes,
105    opts: &VolumePruneOpts,
106) -> Result<VolumePrune200Response, docker_api::Error> {
107    volumes.prune(opts).await
108}
109
110#[tokio::main]
111async fn __volumes_list(
112    volumes: &Volumes,
113    opts: &VolumeListOpts,
114) -> Result<VolumeList200Response, docker_api::Error> {
115    volumes.list(opts).await
116}
117
118#[tokio::main]
119async fn __volumes_create(
120    volumes: &Volumes,
121    opts: &VolumeCreateOpts,
122) -> Result<docker_api::models::Volume, docker_api::Error> {
123    volumes.create(opts).await
124}
125
126#[pymethods]
127impl Pyo3Volume {
128    #[new]
129    pub fn new(docker: Pyo3Docker, name: &str) -> Self {
130        Pyo3Volume(Volume::new(docker.0, name))
131    }
132
133    pub fn name(&self) -> String {
134        self.0.name().to_string()
135    }
136
137    pub fn inspect(&self) -> PyResult<Py<PyAny>> {
138        let rv = __volume_inspect(&self.0);
139
140        match rv {
141            Ok(rv) => Ok(pythonize_this!(rv)),
142            Err(rv) => Err(py_sys_exception!(rv)),
143        }
144    }
145
146    pub fn delete(&self) -> PyResult<()> {
147        let rv = __volume_delete(&self.0);
148
149        match rv {
150            Ok(rv) => Ok(rv),
151            Err(rv) => Err(py_sys_exception!(rv)),
152        }
153    }
154}
155
156#[tokio::main]
157async fn __volume_inspect(
158    volume: &Volume,
159) -> Result<docker_api::models::Volume, docker_api::Error> {
160    volume.inspect().await
161}
162
163#[tokio::main]
164async fn __volume_delete(volume: &Volume) -> Result<(), docker_api::Error> {
165    volume.delete().await
166}
docker_pyo3/volume.rs

docker_pyo3/
volume.rs
