use crate::dm::spec::{Conforming, Optional};
use crate::dm::{Resolved, ResolvedCommand};
use crate::im::{
AttributeId, ClusterHandler, ClusterId, CommandId, EventId, InteractionContext, Status,
StatusIb,
};
use crate::tlv::{Tag, TlvWriter};
use super::Cluster;
pub const ID: ClusterId = 0x0034;
pub const REVISION: u16 = 1;
pub const FEATURE_WATERMARKS: u32 = 1 << 0;
pub const THREAD_METRICS: AttributeId = 0x0000;
pub const CURRENT_HEAP_FREE: AttributeId = 0x0001;
pub const CURRENT_HEAP_USED: AttributeId = 0x0002;
pub const CURRENT_HEAP_HIGH_WATERMARK: AttributeId = 0x0003;
pub const RESET_WATERMARKS: CommandId = 0x00;
pub const SOFTWARE_FAULT: EventId = 0x00;
#[derive(Debug, Clone, Copy, Default)]
pub struct ThreadMetrics<'a> {
pub id: u64,
pub name: &'a str,
pub stack_free_current: Option<u32>,
pub stack_free_minimum: Option<u32>,
pub stack_size: Option<u32>,
}
impl ThreadMetrics<'_> {
fn encode(&self, w: &mut TlvWriter<'_>) -> crate::error::Result<()> {
w.start_structure(Tag::Anonymous)?;
w.unsigned(Tag::Context(0), self.id)?;
if !self.name.is_empty() {
w.utf8(Tag::Context(1), self.name)?;
}
if let Some(value) = self.stack_free_current {
w.unsigned(Tag::Context(2), u64::from(value))?;
}
if let Some(value) = self.stack_free_minimum {
w.unsigned(Tag::Context(3), u64::from(value))?;
}
if let Some(value) = self.stack_size {
w.unsigned(Tag::Context(4), u64::from(value))?;
}
w.end_container()
}
}
pub trait SoftwareMetrics {
fn thread_metrics(&self, emit: &mut dyn FnMut(&ThreadMetrics<'_>)) {
let _ = emit;
}
fn current_heap_free(&self) -> Option<u64> {
None
}
fn current_heap_used(&self) -> Option<u64> {
None
}
fn current_heap_high_watermark(&self) -> Option<u64> {
None
}
fn reset_watermarks(&self) {}
}
#[derive(Debug, Clone, Copy, Default)]
pub struct NoMetrics;
impl SoftwareMetrics for NoMetrics {}
pub fn conforming(
features: u32,
optional: &Optional<'_>,
) -> crate::error::Result<Conforming<4, 1, 0, 1>> {
Conforming::new(
&crate::clusters::generated::software_diagnostics::CLUSTER,
features,
optional,
)
}
pub const ALL_OPTIONAL: Optional<'static> = Optional {
attributes: &[
THREAD_METRICS,
CURRENT_HEAP_FREE,
CURRENT_HEAP_USED,
CURRENT_HEAP_HIGH_WATERMARK,
],
commands: &[],
events: &[SOFTWARE_FAULT],
};
#[derive(Debug)]
pub struct SoftwareDiagnostics<'a, M: SoftwareMetrics> {
metrics: &'a M,
features: u32,
}
impl<'a, M: SoftwareMetrics> SoftwareDiagnostics<'a, M> {
#[must_use]
pub const fn new(metrics: &'a M, features: u32) -> Self {
Self { metrics, features }
}
const fn watermarks(&self) -> bool {
self.features & FEATURE_WATERMARKS != 0
}
}
impl<M: SoftwareMetrics> ClusterHandler for SoftwareDiagnostics<'_, M> {
fn read(
&self,
resolved: &Resolved<'_>,
_ctx: &InteractionContext<'_>,
w: &mut TlvWriter<'_>,
tag: Tag,
) -> Result<(), Status> {
let full = |r: crate::error::Result<()>| r.map_err(|_| Status::ResourceExhausted);
match resolved.attribute {
THREAD_METRICS => {
full(w.start_array(tag))?;
let mut failure = false;
self.metrics.thread_metrics(&mut |thread| {
failure |= thread.encode(w).is_err();
});
if failure {
return Err(Status::ResourceExhausted);
}
full(w.end_container())
}
CURRENT_HEAP_FREE => {
let Some(value) = self.metrics.current_heap_free() else {
return Err(Status::UnsupportedAttribute);
};
full(w.unsigned(tag, value))
}
CURRENT_HEAP_USED => {
let Some(value) = self.metrics.current_heap_used() else {
return Err(Status::UnsupportedAttribute);
};
full(w.unsigned(tag, value))
}
CURRENT_HEAP_HIGH_WATERMARK => {
if !self.watermarks() {
return Err(Status::UnsupportedAttribute);
}
let Some(value) = self.metrics.current_heap_high_watermark() else {
return Err(Status::UnsupportedAttribute);
};
full(w.unsigned(tag, value))
}
_ => Err(Status::UnsupportedAttribute),
}
}
fn invoke(
&self,
resolved: &ResolvedCommand<'_>,
_fields: Option<&[u8]>,
_ctx: &InteractionContext<'_>,
_w: &mut TlvWriter<'_>,
_tag: Tag,
) -> Result<Option<CommandId>, StatusIb> {
if resolved.command.id != RESET_WATERMARKS {
return Err(Status::UnsupportedCommand.into());
}
if !self.watermarks() {
return Err(Status::UnsupportedCommand.into());
}
self.metrics.reset_watermarks();
Ok(None)
}
}
impl<M: SoftwareMetrics> Cluster for SoftwareDiagnostics<'_, M> {
const ID: ClusterId = ID;
}