containerization-framework 0.8.0

Rust bindings for Apple's Containerization framework: Linux containers in lightweight VMs, in-process and without a daemon.
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

//! `ContainerStatistics`, and the statistics nested in it.

/// `ContainerStatistics`. [`super::LinuxContainer::statistics`] makes it, and
/// leaves each category it wasn't asked for as `None`.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct ContainerStatistics {
  pub id: String,
  pub process: Option<ProcessStatistics>,
  pub memory: Option<MemoryStatistics>,
  pub cpu: Option<CPUStatistics>,
  pub block_io: Option<BlockIOStatistics>,
  pub networks: Option<Vec<NetworkStatistics>>,
  pub memory_events: Option<MemoryEventStatistics>,
  pub filesystem: Option<Vec<FilesystemStatistics>>,
  /// Per-protocol traffic for the network namespace, which the network
  /// category reports. `None` if the guest doesn't report it.
  pub protocols: Option<NetworkProtocolStatistics>,
}

/// `ContainerStatistics.ProcessStatistics`.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct ProcessStatistics {
  pub current: u64,
  pub limit: u64,
}

/// `ContainerStatistics.MemoryStatistics`.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct MemoryStatistics {
  pub usage_bytes: u64,
  pub limit_bytes: u64,
  pub swap_usage_bytes: u64,
  pub swap_limit_bytes: u64,
  pub cache_bytes: u64,
  pub kernel_stack_bytes: u64,
  pub slab_bytes: u64,
  pub page_faults: u64,
  pub major_page_faults: u64,
  pub inactive_file: u64,
  pub anon: u64,
  pub workingset_refault_anon: u64,
  pub workingset_refault_file: u64,
  pub pgsteal_kswapd: u64,
  pub pgsteal_direct: u64,
  pub pgsteal_khugepaged: u64,
}

/// `ContainerStatistics.CPUStatistics`.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct CPUStatistics {
  pub usage_usec: u64,
  pub user_usec: u64,
  pub system_usec: u64,
  pub throttling_periods: u64,
  pub throttled_periods: u64,
  pub throttled_time_usec: u64,
}

/// `ContainerStatistics.BlockIOStatistics`.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct BlockIOStatistics {
  pub devices: Vec<BlockIODevice>,
}

/// `ContainerStatistics.BlockIODevice`.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct BlockIODevice {
  pub major: u64,
  pub minor: u64,
  pub read_bytes: u64,
  pub write_bytes: u64,
  pub read_operations: u64,
  pub write_operations: u64,
}

/// `ContainerStatistics.NetworkStatistics`.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct NetworkStatistics {
  pub interface: String,
  pub received_packets: u64,
  pub transmitted_packets: u64,
  pub received_bytes: u64,
  pub transmitted_bytes: u64,
  pub received_errors: u64,
  pub transmitted_errors: u64,
  /// Packets the device dropped, for example because its receive ring or
  /// transmit queue was full.
  pub received_dropped: u64,
  pub transmitted_dropped: u64,
}

/// `ContainerStatistics.NetworkProtocolCounters`, the packet and byte counters
/// for one protocol. [`Default`] is Swift's initializer with every counter
/// left at zero.
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct NetworkProtocolCounters {
  pub received_packets: u64,
  pub transmitted_packets: u64,
  /// Zero when the protocol has no byte counter. Linux only has one for IP
  /// as a whole.
  pub received_bytes: u64,
  pub transmitted_bytes: u64,
  /// Packets the stack discarded for lack of resources or a destination. The
  /// kernel attributes drops to different causes for each protocol, so they
  /// can be compared over time for one protocol but not across protocols.
  /// Zero when the kernel has no matching counter, which doesn't mean that
  /// none happened.
  pub received_drops: u64,
  pub transmitted_drops: u64,
  /// Packets that were malformed or failed processing. As with drops, the
  /// causes differ for each protocol.
  pub received_errors: u64,
  pub transmitted_errors: u64,
}

/// `ContainerStatistics.NetworkProtocolStatistics`, the per-protocol traffic
/// for a container's network namespace. It covers the whole namespace,
/// including loopback, not one interface, so containers that share a
/// namespace report the same values.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct NetworkProtocolStatistics {
  pub tcp: NetworkProtocolCounters,
  pub udp: NetworkProtocolCounters,
  pub icmp: NetworkProtocolCounters,
  /// All IP traffic, including what TCP, UDP and ICMP don't count, such as
  /// raw IP.
  pub ip: NetworkProtocolCounters,
}

/// `ContainerStatistics.MemoryEventStatistics`, the counters in cgroup2's
/// `memory.events`.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct MemoryEventStatistics {
  pub low: u64,
  pub high: u64,
  pub max: u64,
  pub oom: u64,
  pub oom_kill: u64,
}

/// `ContainerStatistics.FilesystemStatistics`, the `statfs(2)` figures for
/// one mount.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct FilesystemStatistics {
  pub mount_point: String,
  pub block_size: u64,
  pub blocks: u64,
  pub free_blocks: u64,
  pub inodes: u64,
  pub free_inodes: u64,
}