use heapless::Vec;
use crate::config::Config;
use crate::error::{Error, ErrorCode, Result, bail};
use crate::im::path::{AttributePath, EventPath};
use crate::im::subscription::{Subscription, SubscriptionTable};
use crate::msg::{FabricIndex, NodeId, SessionId};
use crate::platform::Instant;
use crate::tlv::{ContainerKind, Tag, TlvReader, TlvWriter, Value};
const TAG_ID: u8 = 0;
const TAG_FABRIC: u8 = 1;
const TAG_PEER: u8 = 2;
const TAG_FABRIC_FILTERED: u8 = 3;
const TAG_MIN_INTERVAL: u8 = 4;
const TAG_MAX_INTERVAL: u8 = 5;
const TAG_EVENT_NUMBER: u8 = 6;
const TAG_PATHS: u8 = 7;
const TAG_EVENT_PATHS: u8 = 8;
fn encode_one<const P: usize>(subscription: &Subscription<P>, w: &mut TlvWriter<'_>) -> Result<()> {
w.start_structure(Tag::Anonymous)?;
w.unsigned(Tag::Context(TAG_ID), u64::from(subscription.id))?;
if let Some(fabric) = subscription.fabric_index {
w.unsigned(Tag::Context(TAG_FABRIC), u64::from(fabric.0))?;
}
if let Some(peer) = subscription.peer_node_id {
w.unsigned(Tag::Context(TAG_PEER), peer.0)?;
}
w.bool(
Tag::Context(TAG_FABRIC_FILTERED),
subscription.fabric_filtered,
)?;
w.unsigned(
Tag::Context(TAG_MIN_INTERVAL),
u64::from(subscription.min_interval_s),
)?;
w.unsigned(
Tag::Context(TAG_MAX_INTERVAL),
u64::from(subscription.max_interval_s),
)?;
w.unsigned(
Tag::Context(TAG_EVENT_NUMBER),
subscription.next_event_number,
)?;
w.start_array(Tag::Context(TAG_PATHS))?;
for path in &subscription.paths {
path.encode(w, Tag::Anonymous)?;
}
w.end_container()?;
w.start_array(Tag::Context(TAG_EVENT_PATHS))?;
for path in &subscription.event_paths {
path.encode(w, Tag::Anonymous)?;
}
w.end_container()?;
w.end_container()
}
pub fn save<C: Config, const N: usize, const P: usize>(
table: &SubscriptionTable<C, N, P>,
w: &mut TlvWriter<'_>,
tag: Tag,
) -> Result<usize> {
w.start_array(tag)?;
let mut kept = 0usize;
for subscription in table.iter() {
if subscription.fabric_index.is_none() || subscription.peer_node_id.is_none() {
continue;
}
encode_one(subscription, w)?;
kept = kept.saturating_add(1);
}
w.end_container()?;
Ok(kept)
}
#[derive(Debug, Clone)]
pub struct Durable<const P: usize> {
pub id: u32,
pub fabric_index: FabricIndex,
pub peer_node_id: NodeId,
pub fabric_filtered: bool,
pub min_interval_s: u16,
pub max_interval_s: u16,
pub next_event_number: u64,
pub paths: Vec<AttributePath, P>,
pub event_paths: Vec<EventPath, P>,
}
fn narrow<T: TryFrom<u64>>(value: u64) -> Result<T> {
T::try_from(value).map_err(|_| Error::new(ErrorCode::TlvOutOfRange))
}
fn decode_one<const P: usize>(reader: &mut TlvReader<'_>) -> Result<Durable<P>> {
let mut id = None;
let mut fabric_index = None;
let mut peer_node_id = None;
let mut fabric_filtered = false;
let mut min_interval_s = 0u16;
let mut max_interval_s = 0u16;
let mut next_event_number = 0u64;
let mut paths: Vec<AttributePath, P> = Vec::new();
let mut event_paths: Vec<EventPath, P> = Vec::new();
loop {
let Some(field) = reader.next_element()? else {
bail!(TlvTruncated)
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(TAG_ID) => id = Some(narrow::<u32>(field.unsigned()?)?),
Some(TAG_FABRIC) => {
fabric_index = Some(FabricIndex(narrow::<u8>(field.unsigned()?)?));
}
Some(TAG_PEER) => peer_node_id = Some(NodeId(field.unsigned()?)),
Some(TAG_FABRIC_FILTERED) => fabric_filtered = field.bool()?,
Some(TAG_MIN_INTERVAL) => min_interval_s = narrow::<u16>(field.unsigned()?)?,
Some(TAG_MAX_INTERVAL) => max_interval_s = narrow::<u16>(field.unsigned()?)?,
Some(TAG_EVENT_NUMBER) => next_event_number = field.unsigned()?,
Some(TAG_PATHS) => {
if field.value.container() != Some(ContainerKind::Array) {
bail!(TlvWrongType)
}
loop {
let Some(item) = reader.next_element()? else {
bail!(TlvTruncated)
};
if item.value == Value::EndOfContainer {
break;
}
paths
.push(AttributePath::decode(reader)?)
.map_err(|_| Error::new(ErrorCode::NoSpace))?;
}
}
Some(TAG_EVENT_PATHS) => {
if field.value.container() != Some(ContainerKind::Array) {
bail!(TlvWrongType)
}
loop {
let Some(item) = reader.next_element()? else {
bail!(TlvTruncated)
};
if item.value == Value::EndOfContainer {
break;
}
event_paths
.push(EventPath::decode(reader)?)
.map_err(|_| Error::new(ErrorCode::NoSpace))?;
}
}
_ => reader.skip_value(&field)?,
}
}
let (Some(id), Some(fabric_index), Some(peer_node_id)) = (id, fabric_index, peer_node_id)
else {
bail!(TlvNotFound)
};
if paths.is_empty() && event_paths.is_empty() {
bail!(InvalidArgument)
}
Ok(Durable {
id,
fabric_index,
peer_node_id,
fabric_filtered,
min_interval_s,
max_interval_s,
next_event_number,
paths,
event_paths,
})
}
pub fn restore<C: Config, const N: usize, const P: usize>(
table: &mut SubscriptionTable<C, N, P>,
bytes: &[u8],
now: Instant,
) -> Result<usize> {
let mut reader = TlvReader::new(bytes);
let Some(head) = reader.next_element()? else {
bail!(TlvTruncated)
};
if head.value.container() != Some(ContainerKind::Array) {
bail!(TlvWrongType)
}
let mut restored = 0usize;
loop {
let Some(item) = reader.next_element()? else {
bail!(TlvTruncated)
};
if item.value == Value::EndOfContainer {
break;
}
if item.value.container() != Some(ContainerKind::Structure) {
bail!(TlvWrongType)
}
let durable = decode_one::<P>(&mut reader)?;
table.reserve_id(durable.id);
table.insert_restored(durable, now)?;
restored = restored.saturating_add(1);
}
Ok(restored)
}
pub fn rebind<C: Config, const N: usize, const P: usize>(
table: &mut SubscriptionTable<C, N, P>,
fabric: FabricIndex,
peer: NodeId,
session: SessionId,
now: Instant,
) -> usize {
let mut bound = 0usize;
for subscription in table.iter_mut() {
if subscription.session.is_some()
|| subscription.fabric_index != Some(fabric)
|| subscription.peer_node_id != Some(peer)
{
continue;
}
subscription.session = Some(session);
subscription.last_report = now;
bound = bound.saturating_add(1);
}
bound
}