boxferry-podman 0.2.0

Podman inspection decoding for BoxFerry runtime reconstruction
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
113
114
115
116
117
118
119
120
121
122
123
124

//! Explicit, sensitive-by-default Podman inspect inputs.

use std::fmt;

use boxferry_engine::PlatformVersion;
use boxferry_model::Identifier;

/// Complete set of JSON arrays used for one Podman runtime snapshot.
///
/// Each document must contain the unmodified JSON array emitted for one corresponding inspect
/// resource family. Empty families are represented by `[]`, not by an omitted ambient lookup.
#[derive(Clone, Eq, PartialEq)]
pub struct PodmanInspectDocuments {
    containers: String,
    images: String,
    networks: String,
    volumes: String,
    pods: String,
}

impl PodmanInspectDocuments {
    /// Creates an explicit document set without parsing or accessing Podman.
    #[must_use]
    pub fn new(
        containers: impl Into<String>,
        images: impl Into<String>,
        networks: impl Into<String>,
        volumes: impl Into<String>,
        pods: impl Into<String>,
    ) -> Self {
        Self {
            containers: containers.into(),
            images: images.into(),
            networks: networks.into(),
            volumes: volumes.into(),
            pods: pods.into(),
        }
    }

    /// Returns the container-inspect JSON array.
    #[must_use]
    pub fn containers(&self) -> &str {
        &self.containers
    }

    /// Returns the image-inspect JSON array.
    #[must_use]
    pub fn images(&self) -> &str {
        &self.images
    }

    /// Returns the network-inspect JSON array.
    #[must_use]
    pub fn networks(&self) -> &str {
        &self.networks
    }

    /// Returns the volume-inspect JSON array.
    #[must_use]
    pub fn volumes(&self) -> &str {
        &self.volumes
    }

    /// Returns the pod-inspect JSON array.
    #[must_use]
    pub fn pods(&self) -> &str {
        &self.pods
    }
}

impl fmt::Debug for PodmanInspectDocuments {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        formatter
            .debug_struct("PodmanInspectDocuments")
            .field("containers", &"[REDACTED]")
            .field("images", &"[REDACTED]")
            .field("networks", &"[REDACTED]")
            .field("volumes", &"[REDACTED]")
            .field("pods", &"[REDACTED]")
            .finish()
    }
}

/// Caller-selected application identity, producing Podman version, and inspect documents.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct PodmanInspectSource {
    application_name: Identifier,
    version: PlatformVersion,
    documents: PodmanInspectDocuments,
}

impl PodmanInspectSource {
    /// Creates a deterministic Podman inspect source.
    #[must_use]
    pub const fn new(
        application_name: Identifier,
        version: PlatformVersion,
        documents: PodmanInspectDocuments,
    ) -> Self {
        Self {
            application_name,
            version,
            documents,
        }
    }

    /// Returns the neutral application name selected by the caller.
    #[must_use]
    pub const fn application_name(&self) -> &Identifier {
        &self.application_name
    }

    /// Returns the exact Podman version that produced these documents.
    #[must_use]
    pub const fn version(&self) -> PlatformVersion {
        self.version
    }

    /// Returns the explicit inspect document set.
    #[must_use]
    pub const fn documents(&self) -> &PodmanInspectDocuments {
        &self.documents
    }
}