use std::sync::Arc;
use anyhow::Context as _;
use modem_contract::registry::modem as reg;
use zenoh::Session;
use crate::host::{Host, Plane};
use crate::plane::SduPlane;
type Qbl = zenoh::query::Queryable<zenoh::handlers::FifoChannelHandler<zenoh::query::Query>>;
pub(super) async fn serve(
session: Session,
host: Arc<Host>,
configs: &[Arc<crate::config::ConfigState>],
actions: &[Arc<crate::action::ActionState>],
) -> anyhow::Result<Vec<tokio::task::JoinHandle<()>>> {
let origin = super::PROFILE.local_origin();
let introspect_key = reg::introspect_key(&origin);
let introspect_qbl = declare(&session, &introspect_key).await?;
let describe_key = reg::describe_key(&origin);
let describe_qbl = declare(&session, &describe_key).await?;
let mut tasks = vec![
tokio::spawn(introspect(introspect_qbl, introspect_key)),
tokio::spawn(describe(describe_qbl, describe_key)),
];
for node in host.nodes() {
let read_key = reg::config_device_key(&origin, node.name());
let read_qbl = declare(&session, &read_key).await?;
tasks.push(
match configs.iter().find(|c| c.device == node.name()).cloned() {
Some(state) => tokio::spawn(config_read(read_qbl, read_key, state)),
None => tokio::spawn(gated(
read_qbl,
"config",
Some(node.name().to_string()),
"config",
)),
},
);
let state = configs.iter().find(|c| c.device == node.name()).cloned();
for (key, verb) in [
(
reg::config_device_confirm_key(&origin, node.name()),
"confirm",
),
(
reg::config_device_cancel_key(&origin, node.name()),
"cancel",
),
(
reg::config_device_extend_key(&origin, node.name()),
"extend",
),
] {
let qbl = declare(&session, &key).await?;
tasks.push(match state.clone() {
Some(state) => tokio::spawn(config_control(qbl, key, state, verb)),
None => tokio::spawn(gated(qbl, verb, Some(node.name().to_string()), "config")),
});
}
let persist_key = reg::config_device_persist_key(&origin, node.name());
let persist_qbl = declare(&session, &persist_key).await?;
tasks.push(match state.clone() {
Some(state) => tokio::spawn(config_control(persist_qbl, persist_key, state, "persist")),
None => tokio::spawn(gated(
persist_qbl,
"persist",
Some(node.name().to_string()),
"config",
)),
});
let lanes_key = reg::device_device_sdu_lanes_key(&origin, node.name());
let lanes_qbl = declare(&session, &lanes_key).await?;
tasks.push(match node.plane() {
Plane::Sdu(plane) => tokio::spawn(lanes(lanes_qbl, lanes_key, plane.clone())),
Plane::Netdev(_) => tokio::spawn(gated(
lanes_qbl,
"lanes",
Some(node.name().to_string()),
"sdu",
)),
});
}
let set_selector = reg::rpc_serve_key(&origin, reg::ProcedureId::ConfigDeviceGroupSet);
let set_qbl = session
.declare_queryable(set_selector.as_keyexpr())
.await
.map_err(|e| anyhow::anyhow!("{e}"))
.with_context(|| format!("declare queryable {set_selector}"))?;
tasks.push(tokio::spawn(config_set(
set_qbl,
origin.clone(),
configs.to_vec(),
)));
let action_selector = reg::rpc_serve_key(&origin, reg::ProcedureId::DeviceDeviceActionName);
let action_qbl = session
.declare_queryable(action_selector.as_keyexpr())
.await
.map_err(|e| anyhow::anyhow!("{e}"))
.with_context(|| format!("declare queryable {action_selector}"))?;
tasks.push(tokio::spawn(action_run(
action_qbl,
origin.clone(),
actions.to_vec(),
)));
Ok(tasks)
}
async fn action_run(
qbl: Qbl,
origin: zenkey::origin::LocalOrigin,
actions: Vec<Arc<crate::action::ActionState>>,
) {
while let Ok(query) = qbl.recv_async().await {
let chunks: Vec<&str> = query.key_expr().as_str().split('/').collect();
let at = chunks.iter().position(|c| *c == "device");
let (device, name) = match at {
Some(i) if chunks.len() > i + 3 && chunks[i + 2] == "action" => {
(chunks[i + 1].to_string(), chunks[i + 3].to_string())
}
_ => {
refuse(
&query,
"error/invalid-args",
"the key is not device/{device}/action/{name}",
)
.await;
continue;
}
};
let own = reg::device_device_action_name_key(&origin, &device, &name);
if let Err(e) = zenkey::require_exact(query.key_expr(), own.as_keyexpr()) {
refuse(&query, "error/fanout-forbidden", &e.to_string()).await;
continue;
}
let Some(state) = actions.iter().find(|a| a.device == device) else {
refuse(
&query,
"error/gated",
&format!(
"action needs capability:actions, which device {device:?} does not have \
(RFC 08 §6.1)"
),
)
.await;
continue;
};
let request: super::ActionRequest = match query
.payload()
.map(|p| p.try_to_string().map(|s| s.into_owned()))
.transpose()
{
Ok(Some(body)) if !body.trim().is_empty() => match serde_json::from_str(&body) {
Ok(r) => r,
Err(e) => {
refuse(
&query,
"error/invalid-args",
&format!("the request did not parse: {e}"),
)
.await;
continue;
}
},
_ => super::ActionRequest::default(),
};
let who = crate::config::Attribution {
actor: query.parameters().get("actor").map(str::to_string),
request_id: query.parameters().get("request_id").map(str::to_string),
claimed_source: None,
};
match state.invoke(&name, request.arguments, who).await {
Ok(reply) => {
let r = query
.reply(own.as_keyexpr(), reply)
.encoding(zenoh::bytes::Encoding::APPLICATION_JSON);
if let Err(e) = r.await {
tracing::debug!(error = %e, "action reply failed");
}
}
Err(refusal) => refuse(&query, &refusal.error, &refusal.message).await,
}
}
}
async fn config_set(
qbl: Qbl,
origin: zenkey::origin::LocalOrigin,
configs: Vec<Arc<crate::config::ConfigState>>,
) {
while let Ok(query) = qbl.recv_async().await {
let chunks: Vec<&str> = query.key_expr().as_str().split('/').collect();
let at = chunks.iter().position(|c| *c == "config");
let (device, group) = match at {
Some(i) if chunks.len() > i + 3 && chunks[i + 3] == "set" => {
(chunks[i + 1].to_string(), chunks[i + 2].to_string())
}
_ => {
refuse(
&query,
"error/invalid-args",
"the key is not config/{device}/{group}/set",
)
.await;
continue;
}
};
let own = reg::config_device_group_set_key(&origin, &device, &group);
if let Err(e) = zenkey::require_exact(query.key_expr(), own.as_keyexpr()) {
refuse(&query, "error/fanout-forbidden", &e.to_string()).await;
continue;
}
let Some(state) = configs.iter().find(|c| c.device == device) else {
refuse(
&query,
"error/gated",
&format!(
"set needs capability:config, which device {device:?} does not have (RFC 08 \
§6.1)"
),
)
.await;
continue;
};
let change: zenkey::config::ConfigChange = match query
.payload()
.map(|p| p.try_to_string().map(|s| s.into_owned()))
.transpose()
{
Ok(Some(body)) => match serde_json::from_str(&body) {
Ok(c) => c,
Err(e) => {
refuse(
&query,
"error/invalid-args",
&format!("the change did not parse: {e}"),
)
.await;
continue;
}
},
_ => {
refuse(
&query,
"error/invalid-args",
"a set carries a change request as its body",
)
.await;
continue;
}
};
let who = crate::config::Attribution {
actor: query.parameters().get("actor").map(str::to_string),
request_id: query.parameters().get("request_id").map(str::to_string),
claimed_source: query.source_info().map(|s| format!("{:?}", s.source_id())),
};
match state.set(&group, change, who).await {
Ok(reply) => {
let r = query
.reply(own.as_keyexpr(), reply)
.encoding(zenoh::bytes::Encoding::APPLICATION_JSON);
if let Err(e) = r.await {
tracing::debug!(error = %e, "set reply failed");
}
}
Err(refusal) => refuse(&query, &refusal.error, &refusal.message).await,
}
}
}
async fn config_control(
qbl: Qbl,
key: zenkey::Key,
state: Arc<crate::config::ConfigState>,
verb: &'static str,
) {
while let Ok(query) = qbl.recv_async().await {
let request: zenkey::config::ControlRequest = match query
.payload()
.map(|p| p.try_to_string().map(|s| s.into_owned()))
.transpose()
{
Ok(Some(body)) => match serde_json::from_str(&body) {
Ok(r) => r,
Err(e) => {
refuse(
&query,
"error/invalid-args",
&format!("the control request did not parse: {e}"),
)
.await;
continue;
}
},
_ => {
refuse(
&query,
"error/invalid-args",
&format!("{verb} carries the pending change's token as its body"),
)
.await;
continue;
}
};
let outcome = match verb {
"confirm" => state.confirm(&request).await,
"cancel" => state.cancel(&request).await,
"persist" => state.persist(&request).await,
_ => state.extend(&request).await,
};
match outcome {
Ok(reply) => {
let r = query
.reply(key.as_keyexpr(), reply)
.encoding(zenoh::bytes::Encoding::APPLICATION_JSON);
if let Err(e) = r.await {
tracing::debug!(error = %e, "{verb} reply failed");
}
}
Err(refusal) => refuse(&query, &refusal.error, &refusal.message).await,
}
}
}
async fn refuse(query: &zenoh::query::Query, error: &str, message: &str) {
let envelope = crate::config::Refusal::new(error, message).envelope();
let reply = query
.reply_err(envelope)
.encoding(zenoh::bytes::Encoding::APPLICATION_JSON);
if let Err(e) = reply.await {
tracing::debug!(error = %e, "{error} reply failed");
}
}
async fn gated(
qbl: Qbl,
procedure: &'static str,
device: Option<String>,
capability: &'static str,
) {
while let Ok(query) = qbl.recv_async().await {
let device = device.clone().unwrap_or_else(|| {
let chunks: Vec<&str> = query.key_expr().as_str().split('/').collect();
chunks
.iter()
.position(|c| *c == "config" || *c == "device")
.and_then(|i| chunks.get(i + 1))
.map_or_else(|| "?".to_string(), |d| (*d).to_string())
});
let envelope = serde_json::json!({
"error": "error/gated",
"message": format!(
"{procedure} needs capability:{capability}, which device {device:?} does not \
have (RFC 08 §6.1)"
),
});
let reply = query
.reply_err(envelope.to_string())
.encoding(zenoh::bytes::Encoding::APPLICATION_JSON);
if let Err(e) = reply.await {
tracing::debug!(error = %e, "gated reply failed");
}
}
}
async fn declare(session: &Session, key: &zenkey::Key) -> anyhow::Result<Qbl> {
session
.declare_queryable(key.as_keyexpr())
.await
.map_err(|e| anyhow::anyhow!("{e}"))
.with_context(|| format!("declare queryable {key}"))
}
async fn introspect(qbl: Qbl, key: zenkey::Key) {
while let Ok(query) = qbl.recv_async().await {
let reply = query
.reply(key.as_keyexpr(), reg::REGISTRY_SOURCE)
.encoding(zenoh::bytes::Encoding::from(reg::REGISTRY_ENCODING));
if let Err(e) = reply.await {
tracing::debug!(error = %e, "introspect reply failed");
}
}
}
async fn describe(qbl: Qbl, key: zenkey::Key) {
while let Ok(query) = qbl.recv_async().await {
let reply = query
.reply(key.as_keyexpr(), modem_contract::schema::describe_json())
.encoding(zenoh::bytes::Encoding::APPLICATION_JSON);
if let Err(e) = reply.await {
tracing::debug!(error = %e, "describe reply failed");
}
}
}
async fn config_read(qbl: Qbl, key: zenkey::Key, state: Arc<crate::config::ConfigState>) {
while let Ok(query) = qbl.recv_async().await {
let payload = match serde_json::to_string(&state.view()) {
Ok(p) => p,
Err(e) => {
tracing::error!(error = %e, "the configuration view did not serialize");
continue;
}
};
let reply = query
.reply(key.as_keyexpr(), payload)
.encoding(zenoh::bytes::Encoding::APPLICATION_JSON);
if let Err(e) = reply.await {
tracing::debug!(error = %e, "config reply failed");
}
}
}
async fn lanes(qbl: Qbl, key: zenkey::Key, plane: Arc<dyn SduPlane>) {
while let Ok(query) = qbl.recv_async().await {
let table = super::LaneTable::of(
plane.device(),
&plane.capabilities(),
plane
.lanes()
.iter()
.map(|l| super::Lane::of(&l.key, &l.path, l.connected, l.backlog_bytes))
.collect(),
);
let payload = match serde_json::to_string(&table) {
Ok(p) => p,
Err(e) => {
tracing::error!(error = %e, "lane table did not serialize");
continue;
}
};
let reply = query
.reply(key.as_keyexpr(), payload)
.encoding(zenoh::bytes::Encoding::APPLICATION_JSON);
if let Err(e) = reply.await {
tracing::debug!(error = %e, "lanes reply failed");
}
}
}