ironflow-ops-docker 0.1.5

Docker operations for Ironflow workflows, powered by bollard
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
107
108
109
110
111
112

//! Image cleanup operations: prune.

use std::collections::HashMap;

use async_trait::async_trait;
use bollard::Docker;
use bollard::query_parameters::PruneImagesOptions;
use ironflow_core::error::OperationError;
use ironflow_core::operation::{Operation, OperationContext, TypedOperation};
use serde::{Deserialize, Serialize};
use serde_json::Value;

use crate::containers::DockerRef;
use crate::helpers::{docker_error, to_value};

// ---------------------------------------------------------------------------
// ImagePrune
// ---------------------------------------------------------------------------

/// Output of pruning unused images.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ImagePruneOutput {
    /// Deleted image IDs.
    pub images_deleted: Vec<String>,
    /// Disk space reclaimed in bytes.
    pub space_reclaimed: u64,
}

/// Remove unused images.
///
/// # Examples
///
/// ```no_run
/// use ironflow_ops_docker::images::ImagePrune;
/// use ironflow_ops_docker::DockerClient;
/// use ironflow_core::operation::Operation;
///
/// let client = DockerClient::connect_local().unwrap();
/// let op = ImagePrune::new(&client);
/// assert_eq!(op.kind(), "docker");
/// ```
pub struct ImagePrune {
    docker: Docker,
    filters: HashMap<String, Vec<String>>,
}

impl ImagePrune {
    /// Create a new image-prune operation.
    pub fn new(client: impl Into<DockerRef>) -> Self {
        Self {
            docker: client.into().0,
            filters: HashMap::new(),
        }
    }

    /// Add a filter.
    pub fn filter(mut self, key: impl Into<String>, value: impl Into<String>) -> Self {
        self.filters
            .entry(key.into())
            .or_default()
            .push(value.into());
        self
    }

    /// Execute and return a typed result.
    ///
    /// # Errors
    ///
    /// Returns [`OperationError::External`] if the Docker daemon is
    /// unreachable.
    pub async fn run(&self, _ctx: &OperationContext) -> Result<ImagePruneOutput, OperationError> {
        let options = PruneImagesOptions {
            filters: Some(self.filters.clone()),
        };
        let response = self
            .docker
            .prune_images(Some(options))
            .await
            .map_err(docker_error)?;
        let images_deleted = response
            .images_deleted
            .unwrap_or_default()
            .into_iter()
            .filter_map(|i| i.deleted.or(i.untagged))
            .collect();
        Ok(ImagePruneOutput {
            images_deleted,
            space_reclaimed: response.space_reclaimed.unwrap_or(0) as u64,
        })
    }
}

#[async_trait]
impl Operation for ImagePrune {
    fn kind(&self) -> &str {
        "docker"
    }

    async fn execute(&self, ctx: &OperationContext) -> Result<Value, OperationError> {
        to_value(&self.run(ctx).await?)
    }

    fn input(&self) -> Option<Value> {
        Some(serde_json::json!({
            "operation": "image_prune",
        }))
    }
}

impl TypedOperation for ImagePrune {
    type Output = ImagePruneOutput;
}