use std::collections::{BTreeMap, BTreeSet};
use std::sync::Arc;
use std::sync::atomic::{AtomicU64, Ordering};
use std::time::Duration;
use modem_contract::registry::modem::{Subject, key};
use modem_device::config::{ConfigError, ConfigValue, Effective, ParamClass, Schema, Undo};
use tokio::time::Instant;
use zenkey::config::{
ChangeOutcome, ConfigChange, ConfigChangeEvent, ControlRequest, Edit, ParamValue, PendingChange,
};
use zenkey::origin::LocalOrigin;
use zenoh::Session;
use crate::clock::{now_ms, rfc3339, ulid};
use crate::oper::Source;
use crate::overlay::{Overlay, from_toml, schema_hash, to_toml};
const IDEMPOTENCY_WINDOW: Duration = Duration::from_secs(300);
const APPLY_AFTER: Duration = Duration::from_secs(1);
pub(crate) struct Bucket {
tokens: f64,
last: Instant,
}
impl Bucket {
const CAPACITY: f64 = 10.0;
const PER_SECOND: f64 = 600.0 / 3600.0;
pub(crate) fn new(now: Instant) -> Self {
Self {
tokens: Self::CAPACITY,
last: now,
}
}
fn refill(&mut self, now: Instant) {
let earned = now.duration_since(self.last).as_secs_f64() * Self::PER_SECOND;
self.tokens = (self.tokens + earned).min(Self::CAPACITY);
self.last = now;
}
pub(crate) fn take(&mut self, now: Instant) -> bool {
self.refill(now);
if self.tokens >= 1.0 {
self.tokens -= 1.0;
true
} else {
false
}
}
pub(crate) fn next_at(&self, now: Instant) -> Instant {
let short = (1.0 - self.tokens).max(0.0);
now + Duration::from_secs_f64(short / Self::PER_SECOND)
}
}
pub(crate) struct Pending {
token: String,
group: String,
values: BTreeMap<String, ConfigValue>,
undo: Option<Undo>,
deadline_ms: u64,
who: Attribution,
timer: Option<tokio::task::JoinHandle<()>>,
}
pub(crate) struct ConfigState {
pub(crate) device: String,
pub(crate) source: Source,
pub(crate) schema: Schema,
pub(crate) startup: Effective,
pub(crate) file_keys: BTreeSet<String>,
pub(crate) writable: BTreeSet<String>,
pub(crate) revision: AtomicU64,
runtime: std::sync::Mutex<BTreeSet<String>>,
pending: std::sync::Mutex<Option<Pending>>,
confirmed: std::sync::Mutex<Option<Confirmed>>,
overlay: Option<std::path::PathBuf>,
overlay_keys: std::sync::Mutex<BTreeSet<String>>,
writer: tokio::sync::Mutex<()>,
replies: std::sync::Mutex<BTreeMap<String, (Instant, String)>>,
events: tokio::sync::Mutex<Vec<ConfigChangeEvent>>,
faults: tokio::sync::Mutex<Vec<String>>,
changed: tokio::sync::Notify,
}
#[derive(Clone, Debug)]
struct Confirmed {
token: String,
group: String,
values: BTreeMap<String, ConfigValue>,
}
#[derive(Clone, Debug, Default)]
pub(crate) struct Attribution {
pub(crate) actor: Option<String>,
pub(crate) request_id: Option<String>,
pub(crate) claimed_source: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub(crate) struct Refusal {
pub(crate) error: String,
pub(crate) message: String,
}
impl Refusal {
pub(crate) fn new(error: impl Into<String>, message: impl Into<String>) -> Self {
Self {
error: error.into(),
message: message.into(),
}
}
fn of(e: &zenkey::config::ConfigError) -> Self {
use modem_contract::registry::modem::error;
let name = match e {
zenkey::config::ConfigError::Contract(_) => error::RESTART_REQUIRED,
zenkey::config::ConfigError::Device(_) => error::DEVICE_REFUSED,
other => other.reserved_error().unwrap_or("error/invalid-args"),
};
Self::new(name, e.to_string())
}
fn of_device(e: &ConfigError) -> Self {
use modem_contract::registry::modem::error;
match e {
ConfigError::UnknownGroup(_) | ConfigError::UnknownParameter { .. } => {
Self::new("error/not-found", e.to_string())
}
ConfigError::Invalid { .. } => Self::new("error/invalid-args", e.to_string()),
ConfigError::Contract(_) => Self::new(error::RESTART_REQUIRED, e.to_string()),
ConfigError::Device(words) => Self::new(error::DEVICE_REFUSED, words.clone()),
_ => Self::new("error/unsupported", e.to_string()),
}
}
pub(crate) fn envelope(&self) -> String {
serde_json::json!({ "error": self.error, "message": self.message }).to_string()
}
}
impl ConfigState {
pub(crate) fn of(
device: &str,
source: Source,
file_keys: BTreeSet<String>,
writable: BTreeSet<String>,
overlay: Option<std::path::PathBuf>,
) -> Option<Self> {
let schema = source.schema()?;
let startup = source.effective().unwrap_or_default();
Some(Self {
device: device.to_string(),
source,
schema,
startup,
file_keys,
writable,
revision: AtomicU64::new(0),
runtime: std::sync::Mutex::new(BTreeSet::new()),
pending: std::sync::Mutex::new(None),
confirmed: std::sync::Mutex::new(None),
overlay,
overlay_keys: std::sync::Mutex::new(BTreeSet::new()),
writer: tokio::sync::Mutex::new(()),
replies: std::sync::Mutex::new(BTreeMap::new()),
events: tokio::sync::Mutex::new(Vec::new()),
faults: tokio::sync::Mutex::new(Vec::new()),
changed: tokio::sync::Notify::new(),
})
}
fn view_of(&self, effective: &Effective) -> zenkey::config::ConfigView {
let runtime = self.runtime.lock().expect("not poisoned");
let overlay = self.overlay_keys.lock().expect("not poisoned");
modem_contract::config::view(
&self.device,
&self.schema,
effective,
&modem_contract::config::Provenance {
startup: Some(&self.startup),
file_keys: Some(&self.file_keys),
runtime_keys: Some(&runtime),
overlay_keys: Some(&overlay),
revision: self.revision.load(Ordering::Relaxed),
pending: self
.pending
.lock()
.expect("not poisoned")
.as_ref()
.map(|p| {
PendingChange::new(p.token.clone(), [p.group.clone()])
.until(rfc3339(p.deadline_ms))
}),
},
)
}
pub(crate) fn view(&self) -> zenkey::config::ConfigView {
self.view_of(&self.source.effective().unwrap_or_default())
}
pub(crate) async fn set(
self: &Arc<Self>,
group: &str,
change: ConfigChange,
who: Attribution,
) -> Result<String, Refusal> {
if !self.writable.contains(group) {
return Err(Refusal::new(
"error/gated",
format!(
"group {group:?} is not remotely writable on device {:?}: the startup \
file's `writable` names the groups that are (RFC 05 §5.1)",
self.device
),
));
}
let _writer = self.writer.lock().await;
self.not_busy()?;
if let Some(k) = &change.idempotency_key {
let mut replies = self.replies.lock().expect("not poisoned");
let now = Instant::now();
replies.retain(|_, (at, _)| now.duration_since(*at) < IDEMPOTENCY_WINDOW);
if let Some((_, first)) = replies.get(k) {
return Ok(first.clone());
}
}
let current = self.revision.load(Ordering::Relaxed);
if let Some(expected) = change.expected_revision
&& expected != current
{
return Err(Refusal::of(&zenkey::config::ConfigError::StaleRevision {
expected,
current,
}));
}
modem_contract::config::schema(&self.schema)
.validate(group, &change)
.map_err(|e| Refusal::of(&e))?;
let values: BTreeMap<String, ConfigValue> = change
.values
.iter()
.map(|(k, v)| (k.clone(), modem_contract::config::value_of(v)))
.collect();
let before = self.source.effective().unwrap_or_default();
if change.dry_run {
let mut would = before.clone();
would
.entry(group.to_string())
.or_default()
.extend(values.iter().map(|(k, v)| (k.clone(), v.clone())));
return serde_json::to_string(&self.view_of(&would)).map_err(|e| {
Refusal::new(
"error/invalid-args",
format!("the dry run did not serialize: {e}"),
)
});
}
let class = self
.schema
.group(group)
.map_or(ParamClass::Hot, |g| g.class);
if let Some(confirm_s) = change.confirm_s {
let window = Duration::from_secs(confirm_s).max(self.confirm_floor());
let token = ulid(&AtomicU64::new(0));
if class == ParamClass::Reach {
let apply_at_ms = now_ms() + APPLY_AFTER.as_millis() as u64;
self.arm(
token.clone(),
group,
values.clone(),
None,
Instant::now() + APPLY_AFTER + window,
apply_at_ms + window.as_millis() as u64,
who.clone(),
);
let me = self.clone();
let (g, v, t, w) = (group.to_string(), values.clone(), token.clone(), who);
tokio::spawn(async move {
tokio::time::sleep(APPLY_AFTER).await;
me.apply_armed(&g, &v, &t, &w).await;
});
return Ok(serde_json::json!({
"token": token,
"apply_at": rfc3339(apply_at_ms),
"deadline": rfc3339(apply_at_ms + window.as_millis() as u64),
})
.to_string());
}
let undo = self
.apply_now(group, &values, &before, Some(&token), &who)
.await?;
let deadline_ms = now_ms() + window.as_millis() as u64;
self.arm(
token,
group,
values.clone(),
Some(undo),
Instant::now() + window,
deadline_ms,
who,
);
} else {
self.apply_now(group, &values, &before, None, &who).await?;
}
let after = self.source.effective().unwrap_or_default();
let reply = serde_json::to_string(&self.view_of(&after)).map_err(|e| {
Refusal::new(
"error/invalid-args",
format!("the read-back did not serialize: {e}"),
)
})?;
if let Some(k) = change.idempotency_key {
self.replies
.lock()
.expect("not poisoned")
.insert(k, (Instant::now(), reply.clone()));
}
Ok(reply)
}
fn not_busy(&self) -> Result<(), Refusal> {
if let Some(pending) = self.pending.lock().expect("not poisoned").as_ref() {
return Err(Refusal::new(
"error/busy",
zenkey::config::ConfigError::Busy {
token: pending.token.clone(),
}
.to_string(),
));
}
Ok(())
}
fn confirm_floor(&self) -> Duration {
match &self.source {
Source::Sdu(plane) => plane.configuration().map(|c| c.confirm_floor()),
Source::Device(dev) => dev.configuration().map(|c| c.confirm_floor()),
}
.unwrap_or(Duration::from_secs(60))
}
async fn device_apply(
&self,
group: &str,
values: &BTreeMap<String, ConfigValue>,
) -> Result<Undo, ConfigError> {
match &self.source {
Source::Sdu(plane) => match plane.configuration() {
Some(c) => c.apply(group, values).await,
None => Err(ConfigError::Unsupported(group.to_string())),
},
Source::Device(dev) => match dev.configuration() {
Some(c) => c.apply(group, values).await,
None => Err(ConfigError::Unsupported(group.to_string())),
},
}
}
async fn apply_now(
&self,
group: &str,
values: &BTreeMap<String, ConfigValue>,
before: &Effective,
token: Option<&str>,
who: &Attribution,
) -> Result<Undo, Refusal> {
let undo = self
.device_apply(group, values)
.await
.map_err(|e| Refusal::of_device(&e))?;
let revision = self.revision.fetch_add(1, Ordering::Relaxed) + 1;
{
let mut runtime = self.runtime.lock().expect("not poisoned");
for name in values.keys() {
runtime.insert(format!("{group}/{name}"));
}
}
let after = self.source.effective().unwrap_or_default();
let edits = self.edits(group, before, &after, values);
let event = change_event(
&self.device,
revision,
token,
ChangeOutcome::Applied,
edits,
who,
);
self.events.lock().await.push(event);
self.changed.notify_waiters();
Ok(undo)
}
#[allow(clippy::too_many_arguments)]
fn arm(
self: &Arc<Self>,
token: String,
group: &str,
values: BTreeMap<String, ConfigValue>,
undo: Option<Undo>,
deadline: Instant,
deadline_ms: u64,
who: Attribution,
) {
let me = self.clone();
let t = token.clone();
let timer = tokio::spawn(async move {
tokio::time::sleep_until(deadline).await;
me.expire(&t).await;
});
*self.pending.lock().expect("not poisoned") = Some(Pending {
token,
group: group.to_string(),
values,
undo,
deadline_ms,
who,
timer: Some(timer),
});
self.changed.notify_waiters();
}
async fn apply_armed(
self: &Arc<Self>,
group: &str,
values: &BTreeMap<String, ConfigValue>,
token: &str,
who: &Attribution,
) {
let before = self.source.effective().unwrap_or_default();
match self
.apply_now(group, values, &before, Some(token), who)
.await
{
Ok(undo) => {
if let Some(p) = self
.pending
.lock()
.expect("not poisoned")
.as_mut()
.filter(|p| p.token == token)
{
p.undo = Some(undo);
}
}
Err(refusal) => {
tracing::warn!(
device = %self.device,
group,
error = %refusal.message,
"a reach change was refused after its reply"
);
self.faults.lock().await.push(refusal.message);
self.take_pending(Some(token), false);
}
}
self.changed.notify_waiters();
}
fn take_pending(&self, token: Option<&str>, from_timer: bool) -> Option<Pending> {
let mut slot = self.pending.lock().expect("not poisoned");
match (slot.as_ref(), token) {
(Some(p), Some(t)) if p.token != t => None,
(Some(_), _) => {
let mut p = slot.take().expect("checked");
if let Some(timer) = p.timer.take()
&& !from_timer
{
timer.abort();
}
Some(p)
}
(None, _) => None,
}
}
fn pending_token(&self, request: &ControlRequest) -> Result<(), Refusal> {
match self.pending.lock().expect("not poisoned").as_ref() {
None => Err(Refusal::new(
"error/not-found",
format!("no change is pending on device {:?}", self.device),
)),
Some(p) if p.token != request.token => Err(Refusal::new(
"error/invalid-args",
format!(
"the pending change on device {:?} has token {}, not {}",
self.device, p.token, request.token
),
)),
Some(_) => Ok(()),
}
}
async fn expire(self: &Arc<Self>, token: &str) {
let _writer = self.writer.lock().await;
if let Some(p) = self.take_pending(Some(token), true) {
self.rollback(p, "the confirm window expired").await;
}
}
pub(crate) async fn confirm(&self, request: &ControlRequest) -> Result<String, Refusal> {
let _writer = self.writer.lock().await;
self.pending_token(request)?;
let applied = self
.pending
.lock()
.expect("not poisoned")
.as_ref()
.is_some_and(|p| p.undo.is_some());
if !applied {
return Err(Refusal::new(
"error/busy",
"the change has not been applied yet; confirm it once the echo shows it",
));
}
let p = self
.take_pending(Some(&request.token), false)
.expect("checked");
*self.confirmed.lock().expect("not poisoned") = Some(Confirmed {
token: p.token.clone(),
group: p.group.clone(),
values: p.values.clone(),
});
let revision = self.revision.load(Ordering::Relaxed);
let event = change_event(
&self.device,
revision,
Some(&p.token),
ChangeOutcome::Confirmed,
Vec::new(),
&p.who,
);
self.events.lock().await.push(event);
self.changed.notify_waiters();
self.reply()
}
pub(crate) async fn cancel(&self, request: &ControlRequest) -> Result<String, Refusal> {
let _writer = self.writer.lock().await;
self.pending_token(request)?;
let p = self
.take_pending(Some(&request.token), false)
.expect("checked");
self.rollback(p, "cancelled").await;
self.reply()
}
pub(crate) async fn extend(
self: &Arc<Self>,
request: &ControlRequest,
) -> Result<String, Refusal> {
let _writer = self.writer.lock().await;
self.pending_token(request)?;
let Some(confirm_s) = request.confirm_s else {
return Err(Refusal::new(
"error/invalid-args",
"extend carries `confirm_s`, the new window from now",
));
};
let window = Duration::from_secs(confirm_s).max(self.confirm_floor());
let mut p = self
.take_pending(Some(&request.token), false)
.expect("checked");
p.deadline_ms = now_ms() + window.as_millis() as u64;
let me = self.clone();
let t = p.token.clone();
let deadline = Instant::now() + window;
p.timer = Some(tokio::spawn(async move {
tokio::time::sleep_until(deadline).await;
me.expire(&t).await;
}));
*self.pending.lock().expect("not poisoned") = Some(p);
self.changed.notify_waiters();
self.reply()
}
fn reply(&self) -> Result<String, Refusal> {
serde_json::to_string(&self.view()).map_err(|e| {
Refusal::new(
"error/invalid-args",
format!("the read-back did not serialize: {e}"),
)
})
}
async fn rollback(&self, p: Pending, why: &str) {
let Some(undo) = p.undo else {
return;
};
let before = self.source.effective().unwrap_or_default();
match self.device_apply(&p.group, &undo).await {
Ok(_) => {
let revision = self.revision.fetch_add(1, Ordering::Relaxed) + 1;
{
let mut runtime = self.runtime.lock().expect("not poisoned");
for name in undo.keys() {
runtime.remove(&format!("{}/{name}", p.group));
}
}
let after = self.source.effective().unwrap_or_default();
let edits = self.edits(&p.group, &before, &after, &undo);
let event = change_event(
&self.device,
revision,
Some(&p.token),
ChangeOutcome::RolledBack,
edits,
&p.who,
);
tracing::info!(device = %self.device, group = %p.group, why, "rolled back");
self.events.lock().await.push(event);
}
Err(e) => {
let revision = self.revision.load(Ordering::Relaxed);
let event = change_event(
&self.device,
revision,
Some(&p.token),
ChangeOutcome::Partial,
Vec::new(),
&p.who,
);
tracing::warn!(
device = %self.device,
group = %p.group,
error = %e,
"the undo failed; not retried"
);
self.events.lock().await.push(event);
self.faults
.lock()
.await
.push(format!("undo of {} ({why}) failed: {e}", p.group));
}
}
self.changed.notify_waiters();
}
pub(crate) async fn persist(&self, request: &ControlRequest) -> Result<String, Refusal> {
let _writer = self.writer.lock().await;
let Some(path) = &self.overlay else {
return Err(Refusal::new(
"error/unsupported",
"nothing persists on this host: set `[management] state_dir`, or run under a \
systemd unit with `StateDirectory=` (#128)",
));
};
let confirmed = self.confirmed.lock().expect("not poisoned").clone();
let Some(c) = confirmed.filter(|c| c.token == request.token) else {
return Err(Refusal::new(
"error/not-found",
format!(
"no confirmed change with token {} on device {:?}: persist keeps a change an \
operator confirmed (RFC 05 §5.1)",
request.token, self.device
),
));
};
if let Some(name) = c.values.keys().find(|n| {
self.schema
.group(&c.group)
.and_then(|g| g.parameter(n))
.is_some_and(|p| p.sensitive)
}) {
return Err(Refusal::new(
"error/invalid-args",
format!(
"{}/{name} is sensitive and is never written to the overlay: a secret belongs \
in the operator's credential store — the startup file, or a systemd \
credential",
c.group
),
));
}
let hash = schema_hash(&self.schema);
let mut overlay = match Overlay::load(path) {
Ok(Some(o)) if o.schema == hash => o,
Ok(_) => Overlay::new(hash),
Err(e) => {
tracing::warn!(device = %self.device, path = %path.display(), error = %e, "the overlay was unreadable and is being replaced");
Overlay::new(hash)
}
};
for (name, value) in &c.values {
let overrode = self
.startup
.get(&c.group)
.and_then(|m| m.get(name))
.map_or(toml::Value::String(String::new()), to_toml);
overlay.upsert(&c.group, name, to_toml(value), overrode);
}
overlay.save(path).map_err(|e| {
Refusal::new(
"error/unsupported",
format!(
"the overlay could not be written to {}: {e}",
path.display()
),
)
})?;
{
let mut keys = self.overlay_keys.lock().expect("not poisoned");
let mut runtime = self.runtime.lock().expect("not poisoned");
for name in c.values.keys() {
let key = format!("{}/{name}", c.group);
runtime.remove(&key);
keys.insert(key);
}
}
tracing::info!(device = %self.device, group = %c.group, path = %path.display(), "persisted");
self.changed.notify_waiters();
Ok("{}".to_string())
}
pub(crate) async fn boot(&self) -> usize {
let Some(path) = &self.overlay else {
return 0;
};
let overlay = match Overlay::load(path) {
Ok(Some(o)) => o,
Ok(None) => return 0,
Err(e) => {
tracing::warn!(device = %self.device, path = %path.display(), error = %e, "the overlay is unreadable and is ignored");
return 0;
}
};
let hash = schema_hash(&self.schema);
let mut keep: Vec<crate::overlay::Entry> = Vec::new();
let mut dropped: Vec<(crate::overlay::Entry, String)> = Vec::new();
for e in overlay.entries {
let key = format!("{}/{}", e.group, e.name);
let startup = self
.startup
.get(&e.group)
.and_then(|m| m.get(&e.name))
.cloned();
let reason = if overlay.schema != hash {
Some("the schema changed since it was written".to_string())
} else if from_toml(&e.overrode) != startup {
Some(format!(
"the startup value moved from {} to {}",
e.overrode,
startup.map_or("nothing".to_string(), |v| v.to_string())
))
} else {
match from_toml(&e.value) {
None => Some(format!("{} is not a value {key} takes", e.value)),
Some(v) => self
.schema
.check(&e.group, &e.name, &v)
.err()
.map(|err| err.to_string()),
}
};
match reason {
Some(r) => dropped.push((e, r)),
None => keep.push(e),
}
}
let mut applied = 0;
let mut by_group: BTreeMap<String, BTreeMap<String, ConfigValue>> = BTreeMap::new();
for e in &keep {
if let Some(v) = from_toml(&e.value) {
by_group
.entry(e.group.clone())
.or_default()
.insert(e.name.clone(), v);
}
}
let mut refused: Vec<(crate::overlay::Entry, String)> = Vec::new();
for (group, values) in by_group {
match self.device_apply(&group, &values).await {
Ok(_) => {
let mut keys = self.overlay_keys.lock().expect("not poisoned");
for name in values.keys() {
keys.insert(format!("{group}/{name}"));
}
applied += values.len();
}
Err(e) => {
let why = format!("the device refused it at boot: {e}");
keep.retain(|k| {
if k.group == group {
refused.push((k.clone(), why.clone()));
false
} else {
true
}
});
}
}
}
dropped.extend(refused);
if !dropped.is_empty() {
let pruned = Overlay {
schema: hash,
entries: keep,
};
if let Err(e) = pruned.save(path) {
tracing::warn!(device = %self.device, error = %e, "the pruned overlay could not be written");
}
let edits: Vec<Edit> = dropped
.iter()
.map(|(e, why)| {
tracing::warn!(device = %self.device, parameter = %format!("{}/{}", e.group, e.name), why, "an overlay entry was dropped");
Edit::of(
format!("{}/{}", e.group, e.name),
e.value.clone().try_into::<ParamValue>().ok(),
self.startup
.get(&e.group)
.and_then(|m| m.get(&e.name))
.map(modem_contract::config::value),
)
})
.collect();
let who = Attribution {
actor: Some("boot".into()),
..Attribution::default()
};
let event = change_event(&self.device, 0, None, ChangeOutcome::Partial, edits, &who);
self.events.lock().await.push(event);
}
if applied > 0 {
tracing::info!(device = %self.device, applied, path = %path.display(), "the overlay applied at boot");
}
applied
}
pub(crate) fn provisional(self: &Arc<Self>, after: Duration) -> tokio::task::JoinHandle<()> {
let me = self.clone();
tokio::spawn(async move {
tokio::time::sleep(after).await;
if me.source.oper().is_up() {
return;
}
let _writer = me.writer.lock().await;
let keys: Vec<String> = me
.overlay_keys
.lock()
.expect("not poisoned")
.iter()
.cloned()
.collect();
let mut by_group: BTreeMap<String, BTreeMap<String, ConfigValue>> = BTreeMap::new();
for key in &keys {
if let Some((group, name)) = key.split_once('/')
&& let Some(v) = me.startup.get(group).and_then(|m| m.get(name))
{
by_group
.entry(group.to_string())
.or_default()
.insert(name.to_string(), v.clone());
}
}
let before = me.source.effective().unwrap_or_default();
let mut edits = Vec::new();
for (group, values) in &by_group {
match me.device_apply(group, values).await {
Ok(_) => {
let after = me.source.effective().unwrap_or_default();
edits.extend(me.edits(group, &before, &after, values));
}
Err(e) => {
tracing::warn!(device = %me.device, group, error = %e, "the provisional rollback was refused; not retried");
me.faults
.lock()
.await
.push(format!("provisional boot: undo of {group} failed: {e}"));
}
}
}
me.overlay_keys.lock().expect("not poisoned").clear();
if let Some(path) = &me.overlay {
let aside = path.with_extension("toml.provisional");
if let Err(e) = std::fs::rename(path, &aside) {
tracing::warn!(device = %me.device, error = %e, "the overlay could not be set aside");
} else {
tracing::warn!(device = %me.device, aside = %aside.display(), after_s = after.as_secs(), "not up under the overlay by the deadline: the startup file alone applies, and the overlay is set aside");
}
}
let who = Attribution {
actor: Some("boot".into()),
..Attribution::default()
};
let revision = me.revision.load(Ordering::Relaxed);
let event = change_event(
&me.device,
revision,
None,
ChangeOutcome::RolledBack,
edits,
&who,
);
me.events.lock().await.push(event);
me.changed.notify_waiters();
})
}
fn edits(
&self,
group: &str,
before: &Effective,
after: &Effective,
asked: &BTreeMap<String, ConfigValue>,
) -> Vec<Edit> {
let sensitive = |name: &str| {
self.schema
.group(group)
.and_then(|g| g.parameter(name))
.is_some_and(|p| p.sensitive)
};
asked
.keys()
.map(|name| {
let parameter = format!("{group}/{name}");
if sensitive(name) {
return Edit::redacted(parameter);
}
let value = |e: &Effective| {
e.get(group)
.and_then(|m| m.get(name))
.map(modem_contract::config::value)
};
Edit::of(parameter, value(before), value(after))
})
.collect()
}
}
fn change_event(
device: &str,
revision: u64,
token: Option<&str>,
outcome: ChangeOutcome,
edits: Vec<Edit>,
who: &Attribution,
) -> ConfigChangeEvent {
let mut event = ConfigChangeEvent::new(device, revision, outcome, edits);
if let Some(t) = token {
event = event.token(t);
}
if let Some(a) = &who.actor {
event = event.actor(a);
}
if let Some(r) = &who.request_id {
event = event.request_id(r);
}
if let Some(c) = &who.claimed_source {
event = event.claimed_source(c);
}
event
}
pub(super) async fn publish_loop(
session: Session,
origin: LocalOrigin,
state: Arc<ConfigState>,
ttl_s: u64,
) {
let subject = Subject::config(&state.device);
let doc_key = key(&origin, &subject);
let qos = subject.qos();
let refresh = Duration::from_secs((ttl_s / 2).max(1));
let counter = AtomicU64::new(0);
let mut bucket = Bucket::new(Instant::now());
let mut folded: Option<ConfigChangeEvent> = None;
let mut first = true;
loop {
crate::state::put(&session, &doc_key, &state.view(), qos).await;
let queued = if first {
first = false;
Vec::new()
} else {
std::mem::take(&mut *state.events.lock().await)
};
let now = Instant::now();
for event in folded.take().into_iter().chain(queued) {
if bucket.take(now) {
publish_event(&session, &origin, &state.device, &counter, &event).await;
} else {
folded = Some(event);
}
}
for words in std::mem::take(&mut *state.faults.lock().await) {
let event_id = ulid(&counter);
let subject = Subject::device_device_fault(&state.device, &event_id);
let doc = super::DeviceFault::of(
&state.device,
event_id,
now_ms(),
&modem_device::DeviceEvent::raised(words),
1,
);
crate::events::publish(&session, &origin, &subject, &doc, "device_fault").await;
}
let wake = if folded.is_some() {
bucket.next_at(now).min(now + refresh)
} else {
now + refresh
};
tokio::select! {
() = state.changed.notified() => {}
() = tokio::time::sleep_until(wake) => {}
}
}
}
async fn publish_event(
session: &Session,
origin: &LocalOrigin,
device: &str,
counter: &AtomicU64,
event: &ConfigChangeEvent,
) {
let event_id = ulid(counter);
let subject = Subject::device_config_change(device, &event_id);
crate::events::publish(session, origin, &subject, event, "config_change").await;
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_event_is_the_conventions() {
let edits = vec![
Edit::of(
"poll/signal_poll_s",
Some(ParamValue::Integer(60)),
Some(ParamValue::Integer(30)),
),
Edit::redacted("auth/pin"),
];
let who = Attribution {
actor: Some("marc".into()),
request_id: Some("r-1".into()),
claimed_source: None,
};
let event = change_event("sat0", 1, None, ChangeOutcome::Applied, edits, &who);
assert_eq!(
serde_json::to_value(&event).expect("serializes"),
serde_json::json!({
"resource": "sat0",
"revision": 1,
"outcome": "applied",
"edits": [
{ "parameter": "poll/signal_poll_s", "old": 60, "new": 30 },
{ "parameter": "auth/pin", "redacted": true },
],
"actor": "marc",
"request_id": "r-1",
}),
"the change event's wire shape moved"
);
let rolled = change_event(
"sat0",
2,
Some("t-1"),
ChangeOutcome::RolledBack,
Vec::new(),
&Attribution::default(),
);
assert_eq!(
serde_json::to_value(&rolled).expect("serializes"),
serde_json::json!({
"resource": "sat0", "revision": 2, "token": "t-1",
"outcome": "rolled-back", "edits": [],
})
);
}
}