surma/sausage
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

core: review fixes, init builds the agent, console without a terminal

Browse Source 
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.
This commit is contained in:
surma
2026-10-23 02:25:03 +01:00
parent 53b90a8ecf
commit d7b78ed0fd
27 changed files with 1800 additions and 352 deletions
Download Patch File Download Diff File Expand all files Collapse all files
cli/src/process.rs
+33 -11
View File
@@ -51,12 +51,16 @@ impl Host {
let process = state.processes.remove(pid);
if let Some(p) = process {
self.0.journal.write(pid, &p.info.plugin, "core", status);
let logs = self.0.journal.query_later(json!({"pid":pid,"limit":20}));
let logs = p
.answer
.as_ref()
.map(|_| self.0.journal.query_later(json!({"pid":pid,"limit":20})));
self.0.journal.forget(pid);
Self::release_locks(&mut state, pid);
let status = status.to_string();
tokio::spawn(async move {
let lines = logs.await.expect("journal writer stopped");
if let Some(answer) = p.answer {
let lines = logs.unwrap().await.unwrap_or_else(|_| json!([]));
let failure = json!({
"code": -32002,
"message": "process ended without an answer",
@@ -89,6 +93,9 @@ impl Host {
p.info.state = "stopping".into();
p.input.take();
self.0.journal.write(pid, &p.info.plugin, "core", "stop");
for lock in state.locks.values_mut() {
lock.queue.retain(|(queued, _)| queued != pid);
}
let children: Vec<_> = state
.processes
.iter()
@@ -109,7 +116,11 @@ impl Host {
}
/// Abort a process task and perform its ended-state cleanup.
pub(crate) fn kill(&self, pid: &str) {
if let Some(p) = self.0.state.lock().unwrap().processes.get_mut(pid) {
let mut state = self.0.state.lock().unwrap();
for lock in state.locks.values_mut() {
lock.queue.retain(|(queued, _)| queued != pid);
}
if let Some(p) = state.processes.get_mut(pid) {
p.info.state = "stopping".into();
p.input.take();
self.0.journal.write(pid, &p.info.plugin, "core", "kill");
@@ -120,15 +131,26 @@ impl Host {
}
/// Stop every process in parallel and wait for journal writes to finish.
pub async fn stop(&self) {
let ids: Vec<_> = self.processes().into_keys().collect();
let mut waits = Vec::new();
for pid in ids {
if let Some(n) = self.begin_stop(&pid) {
waits.push(n);
}
{
let _state = self.0.state.lock().unwrap();
self.0
.shutdown
.store(true, std::sync::atomic::Ordering::SeqCst);
}
for mut n in waits {
let _ = n.wait_for(|ended| *ended).await;
loop {
let ids: Vec<_> = self.processes().into_keys().collect();
if ids.is_empty() {
break;
}
let mut waits = Vec::new();
for pid in ids {
if let Some(n) = self.begin_stop(&pid) {
waits.push(n);
}
}
for mut n in waits {
let _ = n.wait_for(|ended| *ended).await;
}
}
self.0.journal.query(json!({"limit":0})).await;
}