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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227

use serde::{Deserialize, Serialize};
use std::collections::HashMap;

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
#[serde(deny_unknown_fields)]
pub struct GetInfoResponse {
    pub host: Option<HostInfo>,
    pub plugins: Option<Plugins>,
    pub registries: Option<HashMap<String, Vec<String>>>,
    pub store: Option<StoreInfo>,
    pub version: Option<Version>,
}

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
#[serde(deny_unknown_fields)]
#[serde(rename_all = "camelCase")]
pub struct HostInfo {
    pub arch: Option<String>,
    pub buildah_version: Option<String>,
    pub cgroup_controllers: Option<Vec<String>>,
    pub cgroup_manager: Option<String>,
    pub cgroup_version: Option<String>,
    pub conmon: Option<ConmonInfo>,
    pub cpus: Option<i64>,
    pub cpu_utilization: Option<CpuUsage>,
    pub database_backend: Option<String>,
    pub distribution: Option<DistributionInfo>,
    pub event_logger: Option<String>,
    pub hostname: Option<String>,
    pub id_mappings: Option<IdMappings>,
    pub kernel: Option<String>,
    pub linkmode: Option<String>,
    pub log_driver: Option<String>,
    pub mem_free: Option<i64>,
    pub mem_total: Option<i64>,
    pub network_backend: Option<String>,
    pub oci_runtime: Option<OciRuntime>,
    pub os: Option<String>,
    pub remote_socket: Option<RemoteSocket>,
    pub runtime_info: Option<HashMap<String, String>>,
    pub security: Option<SecurityInfo>,
    pub service_is_remote: Option<bool>,
    pub slirp4netns: Option<SlirpInfo>,
    pub swap_free: Option<i64>,
    pub swap_total: Option<i64>,
    pub uptime: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
#[serde(deny_unknown_fields)]
pub struct ConmonInfo {
    pub package: Option<String>,
    pub path: Option<String>,
    pub version: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
#[serde(deny_unknown_fields)]
#[serde(rename_all = "camelCase")]
pub struct CpuUsage {
    pub idle_percent: Option<f32>,
    pub system_percent: Option<f32>,
    pub user_percent: Option<f32>,
}

#[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
#[serde(deny_unknown_fields)]
pub struct DistributionInfo {
    pub codename: Option<String>,
    pub distribution: Option<String>,
    pub variant: Option<String>,
    pub version: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
#[serde(deny_unknown_fields)]
pub struct IdMappings {
    pub gidmap: Option<Vec<IdMap>>,
    pub uidmap: Option<Vec<IdMap>>,
}

#[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
#[serde(deny_unknown_fields)]
pub struct IdMap {
    pub container_id: Option<i64>,
    pub host_id: Option<i64>,
    pub size: Option<i64>,
}

#[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
#[serde(deny_unknown_fields)]
pub struct OciRuntime {
    pub name: Option<String>,
    pub package: Option<String>,
    pub path: Option<String>,
    pub version: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
#[serde(deny_unknown_fields)]
pub struct RemoteSocket {
    #[serde(default = "RemoteSocket::default_exists")]
    pub exists: bool,
    pub path: Option<String>,
}
impl RemoteSocket {
    fn default_exists() -> bool {
        false
    }
}

#[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
#[serde(deny_unknown_fields)]
#[serde(rename_all = "camelCase")]
pub struct SecurityInfo {
    pub apparmor_enabled: Option<bool>,
    pub capabilities: Option<String>,
    pub rootless: Option<bool>,
    pub seccomp_enabled: Option<bool>,
    pub seccomp_profile_path: Option<String>,
    pub selinux_enabled: Option<bool>,
}

#[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
#[serde(deny_unknown_fields)]
pub struct SlirpInfo {
    pub executable: Option<String>,
    pub package: Option<String>,
    pub version: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
#[serde(deny_unknown_fields)]
pub struct Plugins {
    pub authorization: Option<Vec<String>>,
    pub log: Option<Vec<String>>,
    pub network: Option<Vec<String>>,
    pub volume: Option<Vec<String>>,
}

#[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
#[serde(deny_unknown_fields)]
#[serde(rename_all = "camelCase")]
pub struct StoreInfo {
    pub config_file: Option<String>,
    pub container_store: Option<ContainerStore>,
    pub graph_driver_name: Option<String>,
    pub graph_options: Option<HashMap<String, GraphOptionsEntry>>,
    pub graph_root: Option<String>,
    pub graph_root_allocated: Option<u64>,
    pub graph_root_used: Option<u64>,
    pub graph_status: Option<HashMap<String, String>>,
    pub image_copy_tmp_dir: Option<String>,
    pub image_store: Option<ImageStore>,
    pub run_root: Option<String>,
    pub transient_store: Option<bool>,
    pub volume_path: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
#[serde(deny_unknown_fields)]
pub struct ContainerStore {
    pub number: Option<i64>,
    pub paused: Option<i64>,
    pub running: Option<i64>,
    pub stopped: Option<i64>,
}

#[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
#[serde(deny_unknown_fields)]
pub struct ImageStore {
    pub number: Option<i64>,
}

#[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
#[serde(deny_unknown_fields)]
#[serde(rename_all = "PascalCase")]
pub struct Version {
    #[serde(rename = "APIVersion")]
    pub api_version: Option<String>,
    pub built: Option<i64>,
    pub built_time: Option<String>,
    pub git_commit: Option<String>,
    pub go_version: Option<String>,
    pub os: Option<String>,
    pub os_arch: Option<String>,
    pub version: Option<String>,
}

// Info taken from https://github.com/containers/podman/blob/69085570f7ebbb3768e963e2a6a31d7bb9b4ca16/libpod/info.go#L265-L281
#[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
#[serde(deny_unknown_fields)]
#[serde(rename_all = "PascalCase")]
pub struct GraphOptionsEntry {
    pub executable: Option<String>,
    pub package: Option<String>,
    pub version: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
#[serde(deny_unknown_fields)]
pub struct Event {
    pub status: Option<String>,
    pub id: Option<String>,
    pub from: Option<String>,
    #[serde(rename = "Type")]
    pub event_type: Option<String>,
    #[serde(rename = "Action")]
    pub action: Option<String>,
    #[serde(rename = "Actor")]
    pub actor: EventActor,
    pub scope: Option<String>,
    pub time: Option<u64>,
    #[serde(rename = "timeNano")]
    pub time_nano: Option<u64>,
    #[serde(rename = "HealthStatus")]
    pub health_status: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
#[serde(deny_unknown_fields)]
pub struct EventActor {
    #[serde(rename = "ID")]
    pub id: Option<String>,
    #[serde(rename = "Attributes")]
    pub attributes: Option<HashMap<String, String>>,
}