use std::path::{Path, PathBuf};
use std::time::Duration;
use crate::Result;
use crate::config::{AddressUnit, MonitoringIntervals, RegionBounds};
use super::configuration;
use super::sysfs_io::{
invalid_kernel_value, path_exists, read_bool, read_text, read_u64, read_usize, write_bool,
write_bytes, write_value,
};
use super::{Operation, Probe, Scheme, Target};
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct Context {
pub(super) path: PathBuf,
}
impl Context {
#[must_use]
pub fn path(&self) -> &Path {
&self.path
}
pub fn available_operations(&self) -> Result<Vec<Operation>> {
let value = read_text(&self.path.join("avail_operations"))?;
Ok(value
.lines()
.map(str::trim)
.filter(|line| !line.is_empty())
.map(Operation::parse)
.collect())
}
pub(super) fn available_operations_if_present(&self) -> Result<Option<Vec<Operation>>> {
let path = self.path.join("avail_operations");
if path_exists(&path)? {
self.available_operations().map(Some)
} else {
Ok(None)
}
}
pub fn operation(&self) -> Result<Operation> {
let value = read_text(&self.path.join("operations"))?;
Ok(Operation::parse(value.trim()))
}
pub fn set_operation(&self, operation: &Operation) -> Result<()> {
configuration::validate_token("monitoring operation", operation.kernel_name())?;
write_bytes(
&self.path.join("operations"),
operation.kernel_name().as_bytes(),
)
}
pub fn address_unit(&self) -> Result<AddressUnit> {
let path = self.path.join("addr_unit");
let bytes = read_u64(&path)?;
AddressUnit::new(bytes)
.map_err(|_| invalid_kernel_value(&path, bytes.to_string(), "a non-zero address unit"))
}
pub fn set_address_unit(&self, address_unit: AddressUnit) -> Result<()> {
write_value(&self.path.join("addr_unit"), address_unit.bytes())
}
pub fn is_paused(&self) -> Result<bool> {
read_bool(&self.path.join("pause"))
}
pub fn set_paused(&self, paused: bool) -> Result<()> {
write_bool(&self.path.join("pause"), paused)
}
pub(crate) fn pause_control_available(&self) -> Result<bool> {
path_exists(&self.path.join("pause"))
}
pub fn intervals(&self) -> Result<MonitoringIntervals> {
let path = self.path.join("monitoring_attrs/intervals");
MonitoringIntervals::new(
Duration::from_micros(read_u64(&path.join("sample_us"))?),
Duration::from_micros(read_u64(&path.join("aggr_us"))?),
Duration::from_micros(read_u64(&path.join("update_us"))?),
)
}
pub fn set_intervals(&self, intervals: MonitoringIntervals) -> Result<()> {
let path = self.path.join("monitoring_attrs/intervals");
let (sample_us, aggregation_us, update_us) = intervals.as_micros();
write_value(&path.join("sample_us"), sample_us)?;
write_value(&path.join("aggr_us"), aggregation_us)?;
write_value(&path.join("update_us"), update_us)
}
pub fn region_bounds(&self) -> Result<RegionBounds> {
let path = self.path.join("monitoring_attrs/nr_regions");
RegionBounds::new(read_u64(&path.join("min"))?, read_u64(&path.join("max"))?)
}
pub fn set_region_bounds(&self, bounds: RegionBounds) -> Result<()> {
let path = self.path.join("monitoring_attrs/nr_regions");
write_value(&path.join("min"), bounds.min())?;
write_value(&path.join("max"), bounds.max())
}
pub fn probe_count(&self) -> Result<usize> {
read_usize(&self.path.join("monitoring_attrs/probes/nr_probes"))
}
pub fn set_probe_count(&self, count: usize) -> Result<()> {
configuration::validate_count("monitoring probe count", count)?;
write_value(&self.path.join("monitoring_attrs/probes/nr_probes"), count)
}
#[must_use]
pub fn probe(&self, index: usize) -> Probe {
Probe {
path: self
.path
.join("monitoring_attrs/probes")
.join(index.to_string()),
}
}
pub fn target_count(&self) -> Result<usize> {
read_usize(&self.path.join("targets/nr_targets"))
}
pub fn set_target_count(&self, count: usize) -> Result<()> {
configuration::validate_count("target count", count)?;
write_value(&self.path.join("targets/nr_targets"), count)
}
#[must_use]
pub fn target(&self, index: usize) -> Target {
Target {
path: self.path.join("targets").join(index.to_string()),
}
}
pub fn scheme_count(&self) -> Result<usize> {
read_usize(&self.path.join("schemes/nr_schemes"))
}
pub fn set_scheme_count(&self, count: usize) -> Result<()> {
configuration::validate_count("scheme count", count)?;
write_value(&self.path.join("schemes/nr_schemes"), count)
}
#[must_use]
pub fn scheme(&self, index: usize) -> Scheme {
Scheme {
path: self.path.join("schemes").join(index.to_string()),
}
}
}