about summary refs log tree commit diff
path: root/src/gatherer.rs
diff options
context:
space:
mode:
Diffstat (limited to 'src/gatherer.rs')
-rw-r--r--src/gatherer.rs72
1 files changed, 60 insertions, 12 deletions
diff --git a/src/gatherer.rs b/src/gatherer.rs
index 9b2a80a..163d84b 100644
--- a/src/gatherer.rs
+++ b/src/gatherer.rs
@@ -1,4 +1,5 @@
 use std::{
+	array,
 	fs::File,
 	io::{BufRead, BufReader},
 	sync::{atomic::Ordering, mpsc::Sender},
@@ -9,7 +10,7 @@ use std::{
 use regex_lite::Regex;
 use time::OffsetDateTime;
 
-use crate::{griph, AwakeState};
+use crate::{db::DbMeminfo, griph, AwakeState};
 
 pub struct Gatherer {
 	state: AwakeState,
@@ -97,7 +98,13 @@ pub fn make_mem_graph(state: &AwakeState) {
 
 	let infos = state.database.get_last_n_host_meminfo(256);
 	let max = infos[0].total_kb;
-	let mut usages: Vec<usize> = infos.into_iter().map(|mi| mi.usage()).collect();
+
+	let now = OffsetDateTime::now_utc();
+	let cleaned = clean_series(&infos, |mem| mem.stamp, now);
+	let mut usages: Vec<Option<usize>> = cleaned
+		.into_iter()
+		.map(|mi| mi.map(|mi| mi.usage()))
+		.collect();
 
 	// Reversing here because we want latest valeus on on the
 	// right side, so last in the array
@@ -112,25 +119,32 @@ pub fn make_mem_graph(state: &AwakeState) {
 pub fn make_net_graph(state: &AwakeState) {
 	tracing::debug!("generating netinfo graph");
 
+	let now = OffsetDateTime::now_utc();
 	let infos = state.database.get_last_n_hostnet(256);
+	let cleaned = clean_series(&infos, |net| net.stamp, now);
+
 	// 125 is (1000 / 8) so it converst Bytes to kiloBITS
-	let mut rx_deltas: Vec<usize> = infos
-		.iter()
-		.map(|ni| ni.rx_bytes_per_sec() as usize / 124)
-		.collect();
-	let mut tx_deltas: Vec<usize> = infos
-		.iter()
-		.map(|ni| ni.tx_bytes_per_sec() as usize / 125)
-		.collect();
+	let mut rx_deltas = extract(&cleaned, |ni| ni.rx_bytes_per_sec() as usize / 125);
+	let mut tx_deltas = extract(&cleaned, |ni| ni.tx_bytes_per_sec() as usize / 125);
 
 	// Reversing to put latest values on the right side
 	rx_deltas.reverse();
 	tx_deltas.reverse();
 
+	let rx_zeroed: Vec<usize> = cleaned
+		.iter()
+		.map(|m| m.map(|n| n.rx_bytes_per_sec() as usize / 125).unwrap_or(0))
+		.collect();
+
+	let tx_zeroed: Vec<usize> = cleaned
+		.iter()
+		.map(|m| m.map(|n| n.tx_bytes_per_sec() as usize / 125).unwrap_or(0))
+		.collect();
+
 	// Mixing the TX/RX delta so we can pick a range.
 	let mut mixed = vec![0; 512];
-	mixed[..256].copy_from_slice(&rx_deltas);
-	mixed[256..].copy_from_slice(&tx_deltas);
+	mixed[..256].copy_from_slice(&rx_zeroed);
+	mixed[256..].copy_from_slice(&tx_zeroed);
 
 	mixed.sort();
 	let kinda_highest = mixed[511 - 32];
@@ -145,6 +159,40 @@ pub fn make_net_graph(state: &AwakeState) {
 	gif.save(path).unwrap();
 }
 
+fn clean_series<T, F>(series: &[T], time_extractor: F, end_time: OffsetDateTime) -> [Option<T>; 256]
+where
+	F: Fn(&T) -> OffsetDateTime,
+	T: Clone,
+{
+	let mut res = [const { None }; 256];
+
+	for value in series {
+		let time = time_extractor(value);
+		let delta = end_time - time;
+		let mins = delta.whole_minutes();
+
+		if mins > 0 && mins < 256 {
+			res[mins as usize] = Some(value.clone());
+		}
+	}
+
+	res
+}
+
+fn extract<T, F, V>(series: &[Option<T>], extractor: F) -> [Option<V>; 256]
+where
+	F: Fn(&T) -> V,
+{
+	let mut res = [const { None }; 256];
+	for (idx, maybe) in series.iter().enumerate() {
+		if let Some(value) = maybe {
+			res[idx] = Some(extractor(value));
+		}
+	}
+
+	res
+}
+
 pub struct Meminfo {
 	pub total: usize,
 	pub free: usize,