297 lines
9.8 KiB
Rust
297 lines
9.8 KiB
Rust
use std::io::Read;
|
|
|
|
use anyhow::Error;
|
|
use bitflags::bitflags;
|
|
|
|
/// The number of data entries per RRA
|
|
pub const RRD_DATA_ENTRIES: usize = 70;
|
|
|
|
/// Proxmox RRD file magic number
|
|
// openssl::sha::sha256(b"Proxmox Round Robin Database file v1.0")[0..8];
|
|
pub const PROXMOX_RRD_MAGIC_1_0: [u8; 8] = [206, 46, 26, 212, 172, 158, 5, 186];
|
|
|
|
use crate::rrd::{RRD, RRA, CF, DST, DataSource};
|
|
|
|
bitflags!{
|
|
/// Flags to specify the data soure type and consolidation function
|
|
pub struct RRAFlags: u64 {
|
|
// Data Source Types
|
|
const DST_GAUGE = 1;
|
|
const DST_DERIVE = 2;
|
|
const DST_COUNTER = 4;
|
|
const DST_MASK = 255; // first 8 bits
|
|
|
|
// Consolidation Functions
|
|
const CF_AVERAGE = 1 << 8;
|
|
const CF_MAX = 2 << 8;
|
|
const CF_MASK = 255 << 8;
|
|
}
|
|
}
|
|
|
|
/// Round Robin Archive with [RRD_DATA_ENTRIES] data slots.
|
|
///
|
|
/// This data structure is used inside [RRD] and directly written to the
|
|
/// RRD files.
|
|
#[repr(C)]
|
|
pub struct RRAv1 {
|
|
/// Defined the data soure type and consolidation function
|
|
pub flags: RRAFlags,
|
|
/// Resulution (seconds)
|
|
pub resolution: u64,
|
|
/// Last update time (epoch)
|
|
pub last_update: f64,
|
|
/// Count values computed inside this update interval
|
|
pub last_count: u64,
|
|
/// Stores the last value, used to compute differential value for derive/counters
|
|
pub counter_value: f64,
|
|
/// Data slots
|
|
pub data: [f64; RRD_DATA_ENTRIES],
|
|
}
|
|
|
|
impl RRAv1 {
|
|
|
|
fn extract_data(
|
|
&self,
|
|
) -> (u64, u64, Vec<Option<f64>>) {
|
|
let reso = self.resolution;
|
|
|
|
let mut list = Vec::new();
|
|
|
|
let rra_end = reso*((self.last_update as u64)/reso);
|
|
let rra_start = rra_end - reso*(RRD_DATA_ENTRIES as u64);
|
|
|
|
let mut t = rra_start;
|
|
let mut index = ((t/reso) % (RRD_DATA_ENTRIES as u64)) as usize;
|
|
for _ in 0..RRD_DATA_ENTRIES {
|
|
let value = self.data[index];
|
|
if value.is_nan() {
|
|
list.push(None);
|
|
} else {
|
|
list.push(Some(value));
|
|
}
|
|
|
|
t += reso; index = (index + 1) % RRD_DATA_ENTRIES;
|
|
}
|
|
|
|
(rra_start, reso, list)
|
|
}
|
|
}
|
|
|
|
/// Round Robin Database file format with fixed number of [RRA]s
|
|
#[repr(C)]
|
|
// Note: Avoid alignment problems by using 8byte types only
|
|
pub struct RRDv1 {
|
|
/// The magic number to identify the file type
|
|
pub magic: [u8; 8],
|
|
/// Hourly data (average values)
|
|
pub hour_avg: RRAv1,
|
|
/// Hourly data (maximum values)
|
|
pub hour_max: RRAv1,
|
|
/// Dayly data (average values)
|
|
pub day_avg: RRAv1,
|
|
/// Dayly data (maximum values)
|
|
pub day_max: RRAv1,
|
|
/// Weekly data (average values)
|
|
pub week_avg: RRAv1,
|
|
/// Weekly data (maximum values)
|
|
pub week_max: RRAv1,
|
|
/// Monthly data (average values)
|
|
pub month_avg: RRAv1,
|
|
/// Monthly data (maximum values)
|
|
pub month_max: RRAv1,
|
|
/// Yearly data (average values)
|
|
pub year_avg: RRAv1,
|
|
/// Yearly data (maximum values)
|
|
pub year_max: RRAv1,
|
|
}
|
|
|
|
impl RRDv1 {
|
|
|
|
pub fn from_raw(mut raw: &[u8]) -> Result<Self, std::io::Error> {
|
|
|
|
let expected_len = std::mem::size_of::<RRDv1>();
|
|
|
|
if raw.len() != expected_len {
|
|
let msg = format!("wrong data size ({} != {})", raw.len(), expected_len);
|
|
return Err(std::io::Error::new(std::io::ErrorKind::Other, msg));
|
|
}
|
|
|
|
let mut rrd: RRDv1 = unsafe { std::mem::zeroed() };
|
|
unsafe {
|
|
let rrd_slice = std::slice::from_raw_parts_mut(&mut rrd as *mut _ as *mut u8, expected_len);
|
|
raw.read_exact(rrd_slice)?;
|
|
}
|
|
|
|
if rrd.magic != PROXMOX_RRD_MAGIC_1_0 {
|
|
let msg = "wrong magic number".to_string();
|
|
return Err(std::io::Error::new(std::io::ErrorKind::Other, msg));
|
|
}
|
|
|
|
Ok(rrd)
|
|
}
|
|
|
|
pub fn to_rrd_v2(&self) -> Result<RRD, Error> {
|
|
|
|
let mut rra_list = Vec::new();
|
|
|
|
// old format v1:
|
|
//
|
|
// hour 1 min, 70 points
|
|
// day 30 min, 70 points
|
|
// week 3 hours, 70 points
|
|
// month 12 hours, 70 points
|
|
// year 1 week, 70 points
|
|
//
|
|
// new default for RRD v2:
|
|
//
|
|
// day 1 min, 1440 points
|
|
// month 30 min, 1440 points
|
|
// year 365 min (6h), 1440 points
|
|
// decade 1 week, 570 points
|
|
|
|
// Linear extrapolation
|
|
fn extrapolate_data(start: u64, reso: u64, factor: u64, data: Vec<Option<f64>>) -> (u64, u64, Vec<Option<f64>>) {
|
|
|
|
let mut new = Vec::new();
|
|
|
|
for i in 0..data.len() {
|
|
let mut next = i + 1;
|
|
if next >= data.len() { next = 0 };
|
|
let v = data[i];
|
|
let v1 = data[next];
|
|
match (v, v1) {
|
|
(Some(v), Some(v1)) => {
|
|
let diff = (v1 - v)/(factor as f64);
|
|
for j in 0..factor {
|
|
new.push(Some(v + diff*(j as f64)));
|
|
}
|
|
}
|
|
(Some(v), None) => {
|
|
new.push(Some(v));
|
|
for _ in 0..factor-1 {
|
|
new.push(None);
|
|
}
|
|
}
|
|
(None, Some(v1)) => {
|
|
for _ in 0..factor-1 {
|
|
new.push(None);
|
|
}
|
|
new.push(Some(v1));
|
|
}
|
|
(None, None) => {
|
|
for _ in 0..factor {
|
|
new.push(None);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
(start, reso/factor, new)
|
|
}
|
|
|
|
// Try to convert to new, higher capacity format
|
|
|
|
// compute daily average (merge old self.day_avg and self.hour_avg
|
|
let mut day_avg = RRA::new(CF::Average, 60, 1440);
|
|
|
|
let (start, reso, data) = self.day_avg.extract_data();
|
|
let (start, reso, data) = extrapolate_data(start, reso, 30, data);
|
|
day_avg.insert_data(start, reso, data)?;
|
|
|
|
let (start, reso, data) = self.hour_avg.extract_data();
|
|
day_avg.insert_data(start, reso, data)?;
|
|
|
|
// compute daily maximum (merge old self.day_max and self.hour_max
|
|
let mut day_max = RRA::new(CF::Maximum, 60, 1440);
|
|
|
|
let (start, reso, data) = self.day_max.extract_data();
|
|
let (start, reso, data) = extrapolate_data(start, reso, 30, data);
|
|
day_max.insert_data(start, reso, data)?;
|
|
|
|
let (start, reso, data) = self.hour_max.extract_data();
|
|
day_max.insert_data(start, reso, data)?;
|
|
|
|
// compute montly average (merge old self.month_avg,
|
|
// self.week_avg and self.day_avg)
|
|
let mut month_avg = RRA::new(CF::Average, 30*60, 1440);
|
|
|
|
let (start, reso, data) = self.month_avg.extract_data();
|
|
let (start, reso, data) = extrapolate_data(start, reso, 24, data);
|
|
month_avg.insert_data(start, reso, data)?;
|
|
|
|
let (start, reso, data) = self.week_avg.extract_data();
|
|
let (start, reso, data) = extrapolate_data(start, reso, 6, data);
|
|
month_avg.insert_data(start, reso, data)?;
|
|
|
|
let (start, reso, data) = self.day_avg.extract_data();
|
|
month_avg.insert_data(start, reso, data)?;
|
|
|
|
// compute montly maximum (merge old self.month_max,
|
|
// self.week_max and self.day_max)
|
|
let mut month_max = RRA::new(CF::Maximum, 30*60, 1440);
|
|
|
|
let (start, reso, data) = self.month_max.extract_data();
|
|
let (start, reso, data) = extrapolate_data(start, reso, 24, data);
|
|
month_max.insert_data(start, reso, data)?;
|
|
|
|
let (start, reso, data) = self.week_max.extract_data();
|
|
let (start, reso, data) = extrapolate_data(start, reso, 6, data);
|
|
month_max.insert_data(start, reso, data)?;
|
|
|
|
let (start, reso, data) = self.day_max.extract_data();
|
|
month_max.insert_data(start, reso, data)?;
|
|
|
|
// compute yearly average (merge old self.year_avg)
|
|
let mut year_avg = RRA::new(CF::Average, 6*3600, 1440);
|
|
|
|
let (start, reso, data) = self.year_avg.extract_data();
|
|
let (start, reso, data) = extrapolate_data(start, reso, 28, data);
|
|
year_avg.insert_data(start, reso, data)?;
|
|
|
|
// compute yearly maximum (merge old self.year_avg)
|
|
let mut year_max = RRA::new(CF::Maximum, 6*3600, 1440);
|
|
|
|
let (start, reso, data) = self.year_max.extract_data();
|
|
let (start, reso, data) = extrapolate_data(start, reso, 28, data);
|
|
year_max.insert_data(start, reso, data)?;
|
|
|
|
// compute decade average (merge old self.year_avg)
|
|
let mut decade_avg = RRA::new(CF::Average, 7*86400, 570);
|
|
let (start, reso, data) = self.year_avg.extract_data();
|
|
decade_avg.insert_data(start, reso, data)?;
|
|
|
|
// compute decade maximum (merge old self.year_max)
|
|
let mut decade_max = RRA::new(CF::Maximum, 7*86400, 570);
|
|
let (start, reso, data) = self.year_max.extract_data();
|
|
decade_max.insert_data(start, reso, data)?;
|
|
|
|
rra_list.push(day_avg);
|
|
rra_list.push(day_max);
|
|
rra_list.push(month_avg);
|
|
rra_list.push(month_max);
|
|
rra_list.push(year_avg);
|
|
rra_list.push(year_max);
|
|
rra_list.push(decade_avg);
|
|
rra_list.push(decade_max);
|
|
|
|
// use values from hour_avg for source (all RRAv1 must have the same config)
|
|
let dst = if self.hour_avg.flags.contains(RRAFlags::DST_COUNTER) {
|
|
DST::Counter
|
|
} else if self.hour_avg.flags.contains(RRAFlags::DST_DERIVE) {
|
|
DST::Derive
|
|
} else {
|
|
DST::Gauge
|
|
};
|
|
|
|
let source = DataSource {
|
|
dst,
|
|
last_value: f64::NAN,
|
|
last_update: self.hour_avg.last_update, // IMPORTANT!
|
|
};
|
|
Ok(RRD {
|
|
source,
|
|
rra_list,
|
|
})
|
|
}
|
|
}
|