267 lines
7.0 KiB
Rust
267 lines
7.0 KiB
Rust
// submodule needed to get metrics such as
|
|
// cpu load, ram/rom load and net activity
|
|
|
|
// use std::sync::Mutex;
|
|
use std::sync::Arc;
|
|
use crate::options::structs::TrackingProcess;
|
|
use sysinfo::{Process, System};
|
|
use tokio::join;
|
|
use crate::options::structs::{ProcessMetrics, ContainerMetrics};
|
|
use super::get_container_id;
|
|
// use pcap::{Device, Capture, Active};
|
|
// use std::net::Ipv4Addr;
|
|
// use anyhow::{Result, Ok};
|
|
|
|
// type PacketBuffer = Arc<Mutex<Vec<PacketInfo>>>;
|
|
|
|
/// # Fn `init_metrics_grubber`
|
|
/// ## for initializing process of unstoppable grubbing metrics.
|
|
///
|
|
/// *input* : `Arc<Mutex<UnixSocket>>` ??
|
|
///
|
|
/// *output* : `Err` if it cant create grubbers | `Ok` on finish
|
|
///
|
|
/// *initiator* : main thread ??
|
|
///
|
|
/// *managing* : object of unix-socket reader
|
|
///
|
|
/// *depends on* : -
|
|
///
|
|
#[allow(dead_code)]
|
|
pub async fn init_metrics_grubber() {
|
|
let mut system = System::new();
|
|
// let mut buffer: Vec<PacketInfo> = vec![];
|
|
// let shared_buf: PacketBuffer = Arc::new(Mutex::new(buffer));
|
|
|
|
system.refresh_all();
|
|
// let temp = String::from_utf8(get_pid("systemd").await.unwrap().stdout).unwrap();
|
|
// let prc = system.process(Pid::from_str(&temp).unwrap()).unwrap();
|
|
// prc.
|
|
// let _ = capture_packets(shared_buf.clone()).await;
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
#[allow(unused_variables)]
|
|
async fn gather_metrics(proc: Arc<Process>) {
|
|
|
|
}
|
|
|
|
// DEPRECATED : for net monitoring
|
|
// async fn capture_packets(buffer: PacketBuffer) -> Result<()> {
|
|
// let mut cap = Capture::from_device(Device::lookup()?.unwrap())?
|
|
// .promisc(true)
|
|
// .open()?;
|
|
|
|
// cap.filter("not broadcast and not multicast", true)?;
|
|
|
|
// while let core::result::Result::Ok(packet) = cap.next_packet() {
|
|
// if let Some((src, dst, prot)) = get_packet_info(&packet.data).await {
|
|
// let packet_info = PacketInfo::new(String::from(prot), dst, src, packet.header.len as usize);
|
|
// let mut locked_buffer = buffer.lock().unwrap();
|
|
// println!("{:?}", &packet_info);
|
|
// locked_buffer.push(packet_info);
|
|
// }
|
|
// }
|
|
// Ok(())
|
|
// }
|
|
// async fn get_packet_info(data: &[u8]) -> Option<(Ipv4Addr, Ipv4Addr, &str)> {
|
|
// if data.len() >= 20 {
|
|
// let src_ip = Ipv4Addr::new(data[12], data[13], data[14], data[15]);
|
|
// let dst_ip = Ipv4Addr::new(data[16], data[17], data[18], data[19]);
|
|
// let protocol = match data[9] {
|
|
// 1 => "ICMP",
|
|
// 6 => "TCP",
|
|
// 17 => "UDP",
|
|
// _ => "Unknown",
|
|
// };
|
|
|
|
// Some((src_ip, dst_ip, protocol))
|
|
// } else {
|
|
// None
|
|
// }
|
|
// }
|
|
|
|
|
|
/// # Fn `get_all_container_metrics`
|
|
/// ## for gathering all container (whole system metrics)
|
|
///
|
|
/// *input* : `Arc<System>`, `Arc<Vec<TrackingProcess>>`
|
|
///
|
|
/// *output* : `ContainerMetrics`
|
|
///
|
|
/// *initiator* : main thread ??
|
|
///
|
|
/// *managing* : ref counter to `System` object, ref counter to list of processes
|
|
///
|
|
/// *depends on* : `TrackingProcess`
|
|
///
|
|
#[allow(dead_code)]
|
|
async fn get_all_container_metrics(sys: Arc<System>, prcs: Arc<Vec<TrackingProcess>>) -> ContainerMetrics {
|
|
let metrics = join!(
|
|
get_cpu_metrics_container(sys.clone()),
|
|
get_ram_metrics_container(sys.clone()),
|
|
get_subsystems(prcs.clone())
|
|
);
|
|
ContainerMetrics::new(
|
|
&get_container_id().unwrap_or(String::from("unknown")),
|
|
metrics.0,
|
|
metrics.1,
|
|
metrics.2
|
|
)
|
|
}
|
|
|
|
/// # Fn `get_cpu_metrics_container`
|
|
/// ## for gathering container cpu metrics
|
|
///
|
|
/// *input* : `Arc<System>`
|
|
///
|
|
/// *output* : `f32`
|
|
///
|
|
/// *initiator* : main thread ??
|
|
///
|
|
/// *managing* : ref counter to `System` object
|
|
///
|
|
/// *depends on* : -
|
|
///
|
|
#[allow(dead_code)]
|
|
async fn get_cpu_metrics_container(sys: Arc<System>) -> f32 {
|
|
sys.global_cpu_usage()
|
|
}
|
|
|
|
/// # Fn `get_ram_metrics_container`
|
|
/// ## for gathering container ram metrics
|
|
///
|
|
/// *input* : `Arc<System>`
|
|
///
|
|
/// *output* : `f32`
|
|
///
|
|
/// *initiator* : main thread ??
|
|
///
|
|
/// *managing* : ref counter to `System` object
|
|
///
|
|
/// *depends on* : -
|
|
///
|
|
#[allow(dead_code)]
|
|
async fn get_ram_metrics_container(sys: Arc<System>) -> f32 {
|
|
(sys.used_memory() / sys.total_memory()) as f32 * 100.0
|
|
}
|
|
// async fn get_mem_metrics_container(sys: Arc<System>) -> f32 {
|
|
// sys.
|
|
// }
|
|
|
|
/// # Fn `get_subsystems`
|
|
/// ## for gathering info about container subsystems (processes)
|
|
///
|
|
/// *input* : `Arc<Vec<TrackingProcess>>`
|
|
///
|
|
/// *output* : `Vec<String>`
|
|
///
|
|
/// *initiator* : main thread ??
|
|
///
|
|
/// *managing* : ref counter to list of `TrackingProcess`
|
|
///
|
|
/// *depends on* : `TrackingProcess`
|
|
///
|
|
#[allow(dead_code)]
|
|
async fn get_subsystems(prcs: Arc<Vec<TrackingProcess>>) -> Vec<String> {
|
|
prcs.iter().map(|process| process.name.clone()).collect()
|
|
}
|
|
|
|
/// # Fn `get_all_metrics_process`
|
|
/// ## for gathering all process' metrics
|
|
///
|
|
/// *input* : `Arc<Process>`, `Arc<System>`
|
|
///
|
|
/// *output* : `ProcessMetrics`
|
|
///
|
|
/// *initiator* : main thread ??
|
|
///
|
|
/// *managing* : two ref counters to `Process` and `System`
|
|
///
|
|
/// *depends on* : -
|
|
///
|
|
#[allow(dead_code)]
|
|
async fn get_all_metrics_process(proc: Arc<Process>, sys: Arc<System>) -> ProcessMetrics {
|
|
let metrics = join!(
|
|
get_cpu_metrics_process(proc.clone()),
|
|
get_ram_metrics_process(proc.clone(), sys.clone())
|
|
);
|
|
ProcessMetrics::new(
|
|
proc.name().to_str().unwrap_or("unknown"),
|
|
metrics.0,
|
|
metrics.1
|
|
)
|
|
}
|
|
|
|
/// # Fn `get_cpu_metrics_process`
|
|
/// ## for gathering process cpu metrics
|
|
///
|
|
/// *input* : `Arc<Process>`
|
|
///
|
|
/// *output* : `f32`
|
|
///
|
|
/// *initiator* : main thread ??
|
|
///
|
|
/// *managing* : ref counter to `Process` object
|
|
///
|
|
/// *depends on* : -
|
|
///
|
|
async fn get_cpu_metrics_process(proc: Arc<Process>) -> f32 {
|
|
proc.cpu_usage()
|
|
}
|
|
|
|
/// # Fn `get_ram_metrics_process`
|
|
/// ## for gathering process ram metrics
|
|
///
|
|
/// *input* : `Arc<Process>`
|
|
///
|
|
/// *output* : `f32`
|
|
///
|
|
/// *initiator* : main thread ??
|
|
///
|
|
/// *managing* : ref counter to `Process` object
|
|
///
|
|
/// *depends on* : -
|
|
///
|
|
async fn get_ram_metrics_process(proc: Arc<Process>, sys: Arc<System>) -> f32 {
|
|
(proc.memory() as f64 / sys.total_memory() as f64) as f32 * 100.0 as f32
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod metrics_unittets {
|
|
#[tokio::test]
|
|
// Option<String> output
|
|
// echo func
|
|
async fn get_cpu_load() {
|
|
assert!(true);
|
|
}
|
|
#[tokio::test]
|
|
// Option<String> output
|
|
// echo func
|
|
async fn get_ram_load() {
|
|
assert!(true);
|
|
}
|
|
#[tokio::test]
|
|
// Option<String> output
|
|
// echo func
|
|
async fn get_mem_load() {
|
|
assert!(true);
|
|
}
|
|
#[tokio::test]
|
|
// can't be tested this way because of 0-0 loop of checking buffer
|
|
// async func with loop inside
|
|
async fn get_net_stat() {
|
|
assert!(true);
|
|
}
|
|
#[tokio::test]
|
|
async fn get_metrics_grubber() {
|
|
assert!(true);
|
|
}
|
|
// Option<Vec<TrackingProcess OR String>> output
|
|
// echo func
|
|
#[tokio::test]
|
|
async fn get_info_about_subsystems() {
|
|
assert!(true);
|
|
}
|
|
}
|