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
|
use chrono::prelude::*;
use git_testament::{git_testament, render_testament};
use serde::Serialize;
git_testament!(TESTAMENT);
#[derive(Debug, Serialize)]
pub struct SuiteMeasurements {
measurements: Vec<OpMeasurements>,
obnam_version: String,
obnam_benchmark_version: String,
benchmark_started: String,
hostname: String,
host_cpus: usize,
host_ram: u64,
}
#[derive(Debug, Serialize)]
pub struct OpMeasurements {
benchmark: String,
op: Operation,
measurements: Vec<Measurement>,
}
#[derive(Debug, Serialize)]
pub enum Measurement {
TotalFiles(u64),
TotalData(u64),
DurationMs(u128),
}
#[derive(Debug, Clone, Copy, Serialize)]
pub enum Operation {
Start,
Stop,
Create,
Rename,
Delete,
Backup,
Restore,
ManifestLive,
ManifestRestored,
CompareManiests,
}
#[derive(Debug, thiserror::Error)]
pub enum SuiteMeasurementsError {
#[error("failed to get CPU info: {0}")]
CpuInfo(procfs::ProcError),
#[error("failed to get RAM info: {0}")]
MemInfo(procfs::ProcError),
#[error("failed to get hostname: {0}")]
Hostname(nix::Error),
}
impl SuiteMeasurements {
pub fn new(obnam_version: String) -> Result<Self, SuiteMeasurementsError> {
let cpu = procfs::CpuInfo::new().map_err(SuiteMeasurementsError::CpuInfo)?;
let mem = procfs::Meminfo::new().map_err(SuiteMeasurementsError::MemInfo)?;
let mut buf = [0u8; 1024];
let hostname =
nix::unistd::gethostname(&mut buf).map_err(SuiteMeasurementsError::Hostname)?;
let hostname = hostname.to_string_lossy();
Ok(Self {
measurements: vec![],
obnam_version,
obnam_benchmark_version: render_testament!(TESTAMENT),
benchmark_started: Utc::now().to_string(),
hostname: hostname.to_string(),
host_ram: mem.mem_total,
host_cpus: cpu.num_cores(),
})
}
pub fn push(&mut self, m: OpMeasurements) {
self.measurements.push(m);
}
}
impl OpMeasurements {
pub fn new(benchmark: &str, op: Operation) -> Self {
let benchmark = benchmark.to_string();
Self {
benchmark,
op,
measurements: vec![],
}
}
pub fn push(&mut self, m: Measurement) {
self.measurements.push(m);
}
}
|
