use std::sync::Arc;
use std::time::Duration;
use modem_contract::registry::modem::{Subject, key};
use zenkey::origin::LocalOrigin;
use zenkey::{Key, QosProfile};
use zenoh::Session;
use crate::plane::SduPlane;
pub(super) struct StateKeys {
link: (Subject, Key),
security: (Subject, Key),
endpoints: Vec<(String, Subject, Key)>,
}
impl StateKeys {
pub(super) fn of(origin: &LocalOrigin, plane: &dyn SduPlane) -> Self {
let device = plane.device();
let resolve = |subject: Subject| {
let k = key(origin, &subject);
(subject, k)
};
let mut endpoints = Vec::new();
let mut seen = std::collections::BTreeSet::new();
for lane in plane.lanes() {
let name = lane.key.endpoint.as_str();
if seen.insert(name.to_string()) {
let (subject, k) = resolve(Subject::device_sdu_endpoint(device, name));
endpoints.push((name.to_string(), subject, k));
}
}
Self {
link: resolve(Subject::device_sdu_link(device)),
security: resolve(Subject::device_security(device)),
endpoints,
}
}
}
pub(super) fn declared_ttl_s() -> u64 {
Subject::device_sdu_link("rf0")
.ttl_s()
.expect("a state subject declares ttl_s (RFC 08 §5), enforced at build time")
}
pub(super) async fn publish_loop(
session: Session,
keys: StateKeys,
plane: Arc<dyn SduPlane>,
ttl_s: u64,
) {
let StateKeys {
link: (link_subject, link_key),
security: (security_subject, security_key),
endpoints: endpoint_keys,
} = keys;
let interval = Duration::from_secs((ttl_s / 2).max(1));
loop {
let lanes = plane.lanes();
put(
&session,
&link_key,
&super::LinkState::of(
plane.device(),
ttl_s,
&plane.capabilities(),
lanes
.iter()
.map(|l| super::Lane::of(&l.key, &l.path, l.connected))
.collect(),
),
link_subject.qos(),
)
.await;
put(
&session,
&security_key,
&super::SecurityState::of(plane.device()),
security_subject.qos(),
)
.await;
for (endpoint, subject, key) in &endpoint_keys {
put(
&session,
key,
&super::EndpointState::of(
plane.device(),
endpoint,
lanes.iter().map(|l| (&l.key, l.connected)),
),
subject.qos(),
)
.await;
}
tokio::time::sleep(interval).await;
}
}
pub(super) async fn put<T: serde::Serialize>(
session: &Session,
key: &zenkey::Key,
doc: &T,
qos: QosProfile,
) {
let payload = match serde_json::to_string(doc) {
Ok(p) => p,
Err(e) => {
tracing::error!(key = %key, error = %e, "state document did not serialize");
return;
}
};
if let Err(e) = session
.put(key.as_keyexpr(), payload)
.congestion_control(qos.congestion_control())
.priority(qos.priority())
.express(qos.express())
.reliability(qos.reliability())
.encoding(zenoh::bytes::Encoding::APPLICATION_JSON)
.await
{
tracing::debug!(key = %key, error = %e, "state publication failed");
}
}