surma
d7b78ed0fd
Activation path (review T6R): a broken plugin or a stray file in /plugins blocks no activation; candidates replace their own entries; discovery has a 10 s deadline and its process is stopped after the answer; an unchanged hash keeps plugin.prev.wasm; activations run in their own task; the watcher is not recursive; no duplicate services; rpc.retired waits for live processes of its version; reads and hashes on blocking threads. Guest I/O and per-call paths: a stdin write error is EOF, stdout and stderr are drained before the status; stderr is lossy UTF-8 and goes to the journal from its own reader; compiled components are freed; shutdown starts no new processes; lock queues drop stopping processes; compile before the admission gate; CommandPre per component; core.unlock in order; null errors are successes; the journal thread survives SQLite errors. sausage init builds the agent with cargo.build; sausage without a command creates ./world. The console reads plain lines without a terminal. PROTOCOL.md and DECISIONS.md describe the decided rules. The flake tests the whole workspace and checks the packaged cargo.build.
91 lines
2.9 KiB
Rust
91 lines
2.9 KiB
Rust
//! Advisory FIFO locks and cleanup of ended processes.
|
|
use crate::error;
|
|
use crate::{Host, RpcResult, host::State};
|
|
use serde_json::json;
|
|
use std::collections::VecDeque;
|
|
use tokio::sync::oneshot;
|
|
|
|
pub(crate) struct Lock {
|
|
pub(crate) owner: String,
|
|
pub(crate) queue: VecDeque<(String, oneshot::Sender<RpcResult>)>,
|
|
}
|
|
|
|
impl Host {
|
|
/// Acquire a FIFO queue position, or report whether the lock is free.
|
|
pub(crate) async fn lock(&self, caller: &str, path: &str, wait: bool) -> RpcResult {
|
|
let rx = {
|
|
let mut state = self.0.state.lock().unwrap();
|
|
if caller != "console"
|
|
&& caller != "core"
|
|
&& !state
|
|
.processes
|
|
.get(caller)
|
|
.is_some_and(|p| p.info.state == "running")
|
|
{
|
|
return Err(error(-32600, "process is stopping or ended"));
|
|
}
|
|
if let Some(lock) = state.locks.get_mut(path) {
|
|
if !wait {
|
|
return Ok(json!({"held":false}));
|
|
}
|
|
let (tx, rx) = oneshot::channel();
|
|
lock.queue.push_back((caller.into(), tx));
|
|
Some(rx)
|
|
} else {
|
|
state.locks.insert(
|
|
path.into(),
|
|
Lock {
|
|
owner: caller.into(),
|
|
queue: VecDeque::new(),
|
|
},
|
|
);
|
|
None
|
|
}
|
|
};
|
|
match rx {
|
|
Some(rx) => rx
|
|
.await
|
|
.unwrap_or_else(|_| Err(error(-32603, "lock canceled"))),
|
|
None => Ok(json!({"held":true})),
|
|
}
|
|
}
|
|
/// Release a held lock only when this process owns it.
|
|
pub(crate) fn unlock(&self, caller: &str, path: &str) {
|
|
let mut state = self.0.state.lock().unwrap();
|
|
if state
|
|
.locks
|
|
.get(path)
|
|
.is_some_and(|lock| lock.owner == caller)
|
|
{
|
|
grant(&mut state, path);
|
|
}
|
|
}
|
|
|
|
/// Remove queued acquisitions and grant the next owner of each held lock.
|
|
pub(crate) fn release_locks(state: &mut State, pid: &str) {
|
|
for lock in state.locks.values_mut() {
|
|
lock.queue.retain(|(p, _)| p != pid);
|
|
}
|
|
let paths: Vec<_> = state
|
|
.locks
|
|
.iter()
|
|
.filter(|(_, l)| l.owner == pid)
|
|
.map(|(p, _)| p.clone())
|
|
.collect();
|
|
for path in paths {
|
|
grant(state, &path);
|
|
}
|
|
}
|
|
}
|
|
pub(crate) fn grant(state: &mut State, path: &str) {
|
|
if let Some(mut lock) = state.locks.remove(path) {
|
|
while let Some((owner, tx)) = lock.queue.pop_front() {
|
|
if tx.send(Ok(json!({"held":true}))).is_ok() {
|
|
lock.owner = owner;
|
|
state.locks.insert(path.into(), lock);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|