use std::sync::Arc;
use std::sync::atomic::AtomicU64;
use zenkey::origin::LocalOrigin;
use zenoh::Session;
use crate::plane::SduPlane;
use modem_contract::registry::modem::{Subject, key};
use crate::clock::{now_ms, ulid};
const FAULT_FLOOR: std::time::Duration = std::time::Duration::from_secs(60);
pub(super) async fn publish_loop(session: Session, origin: LocalOrigin, plane: Arc<dyn SduPlane>) {
let device = plane.device().to_string();
let counter = AtomicU64::new(0);
let mut faults = plane.events();
let mut last_fault: Option<tokio::time::Instant> = None;
let mut suppressed: u64 = 0;
loop {
match faults.recv().await {
Ok(event) => {
let now = tokio::time::Instant::now();
if last_fault.is_some_and(|t| now.duration_since(t) < FAULT_FLOOR) {
suppressed += 1;
continue;
}
last_fault = Some(now);
let event_id = ulid(&counter);
let subject = Subject::device_device_fault(&device, &event_id);
let doc =
super::DeviceFault::of(&device, event_id, now_ms(), &event, suppressed + 1);
suppressed = 0;
publish(&session, &origin, &subject, &doc, "device_fault").await;
}
Err(tokio::sync::broadcast::error::RecvError::Closed) => return,
Err(tokio::sync::broadcast::error::RecvError::Lagged(n)) => {
suppressed += n;
}
}
}
}
pub(super) async fn publish_device_loop(
session: Session,
origin: LocalOrigin,
device: String,
dev: Arc<dyn modem_device::Device>,
) {
let counter = AtomicU64::new(0);
let mut last_fault: Option<tokio::time::Instant> = None;
let mut suppressed: u64 = 0;
loop {
let event = match dev.next_event().await {
Ok(e) => e,
Err(e) => {
tracing::warn!(device = %device, error = %e, "the device's event stream ended");
return;
}
};
let now = tokio::time::Instant::now();
if last_fault.is_some_and(|t| now.duration_since(t) < FAULT_FLOOR) {
suppressed += 1;
continue;
}
last_fault = Some(now);
let event_id = ulid(&counter);
let subject = Subject::device_device_fault(&device, &event_id);
let doc = super::DeviceFault::of(&device, event_id, now_ms(), &event, suppressed + 1);
suppressed = 0;
publish(&session, &origin, &subject, &doc, "device_fault").await;
}
}
pub(super) async fn publish<T: serde::Serialize>(
session: &Session,
origin: &LocalOrigin,
subject: &Subject,
doc: &T,
what: &str,
) {
let payload = match serde_json::to_string(doc) {
Ok(p) => p,
Err(e) => {
tracing::error!(error = %e, "the {what} event did not serialize");
return;
}
};
let qos = subject.qos();
let k = key(origin, subject);
if let Err(e) = session
.put(k.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 = %k, error = %e, "{what} publication failed");
} else {
tracing::info!(key = %k, "published a {what} event");
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn an_id_survives_being_used_as_a_key_chunk() {
let c = AtomicU64::new(0);
let id = ulid(&c);
assert_eq!(zenkey::Chunk::slug(&id).as_str(), id);
}
#[test]
fn a_device_or_endpoint_name_keys_as_itself_when_it_is_lowercase_alnum() {
for name in ["rf0", "sat0", "peer-b", "300234010753370", "gw.eu-1"] {
assert_eq!(zenkey::Chunk::slug(name).as_str(), name, "{name} moved");
}
for name in ["RF0", "x-sat0", "sat 0", ""] {
let slug = zenkey::Chunk::slug(name);
assert!(
slug.as_str().starts_with("x-"),
"{name:?} -> {}",
slug.as_str()
);
assert_eq!(zenkey::Chunk::unslug(&slug).as_deref(), Some(name));
}
}
}