Add armed plugin-originated file watches across VFS mutations
Register core.watch before its armed notification, coalesce later changes without losing post-notification writes, and clean up on caller death. Observe mounted layers and open file handles, including descriptor/stream writes, truncation, both rename paths and deletion. Track cancelled mutations through process idle and retain visible paths across renames. Document the protocol, expose native core discovery, and exercise watches through SDK callbacks and raw WASI filesystem operations. Card: SAU-359
This commit is contained in:
SAU-359 implementer
+26
@@ -219,6 +219,7 @@ these areas fails.
|
||||
/proc/
|
||||
core/
|
||||
PROTOCOL.md this file
|
||||
discover.json core.rpc.discover document
|
||||
graph.json plugins, imports, and the result of each check
|
||||
graph.dot the same graph for Graphviz
|
||||
locks.json held locks and waiting processes
|
||||
@@ -246,6 +247,29 @@ Rules:
|
||||
|
||||
Principle: **inspect through files, act through calls.**
|
||||
|
||||
### File watching
|
||||
|
||||
`core.watch {"path": "/state/session/mailbox"}` stays open for the caller
|
||||
process's lifetime. It needs a request ID and a running plugin caller.
|
||||
Its first `core.notify` is `"armed"`, with empty params. Only then scan the
|
||||
files. Writes before arming are visible in that scan; writes after arming
|
||||
produce `"changed"` notifications (also with empty params). Rescan after
|
||||
each notification; files, not event counts, are the truth.
|
||||
|
||||
Notifications follow successful plugin-originated file mutations: creation,
|
||||
truncation, descriptor/stream writes, rename (both source and destination),
|
||||
and deletion, including mounted `/run` and `/self` files. Paths are normalized
|
||||
in the virtual namespace; `/self` means the caller's `/proc/<pid>` folder.
|
||||
A watch matches itself and descendants, not sibling prefixes. Moving or
|
||||
removing an ancestor also invalidates it. Paths need not exist when armed.
|
||||
Open file writes follow plugin renames; unlinked/replaced handles no longer
|
||||
name visible files. External host writes are outside this contract.
|
||||
|
||||
Changes may coalesce, including a change already visible in the initial
|
||||
scan, but a change after the last notification always produces another.
|
||||
Delivery holds no filesystem locks. The watch ends with its caller; there
|
||||
is no cancellation API or polling/retry loop.
|
||||
|
||||
## 5. Endpoints
|
||||
|
||||
An endpoint is a JSON-RPC interface that a running process serves over TCP,
|
||||
@@ -333,7 +357,9 @@ At start, the core starts each service in `/config/boot.yaml`, in order:
|
||||
|
||||
| Method | Params | Result |
|
||||
| --- | --- | --- |
|
||||
| `core.rpc.discover` | none | OpenRPC core API document (also `/proc/core/discover.json`) |
|
||||
| `core.call` | `method`, `params`, `detach`? | the result of the method |
|
||||
| `core.watch` | `path` | stays open; `armed`, then `changed` notifications (section 4) |
|
||||
| `core.notify` | `name`, `params` | none (a notification) |
|
||||
| `core.stop` | `pid` | `{}` when the process has ended |
|
||||
| `core.kill` | `pid` | `{}` |
|
||||
|
||||
@@ -0,0 +1,19 @@
|
||||
{
|
||||
"openrpc": "1.2.6",
|
||||
"info": {"title":"core", "version":"0.1.0"},
|
||||
"methods": [
|
||||
{"name": "rpc.discover", "summary": "Describe the native core API.", "description": "Describe the native core API.", "paramStructure": "by-name", "params": [], "result": {"name": "result", "schema": {"type": "object"}}},
|
||||
{"name": "watch", "summary": "Keep this call open until the caller process ends. First core.notify is armed, then changed after successful plugin-originated file mutations. Scan only after armed; rescan after changed. Events may coalesce; files are the truth. No polling or cancellation API. See PROTOCOL section 4.", "description": "Keep this call open until the caller process ends. First core.notify is armed, then changed after successful plugin-originated file mutations. Scan only after armed; rescan after changed. Events may coalesce; files are the truth. No polling or cancellation API. See PROTOCOL section 4.", "paramStructure": "by-name", "params": [{"name": "path", "required": true, "description": "Virtual file or directory path, including descendants; need not exist. /self is relative to the caller.", "schema": {"type": "string"}}], "result": {"name": "result", "schema": {"type": "null"}}},
|
||||
{"name": "call", "summary": "Make a call and return its result; detach lets the new process outlive its caller.", "description": "Make a call and return its result; detach lets the new process outlive its caller.", "paramStructure": "by-name", "params": [{"name": "method", "required": true, "description": "Qualified method.", "schema": {"type": "string"}}, {"name": "params", "required": true, "description": "Named parameters.", "schema": {"type": "object"}}, {"name": "detach", "required": false, "description": "Detach the new process.", "schema": {"type": "boolean"}}], "result": {"name": "result", "schema": {}}},
|
||||
{"name": "notify", "summary": "Notify this process's caller while its call is open.", "description": "Notify this process's caller while its call is open.", "paramStructure": "by-name", "params": [{"name": "name", "required": true, "description": "Event name.", "schema": {"type": "string"}}, {"name": "params", "required": false, "description": "Event payload.", "schema": {}}], "result": {"name": "result", "schema": {"type": "null"}}},
|
||||
{"name": "stop", "summary": "End a process and await cleanup.", "description": "End a process and await cleanup.", "paramStructure": "by-name", "params": [{"name": "pid", "required": true, "description": "Process ID.", "schema": {"type": "string"}}], "result": {"name": "result", "schema": {"type": "object"}}},
|
||||
{"name": "kill", "summary": "End a process and await cleanup.", "description": "End a process and await cleanup.", "paramStructure": "by-name", "params": [{"name": "pid", "required": true, "description": "Process ID.", "schema": {"type": "string"}}], "result": {"name": "result", "schema": {"type": "object"}}},
|
||||
{"name": "lock", "summary": "Acquire a FIFO process-lifetime lock.", "description": "Acquire a FIFO process-lifetime lock.", "paramStructure": "by-name", "params": [{"name": "path", "required": true, "description": "Lock key.", "schema": {"type": "string"}}, {"name": "wait", "required": false, "description": "Wait for acquisition (default true).", "schema": {"type": "boolean"}}], "result": {"name": "result", "schema": {"type": "object", "properties": {"held": {"type": "boolean"}}, "required": ["held"]}}},
|
||||
{"name": "unlock", "summary": "Release an owned lock.", "description": "Release an owned lock.", "paramStructure": "by-name", "params": [{"name": "path", "required": true, "description": "Lock key.", "schema": {"type": "string"}}], "result": {"name": "result", "schema": {"type": "null"}}},
|
||||
{"name": "activate", "summary": "Install one or more checked plugin versions. See PROTOCOL section 10.", "description": "Install one or more checked plugin versions. See PROTOCOL section 10.", "paramStructure": "by-name", "params": [{"name": "plugin", "required": false, "description": "Single plugin name.", "schema": {"type": "string"}}, {"name": "wasm", "required": false, "description": "Candidate path.", "schema": {"type": "string"}}, {"name": "plugins", "required": false, "description": "Batch candidates.", "schema": {"type": "array", "items": {"type": "object", "properties": {"plugin": {"type": "string"}, "wasm": {"type": "string"}}, "required": ["plugin", "wasm"]}}}, {"name": "force", "required": false, "description": "Skip compatibility rejection.", "schema": {"type": "boolean"}}], "result": {"name": "result", "schema": {"type": "object"}}},
|
||||
{"name": "revert", "summary": "Restore the previous plugin version.", "description": "Restore the previous plugin version.", "paramStructure": "by-name", "params": [{"name": "plugin", "required": true, "description": "Plugin name.", "schema": {"type": "string"}}, {"name": "force", "required": false, "description": "Skip compatibility rejection.", "schema": {"type": "boolean"}}], "result": {"name": "result", "schema": {"type": "object"}}},
|
||||
{"name": "log", "summary": "Read the central journal (PROTOCOL section 7).", "description": "Read the central journal (PROTOCOL section 7).", "paramStructure": "by-name", "params": [{"name": "pid", "required": false, "description": "Process ID.", "schema": {"type": "string"}}, {"name": "plugin", "required": false, "description": "Plugin name.", "schema": {"type": "string"}}, {"name": "since", "required": false, "description": "ISO 8601 start time.", "schema": {"type": "string"}}, {"name": "until", "required": false, "description": "ISO 8601 end time.", "schema": {"type": "string"}}, {"name": "grep", "required": false, "description": "Line substring.", "schema": {"type": "string"}}, {"name": "limit", "required": false, "description": "Maximum entries (default 100).", "schema": {"type": "integer"}}], "result": {"name": "result", "schema": {"type": "array", "items": {"type": "object"}}}},
|
||||
{"name": "restart", "summary": "Request clean host restart through the loop supervisor; needs explicit operator approval.", "description": "Request clean host restart through the loop supervisor; needs explicit operator approval.", "paramStructure": "by-name", "params": [], "result": {"name": "result", "schema": {"type": "object"}}},
|
||||
{"name": "exit", "summary": "Request clean host restart through the loop supervisor; needs explicit operator approval.", "description": "Request clean host restart through the loop supervisor; needs explicit operator approval.", "paramStructure": "by-name", "params": [], "result": {"name": "result", "schema": {"type": "object"}}}
|
||||
]
|
||||
}
|
||||
@@ -12,6 +12,8 @@ impl Host {
|
||||
p: Value,
|
||||
) -> RpcResult {
|
||||
match method {
|
||||
"rpc.discover" => Ok(serde_json::from_str(include_str!("core.json")).unwrap()),
|
||||
"watch" => self.watch(caller, id, required_str(&p, "path")?).await,
|
||||
"call" => {
|
||||
self.route(
|
||||
caller.into(),
|
||||
|
||||
+28
-7
@@ -47,27 +47,48 @@ impl Host {
|
||||
tracker: Process,
|
||||
) -> anyhow::Result<Mounts> {
|
||||
let root = self.0.world.root.clone();
|
||||
let operations = tracker.clone();
|
||||
let host = tracker
|
||||
.clone()
|
||||
.blocking(move || sausage_vfs::Host::new(root, tracker))
|
||||
.await?;
|
||||
let mut mounts = Mounts::default();
|
||||
mounts.mount("/", Arc::new(host), false);
|
||||
mounts.mount(
|
||||
"/",
|
||||
self.0
|
||||
.observer
|
||||
.layer(Arc::new(host), "/", operations.clone()),
|
||||
false,
|
||||
);
|
||||
mounts.mount("/proc", Arc::new(Proc(self.clone())), true);
|
||||
mounts.mount(
|
||||
"/self",
|
||||
Arc::new(SelfFolder {
|
||||
host: self.clone(),
|
||||
pid,
|
||||
memory,
|
||||
}),
|
||||
self.0.observer.layer(
|
||||
Arc::new(SelfFolder {
|
||||
host: self.clone(),
|
||||
pid: pid.clone(),
|
||||
memory,
|
||||
}),
|
||||
&format!("/proc/{}", pid.as_deref().unwrap_or("console")),
|
||||
operations.clone(),
|
||||
),
|
||||
false,
|
||||
);
|
||||
mounts.mount(
|
||||
"/run",
|
||||
self.0
|
||||
.observer
|
||||
.layer(Arc::new(self.0.run.clone()), "/run", operations),
|
||||
false,
|
||||
);
|
||||
mounts.mount("/run", Arc::new(self.0.run.clone()), false);
|
||||
Ok(mounts)
|
||||
}
|
||||
fn core_files(&self) -> Generated {
|
||||
let mut files = Generated::default();
|
||||
files.insert(
|
||||
"/discover.json",
|
||||
|| Ok(include_bytes!("core.json").to_vec()),
|
||||
);
|
||||
let protocol = include_bytes!("../../PROTOCOL.md");
|
||||
files.insert("/PROTOCOL.md", move || Ok(protocol.to_vec()));
|
||||
let graph = self.graph_json();
|
||||
|
||||
@@ -37,6 +37,8 @@ pub(crate) struct Inner {
|
||||
/// processes, and upgrade tasks do nothing.
|
||||
pub(crate) shutdown: std::sync::atomic::AtomicBool,
|
||||
pub(crate) run: sausage_vfs::Memory,
|
||||
pub(crate) watches: crate::watches::Watches,
|
||||
pub(crate) observer: sausage_vfs::observe::Observer,
|
||||
pub(crate) graph: Mutex<crate::graph::Graph>,
|
||||
pub(crate) activations: tokio::sync::Mutex<()>,
|
||||
pub(crate) watcher: Mutex<Option<notify::RecommendedWatcher>>,
|
||||
@@ -91,6 +93,10 @@ impl Host {
|
||||
))
|
||||
}
|
||||
fn with_parts(world: World, runtime: Arc<Runtime>, journal: journal::Journal) -> Self {
|
||||
let watches = crate::watches::Watches::default();
|
||||
let events = watches.clone();
|
||||
let observer =
|
||||
sausage_vfs::observe::Observer::new(move |path| crate::watches::changed(&events, path));
|
||||
Self(Arc::new(Inner {
|
||||
world,
|
||||
runtime,
|
||||
@@ -109,6 +115,8 @@ impl Host {
|
||||
admission: tokio::sync::RwLock::new(()),
|
||||
shutdown: std::sync::atomic::AtomicBool::new(false),
|
||||
run: sausage_vfs::Memory::default(),
|
||||
watches,
|
||||
observer,
|
||||
graph: Mutex::new(crate::graph::Graph::default()),
|
||||
activations: tokio::sync::Mutex::new(()),
|
||||
watcher: Mutex::new(None),
|
||||
|
||||
@@ -18,6 +18,7 @@ pub mod runtime;
|
||||
mod services;
|
||||
mod upgrades;
|
||||
mod watcher;
|
||||
mod watches;
|
||||
pub mod world;
|
||||
pub use host::Host;
|
||||
pub use native::{NativeContext, NativeFuture, NativePlugin};
|
||||
|
||||
+12
-7
@@ -51,15 +51,20 @@ impl Host {
|
||||
.processes
|
||||
.get(pid)
|
||||
.and_then(|p| p.answer.as_ref().map(|_| (p.caller.clone(), p.id.clone())));
|
||||
if let Some((caller, id)) = target {
|
||||
let notification = json!({
|
||||
"jsonrpc": "2.0",
|
||||
"method": "core.notify",
|
||||
"params": { "call": id, "name": name, "params": params }
|
||||
});
|
||||
self.send(&caller, notification);
|
||||
if let Some((caller, Some(id))) = target {
|
||||
self.call_notify(&caller, &id, name, params);
|
||||
}
|
||||
}
|
||||
/// Deliver a notification on an open core call using the same envelope as plugin progress.
|
||||
pub(crate) fn call_notify(&self, caller: &str, id: &Value, name: &str, params: Value) {
|
||||
self.send(
|
||||
caller,
|
||||
json!({
|
||||
"jsonrpc":"2.0", "method":"core.notify",
|
||||
"params": {"call":id, "name":name, "params":params}
|
||||
}),
|
||||
);
|
||||
}
|
||||
/// Validate and route a request, then start its native or WASI process.
|
||||
pub(crate) fn route(
|
||||
&self,
|
||||
|
||||
@@ -0,0 +1,178 @@
|
||||
//! Armed plugin-file watches. A Notify permit coalesces changes without losing a later change.
|
||||
use crate::{Host, RpcResult, error};
|
||||
use sausage_vfs::observe::under;
|
||||
use serde_json::{Value, json};
|
||||
use std::{
|
||||
collections::HashMap,
|
||||
sync::{Arc, Mutex},
|
||||
};
|
||||
use tokio::sync::Notify;
|
||||
use uuid::Uuid;
|
||||
|
||||
pub(crate) struct Watch {
|
||||
path: String,
|
||||
changed: Arc<Notify>,
|
||||
}
|
||||
pub(crate) type Watches = Arc<Mutex<HashMap<Uuid, Watch>>>;
|
||||
pub(crate) fn changed(watches: &Watches, path: &str) {
|
||||
let targets: Vec<_> = watches
|
||||
.lock()
|
||||
.unwrap()
|
||||
.values()
|
||||
// Removing/moving an ancestor also invalidates a watch inside that subtree.
|
||||
.filter(|w| under(path, &w.path) || under(&w.path, path))
|
||||
.map(|w| w.changed.clone())
|
||||
.collect();
|
||||
for changed in targets {
|
||||
changed.notify_one();
|
||||
}
|
||||
}
|
||||
struct Registration {
|
||||
watches: Watches,
|
||||
key: Uuid,
|
||||
}
|
||||
impl Drop for Registration {
|
||||
fn drop(&mut self) {
|
||||
self.watches.lock().unwrap().remove(&self.key);
|
||||
}
|
||||
}
|
||||
fn path(caller: &str, path: &str) -> String {
|
||||
let path = sausage_vfs::resolve("/", path);
|
||||
let path = path.trim_end_matches('/');
|
||||
if path.is_empty() {
|
||||
return "/".into();
|
||||
}
|
||||
if under(path, "/self") {
|
||||
format!("/proc/{caller}{}", &path[5..])
|
||||
} else {
|
||||
path.into()
|
||||
}
|
||||
}
|
||||
impl Host {
|
||||
pub(crate) async fn watch(&self, caller: &str, id: Option<Value>, target: &str) -> RpcResult {
|
||||
let id = id.ok_or_else(|| error(-32600, "watch needs a request ID"))?;
|
||||
let mut ended = self
|
||||
.0
|
||||
.state
|
||||
.lock()
|
||||
.unwrap()
|
||||
.processes
|
||||
.get(caller)
|
||||
.filter(|p| p.info.state == "running")
|
||||
.map(|p| p.ended.subscribe())
|
||||
.ok_or_else(|| error(-32600, "watch needs a running caller process"))?;
|
||||
let changed = Arc::new(Notify::new());
|
||||
let registration = Registration {
|
||||
watches: self.0.watches.clone(),
|
||||
key: Uuid::now_v7(),
|
||||
};
|
||||
self.0.watches.lock().unwrap().insert(
|
||||
registration.key,
|
||||
Watch {
|
||||
path: path(caller, target),
|
||||
changed: changed.clone(),
|
||||
},
|
||||
);
|
||||
self.call_notify(caller, &id, "armed", json!({}));
|
||||
loop {
|
||||
tokio::select! {
|
||||
biased;
|
||||
_ = ended.wait_for(|ended| *ended) => return Ok(Value::Null),
|
||||
_ = changed.notified() => self.call_notify(caller, &id, "changed", json!({})),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
/// Pending changes coalesce; a change after consuming the last permit is retained.
|
||||
#[tokio::test]
|
||||
async fn coalescing_and_cleanup() {
|
||||
let watches = Watches::default();
|
||||
let n = Arc::new(Notify::new());
|
||||
let r = Registration {
|
||||
watches: watches.clone(),
|
||||
key: Uuid::now_v7(),
|
||||
};
|
||||
watches.lock().unwrap().insert(
|
||||
r.key,
|
||||
Watch {
|
||||
path: "/mailbox".into(),
|
||||
changed: n.clone(),
|
||||
},
|
||||
);
|
||||
changed(&watches, "/mailboxes/a");
|
||||
assert!(
|
||||
tokio::time::timeout(std::time::Duration::ZERO, n.notified())
|
||||
.await
|
||||
.is_err()
|
||||
);
|
||||
changed(&watches, "/mailbox/a");
|
||||
changed(&watches, "/mailbox/b");
|
||||
n.notified().await;
|
||||
assert!(
|
||||
tokio::time::timeout(std::time::Duration::ZERO, n.notified())
|
||||
.await
|
||||
.is_err()
|
||||
);
|
||||
changed(&watches, "/mailbox/c");
|
||||
n.notified().await;
|
||||
drop(r);
|
||||
assert!(watches.lock().unwrap().is_empty());
|
||||
changed(&watches, "/mailbox/d");
|
||||
assert!(
|
||||
tokio::time::timeout(std::time::Duration::ZERO, n.notified())
|
||||
.await
|
||||
.is_err()
|
||||
);
|
||||
}
|
||||
#[test]
|
||||
fn self_alias_and_normalization() {
|
||||
assert_eq!(path("writer", "/self/../self/a/"), "/proc/writer/a");
|
||||
assert_eq!(path("writer", "/selfish/a"), "/selfish/a");
|
||||
assert_eq!(path("writer", "/"), "/");
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod lifetime_tests {
|
||||
use super::*;
|
||||
/// The real caller's ended event releases the registration, without a cancellation RPC.
|
||||
#[tokio::test]
|
||||
async fn caller_death_removes_watch() {
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
let runtime = crate::runtime::Runtime::new(&temp.path().join("cache")).unwrap();
|
||||
let host = Host::test_world(&temp.path().join("world"), runtime)
|
||||
.await
|
||||
.unwrap();
|
||||
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
|
||||
host.register_native(
|
||||
"holder",
|
||||
Arc::new(move |ctx, _, _| {
|
||||
let tx = tx.clone();
|
||||
Box::pin(async move {
|
||||
tx.send(ctx.pid.clone()).unwrap();
|
||||
std::future::pending().await
|
||||
})
|
||||
}),
|
||||
);
|
||||
let h = host.clone();
|
||||
let task = tokio::spawn(async move { h.call("holder.hold", json!({})).await });
|
||||
let pid = rx.recv().await.unwrap();
|
||||
let mut watch = Box::pin(host.watch(&pid, Some(json!("watch")), "/mailbox"));
|
||||
assert!(
|
||||
watch
|
||||
.as_mut()
|
||||
.poll(&mut std::task::Context::from_waker(std::task::Waker::noop()))
|
||||
.is_pending()
|
||||
);
|
||||
assert_eq!(host.0.watches.lock().unwrap().len(), 1);
|
||||
host.call("core.kill", json!({"pid":pid})).await.unwrap();
|
||||
watch.await.unwrap();
|
||||
assert!(host.0.watches.lock().unwrap().is_empty());
|
||||
assert!(task.await.unwrap().is_err());
|
||||
host.stop().await;
|
||||
}
|
||||
}
|
||||
@@ -7,3 +7,4 @@ mod common;
|
||||
mod console;
|
||||
mod core;
|
||||
mod sdk;
|
||||
mod watches;
|
||||
|
||||
@@ -0,0 +1,195 @@
|
||||
//! Real SDK watch callbacks and raw WASI filesystem mutations share the host namespace.
|
||||
use super::common::{CACHE, probe, sdk_probe};
|
||||
use sausage::{Host, world::World};
|
||||
use serde_json::{Value, json};
|
||||
use std::time::Duration;
|
||||
|
||||
// Same call bound as core.rs; no sleeps or polling.
|
||||
async fn call(h: &Host, method: &str, p: Value) -> Value {
|
||||
tokio::time::timeout(Duration::from_secs(20), h.call(method, p))
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap()
|
||||
}
|
||||
async fn event(h: &Host, rx: &mut tokio::sync::broadcast::Receiver<Value>, name: &str) -> Value {
|
||||
let result = tokio::time::timeout(Duration::from_secs(20), async {
|
||||
loop {
|
||||
let e = rx.recv().await.unwrap();
|
||||
if e["params"]["name"] == name {
|
||||
return e["params"]["params"].clone();
|
||||
}
|
||||
}
|
||||
})
|
||||
.await;
|
||||
match result {
|
||||
Ok(v) => v,
|
||||
Err(e) => {
|
||||
eprintln!(
|
||||
"JOURNAL {}",
|
||||
h.call("core.log", json!({"limit":100})).await.unwrap()
|
||||
);
|
||||
panic!("{e}");
|
||||
}
|
||||
}
|
||||
}
|
||||
async fn start() -> (tempfile::TempDir, Host) {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let world = World::create(&dir.path().join("world")).unwrap();
|
||||
for (name, wasm) in [("probe", probe()), ("sdk", sdk_probe())] {
|
||||
std::fs::create_dir_all(world.plugin_dir(name)).unwrap();
|
||||
std::fs::copy(wasm, world.plugin_dir(name).join("plugin.wasm")).unwrap();
|
||||
}
|
||||
let host = Host::start_with_cache(&world.root, std::path::Path::new(CACHE))
|
||||
.await
|
||||
.unwrap();
|
||||
(dir, host)
|
||||
}
|
||||
fn watch(h: &Host, path: &str) -> tokio::task::JoinHandle<sausage::RpcResult> {
|
||||
let (h, path) = (h.clone(), path.to_owned());
|
||||
tokio::spawn(async move { h.call("sdk.watch", json!({"path":path})).await })
|
||||
}
|
||||
async fn mutate(h: &Host, op: &str, path: &str) {
|
||||
call(h, "probe.mutate", json!({"op":op,"path":path})).await;
|
||||
}
|
||||
/// PROTOCOL 4: pre-arm state is in the first scan; each post-scan mutation wakes
|
||||
/// the SDK without completing the watch. Covers descriptor/stream/truncate paths.
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn armed_scan_and_later_changes() {
|
||||
let (_dir, h) = start().await;
|
||||
mutate(&h, "mkdir", "/state/mailbox").await;
|
||||
call(
|
||||
&h,
|
||||
"probe.write",
|
||||
json!({"path":"/state/mailbox/before", "text":"before"}),
|
||||
)
|
||||
.await;
|
||||
let mut rx = h.subscribe();
|
||||
let task = watch(&h, "/state/mailbox/../mailbox/");
|
||||
let armed = event(&h, &mut rx, "armed").await;
|
||||
assert_eq!(armed["entries"], json!(["before"]));
|
||||
assert!(!task.is_finished());
|
||||
for (op, expected) in [
|
||||
("descriptor", "descriptor"),
|
||||
("stream", "streamptor"),
|
||||
("append", "streamptorappend"),
|
||||
("size", ""),
|
||||
("descriptor", "descriptor"),
|
||||
("truncate", ""),
|
||||
] {
|
||||
mutate(&h, op, "/state/mailbox/before").await;
|
||||
let mut scan = event(&h, &mut rx, "changed").await;
|
||||
while scan["text"] != expected {
|
||||
scan = event(&h, &mut rx, "changed").await;
|
||||
}
|
||||
}
|
||||
mutate(&h, "burst", "/state/mailbox").await;
|
||||
let mut scanned = event(&h, &mut rx, "changed").await;
|
||||
while !scanned["entries"].as_array().unwrap().contains(&json!("4")) {
|
||||
scanned = event(&h, &mut rx, "changed").await;
|
||||
}
|
||||
while rx.try_recv().is_ok() {}
|
||||
mutate(&h, "delete", "/state/mailbox/4").await;
|
||||
let mut scanned = event(&h, &mut rx, "changed").await;
|
||||
while scanned["entries"].as_array().unwrap().contains(&json!("4")) {
|
||||
scanned = event(&h, &mut rx, "changed").await;
|
||||
}
|
||||
call(&h, "core.kill", json!({"pid":armed["pid"]})).await;
|
||||
assert!(task.await.unwrap().is_err());
|
||||
h.stop().await;
|
||||
}
|
||||
/// PROTOCOL 4: atomic publication, rename source/destination, mounted paths,
|
||||
/// absent paths, and caller-death cleanup. No external host writes are required.
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn rename_delete_and_mounts() {
|
||||
let (_dir, h) = start().await;
|
||||
for base in ["/state/inbox", "/run/inbox"] {
|
||||
let mut rx = h.subscribe();
|
||||
let task = watch(&h, base);
|
||||
let armed = event(&h, &mut rx, "armed").await;
|
||||
assert_eq!(armed["entries"], json!([]));
|
||||
let staging = format!("{base}-staging");
|
||||
mutate(&h, "mkdir", &staging).await;
|
||||
call(
|
||||
&h,
|
||||
"probe.mutate",
|
||||
json!({"op":"rename","path":staging,"to":base}),
|
||||
)
|
||||
.await;
|
||||
event(&h, &mut rx, "changed").await;
|
||||
mutate(&h, "atomic", &format!("{base}/published")).await;
|
||||
let mut scan = event(&h, &mut rx, "changed").await;
|
||||
while !scan["entries"]
|
||||
.as_array()
|
||||
.unwrap()
|
||||
.contains(&json!("published"))
|
||||
{
|
||||
scan = event(&h, &mut rx, "changed").await;
|
||||
}
|
||||
assert_eq!(
|
||||
call(
|
||||
&h,
|
||||
"probe.read",
|
||||
json!({"path":format!("{base}/published")})
|
||||
)
|
||||
.await,
|
||||
"complete"
|
||||
);
|
||||
while rx.try_recv().is_ok() {}
|
||||
call(
|
||||
&h,
|
||||
"probe.mutate",
|
||||
json!({"op":"rename","path":base,"to":format!("{base}-moved")}),
|
||||
)
|
||||
.await;
|
||||
let mut scan = event(&h, &mut rx, "changed").await;
|
||||
while scan["entries"] != json!([]) {
|
||||
scan = event(&h, &mut rx, "changed").await;
|
||||
}
|
||||
call(&h, "core.kill", json!({"pid":armed["pid"]})).await;
|
||||
assert!(task.await.unwrap().is_err());
|
||||
}
|
||||
// /self watches bind to this caller, and mutations are visible via /proc/<pid>.
|
||||
let mut rx = h.subscribe();
|
||||
let task = watch(&h, "/self");
|
||||
let armed = event(&h, &mut rx, "armed").await;
|
||||
assert!(
|
||||
armed["entries"]
|
||||
.as_array()
|
||||
.unwrap()
|
||||
.contains(&json!("owned"))
|
||||
);
|
||||
event(&h, &mut rx, "changed").await;
|
||||
assert_eq!(
|
||||
call(
|
||||
&h,
|
||||
"probe.read",
|
||||
json!({"path":format!("/proc/{}/owned", armed["pid"].as_str().unwrap())})
|
||||
)
|
||||
.await,
|
||||
"visible via proc"
|
||||
);
|
||||
call(&h, "core.kill", json!({"pid":armed["pid"]})).await;
|
||||
assert!(task.await.unwrap().is_err());
|
||||
h.stop().await;
|
||||
}
|
||||
|
||||
/// PROTOCOL 9: core discovery includes the armed watch and matches its proc projection.
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn discovery() {
|
||||
let (_dir, h) = start().await;
|
||||
let doc = call(&h, "core.rpc.discover", json!({})).await;
|
||||
let projected = call(&h, "probe.read", json!({"path":"/proc/core/discover.json"})).await;
|
||||
assert_eq!(
|
||||
doc,
|
||||
serde_json::from_str::<Value>(projected.as_str().unwrap()).unwrap()
|
||||
);
|
||||
let watch = doc["methods"]
|
||||
.as_array()
|
||||
.unwrap()
|
||||
.iter()
|
||||
.find(|m| m["name"] == "watch")
|
||||
.unwrap();
|
||||
assert_eq!(watch["params"][0]["name"], "path");
|
||||
assert!(watch["description"].as_str().unwrap().contains("armed"));
|
||||
h.stop().await;
|
||||
}
|
||||
@@ -468,6 +468,7 @@ fn dispatch(request: &Value, lines: &mut Lines) -> Option<Value> {
|
||||
return None;
|
||||
}
|
||||
"network" => network(params),
|
||||
"mutate" => mutate(params),
|
||||
"read" => read_file(params),
|
||||
"write" => write_file(params),
|
||||
"raw_call" => {
|
||||
@@ -518,3 +519,68 @@ fn main() {
|
||||
}));
|
||||
}
|
||||
}
|
||||
|
||||
/// Separate mutation calls let the host await a scan before each subsequent change.
|
||||
fn mutate(p: &Value) -> Value {
|
||||
use wasip2::filesystem::{
|
||||
preopens,
|
||||
types::{DescriptorFlags as D, OpenFlags as O, PathFlags as P},
|
||||
};
|
||||
let path = p["path"].as_str().unwrap();
|
||||
match p["op"].as_str().unwrap() {
|
||||
"mkdir" => std::fs::create_dir_all(path).unwrap(),
|
||||
"rename" => std::fs::rename(path, p["to"].as_str().unwrap()).unwrap(),
|
||||
"delete" => std::fs::remove_file(path).unwrap(),
|
||||
"rmdir" => std::fs::remove_dir(path).unwrap(),
|
||||
"atomic" => {
|
||||
let temp = format!("{path}.tmp");
|
||||
std::fs::write(&temp, "complete").unwrap();
|
||||
std::fs::rename(temp, path).unwrap();
|
||||
}
|
||||
"burst" => {
|
||||
for i in 0..5 {
|
||||
std::fs::write(format!("{path}/{i}"), "complete").unwrap();
|
||||
}
|
||||
}
|
||||
op => {
|
||||
let root = preopens::get_directories().remove(0).0;
|
||||
let file = root
|
||||
.open_at(
|
||||
P::empty(),
|
||||
path.trim_start_matches('/'),
|
||||
O::empty(),
|
||||
D::READ | D::WRITE,
|
||||
)
|
||||
.unwrap();
|
||||
match op {
|
||||
"descriptor" => {
|
||||
file.write(b"descriptor", 0).unwrap();
|
||||
}
|
||||
"stream" => {
|
||||
file.write_via_stream(0)
|
||||
.unwrap()
|
||||
.blocking_write_and_flush(b"stream")
|
||||
.unwrap();
|
||||
}
|
||||
"append" => {
|
||||
file.append_via_stream()
|
||||
.unwrap()
|
||||
.blocking_write_and_flush(b"append")
|
||||
.unwrap();
|
||||
}
|
||||
"size" => file.set_size(0).unwrap(),
|
||||
"truncate" => {
|
||||
root.open_at(
|
||||
P::empty(),
|
||||
path.trim_start_matches('/'),
|
||||
O::TRUNCATE,
|
||||
D::WRITE,
|
||||
)
|
||||
.unwrap();
|
||||
}
|
||||
_ => panic!("unknown mutation"),
|
||||
}
|
||||
}
|
||||
}
|
||||
json!({})
|
||||
}
|
||||
|
||||
@@ -26,6 +26,11 @@ impl Call {
|
||||
self
|
||||
}
|
||||
/// Receive progress notifications before the result arrives.
|
||||
///
|
||||
/// For `core.watch`, await this call in a background task for the process's
|
||||
/// lifetime. Scan only after `armed`, and rescan on `changed`; events can
|
||||
/// coalesce. The call has no cancellation API. Do not use endpoint connect
|
||||
/// retries to wait for file publication.
|
||||
pub fn on_notify(mut self, f: impl FnMut(&str, Value) + 'static) -> Self {
|
||||
self.notify = Some(Box::new(f));
|
||||
self
|
||||
|
||||
@@ -2,6 +2,12 @@
|
||||
use sausage_plugin::serde_json::{Value, json};
|
||||
use sausage_plugin::{Ctx, Result, call, lock, rpc, schema};
|
||||
struct Probe;
|
||||
/// A virtual path to observe.
|
||||
#[schema]
|
||||
struct WatchPath {
|
||||
/// Directory or file, not necessarily present yet.
|
||||
path: String,
|
||||
}
|
||||
/// The values to add.
|
||||
#[schema]
|
||||
struct Add {
|
||||
@@ -30,6 +36,33 @@ struct Echo {
|
||||
}
|
||||
#[rpc(grace_seconds = 12,endpoints(control=Control))]
|
||||
impl Probe {
|
||||
/// Scan only after the watch is armed; keep the call open until process death.
|
||||
async fn watch(&self, p: WatchPath) -> Result<()> {
|
||||
let path = p.path.clone();
|
||||
call("core.watch", json!({"path":p.path}))
|
||||
.on_notify(move |name, _| {
|
||||
if name == "armed" && path == "/self" {
|
||||
std::fs::write("/self/owned", "visible via proc").unwrap();
|
||||
}
|
||||
let mut entries: Vec<_> = std::fs::read_dir(&path)
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.filter_map(std::result::Result::ok)
|
||||
.map(|e| e.file_name().into_string().unwrap())
|
||||
.collect();
|
||||
entries.sort();
|
||||
let text = std::fs::read_to_string(format!("{path}/before")).ok();
|
||||
Ctx::default()
|
||||
.notify(
|
||||
name,
|
||||
json!({"pid":sausage_plugin::pid(), "entries":entries, "text":text}),
|
||||
)
|
||||
.unwrap();
|
||||
})
|
||||
.await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Publish a control endpoint until EOF.
|
||||
async fn serve(&self) -> Result<()> {
|
||||
sausage_plugin::listen("/endpoint", std::rc::Rc::new(Control)).await
|
||||
|
||||
@@ -5,6 +5,7 @@ pub mod generated;
|
||||
pub mod host;
|
||||
pub mod memory;
|
||||
pub mod mounts;
|
||||
pub mod observe;
|
||||
pub mod process;
|
||||
mod readonly;
|
||||
mod streams;
|
||||
|
||||
@@ -0,0 +1,355 @@
|
||||
//! Observes successful namespace and open-file mutations, even if their caller is cancelled.
|
||||
use crate::*;
|
||||
use std::sync::{Mutex, Weak};
|
||||
|
||||
type TrackedPath = Mutex<Option<String>>;
|
||||
type Path = Arc<TrackedPath>;
|
||||
type Callback = dyn Fn(&str) + Send + Sync;
|
||||
/// Shared observation for mount namespaces. Paths supplied to the callback are virtual paths.
|
||||
/// Callbacks run after filesystem locks have been released; they must not block.
|
||||
#[derive(Clone)]
|
||||
pub struct Observer {
|
||||
changed: Arc<Callback>,
|
||||
paths: Arc<Mutex<Vec<Weak<TrackedPath>>>>,
|
||||
// Keep path rebasing and mutations in the same order across all namespaces.
|
||||
mutations: Arc<tokio::sync::Mutex<()>>,
|
||||
}
|
||||
impl Observer {
|
||||
pub fn new(changed: impl Fn(&str) + Send + Sync + 'static) -> Self {
|
||||
Self {
|
||||
changed: Arc::new(changed),
|
||||
paths: Arc::default(),
|
||||
mutations: Arc::default(),
|
||||
}
|
||||
}
|
||||
/// Wrap a layer at its canonical namespace prefix (e.g. `/run`).
|
||||
pub fn layer(&self, layer: Arc<dyn Layer>, prefix: &str, process: Process) -> Arc<dyn Layer> {
|
||||
Arc::new(Observed {
|
||||
layer,
|
||||
prefix: prefix.trim_end_matches('/').into(),
|
||||
observer: self.clone(),
|
||||
process,
|
||||
})
|
||||
}
|
||||
fn path(&self, path: String) -> Path {
|
||||
let path = Arc::new(Mutex::new(Some(path)));
|
||||
let mut paths = self.paths.lock().unwrap();
|
||||
paths.retain(|p| p.strong_count() != 0);
|
||||
paths.push(Arc::downgrade(&path));
|
||||
path
|
||||
}
|
||||
fn moved(&self, from: &str, to: Option<&str>) {
|
||||
let mut paths = self.paths.lock().unwrap();
|
||||
paths.retain(|p| {
|
||||
let Some(p) = p.upgrade() else { return false };
|
||||
let mut path = p.lock().unwrap();
|
||||
if let Some(old) = path.as_deref() {
|
||||
if under(old, from) {
|
||||
*path = to.map(|to| format!("{to}{}", &old[from.len()..]));
|
||||
} else if to.is_some_and(|to| under(old, to)) {
|
||||
// A replaced destination's old descriptor no longer names a visible file.
|
||||
*path = None;
|
||||
}
|
||||
}
|
||||
true
|
||||
});
|
||||
}
|
||||
}
|
||||
/// Component-aware descendant matching, including the path itself.
|
||||
pub fn under(path: &str, base: &str) -> bool {
|
||||
base == "/" || path == base || path.strip_prefix(base).is_some_and(|s| s.starts_with('/'))
|
||||
}
|
||||
struct Observed {
|
||||
layer: Arc<dyn Layer>,
|
||||
prefix: String,
|
||||
observer: Observer,
|
||||
process: Process,
|
||||
}
|
||||
impl Observed {
|
||||
fn path(&self, path: &str) -> String {
|
||||
let path = format!("{}{}", self.prefix, path.trim_end_matches('/'));
|
||||
if path.is_empty() { "/".into() } else { path }
|
||||
}
|
||||
}
|
||||
struct Handle {
|
||||
file: Arc<dyn File>,
|
||||
path: Path,
|
||||
observer: Observer,
|
||||
process: Process,
|
||||
}
|
||||
impl Handle {
|
||||
async fn mutate<T: Send + 'static>(
|
||||
&self,
|
||||
f: impl Future<Output = Result<T>> + Send + 'static,
|
||||
) -> Result<T> {
|
||||
let (path, observer) = (self.path.clone(), self.observer.clone());
|
||||
self.process
|
||||
.operation(async move {
|
||||
let order = observer.mutations.lock().await;
|
||||
let result = f.await?;
|
||||
let path = path.lock().unwrap().clone();
|
||||
drop(order);
|
||||
if let Some(path) = path {
|
||||
(observer.changed)(&path);
|
||||
}
|
||||
Ok(result)
|
||||
})
|
||||
.await
|
||||
}
|
||||
}
|
||||
#[async_trait]
|
||||
impl Layer for Observed {
|
||||
async fn stat(&self, path: &str, follow: bool) -> Result<Stat> {
|
||||
self.layer.stat(path, follow).await
|
||||
}
|
||||
async fn readlink(&self, path: &str) -> Result<String> {
|
||||
self.layer.readlink(path).await
|
||||
}
|
||||
async fn list(&self, path: &str) -> Result<Vec<Entry>> {
|
||||
self.layer.list(path).await
|
||||
}
|
||||
async fn open(&self, path: &str, options: Open) -> Result<Arc<dyn File>> {
|
||||
let (layer, local, path, observer, process) = (
|
||||
self.layer.clone(),
|
||||
path.to_owned(),
|
||||
self.path(path),
|
||||
self.observer.clone(),
|
||||
self.process.clone(),
|
||||
);
|
||||
self.process
|
||||
.operation(async move {
|
||||
let order = observer.mutations.lock().await;
|
||||
let file = layer.open(&local, options).await?;
|
||||
let handle = Arc::new(Handle {
|
||||
file,
|
||||
path: observer.path(path.clone()),
|
||||
observer: observer.clone(),
|
||||
process,
|
||||
});
|
||||
drop(order);
|
||||
if options.create || options.truncate {
|
||||
(observer.changed)(&path);
|
||||
}
|
||||
Ok(handle as Arc<dyn File>)
|
||||
})
|
||||
.await
|
||||
}
|
||||
async fn mkdir(&self, path: &str) -> Result<()> {
|
||||
let (layer, local, path, observer) = (
|
||||
self.layer.clone(),
|
||||
path.to_owned(),
|
||||
self.path(path),
|
||||
self.observer.clone(),
|
||||
);
|
||||
self.process
|
||||
.operation(async move {
|
||||
let order = observer.mutations.lock().await;
|
||||
layer.mkdir(&local).await?;
|
||||
drop(order);
|
||||
(observer.changed)(&path);
|
||||
Ok(())
|
||||
})
|
||||
.await
|
||||
}
|
||||
async fn remove_file(&self, path: &str) -> Result<()> {
|
||||
self.remove(path, false).await
|
||||
}
|
||||
async fn remove_dir(&self, path: &str) -> Result<()> {
|
||||
self.remove(path, true).await
|
||||
}
|
||||
async fn rename(&self, from: &str, to: &str) -> Result<()> {
|
||||
let (layer, a, b, from, to, observer) = (
|
||||
self.layer.clone(),
|
||||
from.to_owned(),
|
||||
to.to_owned(),
|
||||
self.path(from),
|
||||
self.path(to),
|
||||
self.observer.clone(),
|
||||
);
|
||||
self.process
|
||||
.operation(async move {
|
||||
let order = observer.mutations.lock().await;
|
||||
layer.rename(&a, &b).await?;
|
||||
if from != to {
|
||||
observer.moved(&from, Some(&to));
|
||||
}
|
||||
drop(order);
|
||||
(observer.changed)(&from);
|
||||
(observer.changed)(&to);
|
||||
Ok(())
|
||||
})
|
||||
.await
|
||||
}
|
||||
}
|
||||
impl Observed {
|
||||
async fn remove(&self, path: &str, directory: bool) -> Result<()> {
|
||||
let (layer, local, path, observer) = (
|
||||
self.layer.clone(),
|
||||
path.to_owned(),
|
||||
self.path(path),
|
||||
self.observer.clone(),
|
||||
);
|
||||
self.process
|
||||
.operation(async move {
|
||||
let order = observer.mutations.lock().await;
|
||||
if directory {
|
||||
layer.remove_dir(&local).await?;
|
||||
} else {
|
||||
layer.remove_file(&local).await?;
|
||||
}
|
||||
observer.moved(&path, None);
|
||||
drop(order);
|
||||
(observer.changed)(&path);
|
||||
Ok(())
|
||||
})
|
||||
.await
|
||||
}
|
||||
}
|
||||
#[async_trait]
|
||||
impl File for Handle {
|
||||
async fn stat(&self) -> Result<Stat> {
|
||||
self.file.stat().await
|
||||
}
|
||||
async fn read(&self, offset: u64, length: usize) -> Result<Vec<u8>> {
|
||||
self.file.read(offset, length).await
|
||||
}
|
||||
async fn write(&self, offset: u64, bytes: Vec<u8>) -> Result<usize> {
|
||||
let f = self.file.clone();
|
||||
self.mutate(async move { f.write(offset, bytes).await })
|
||||
.await
|
||||
}
|
||||
async fn append(&self, bytes: Vec<u8>) -> Result<usize> {
|
||||
let f = self.file.clone();
|
||||
self.mutate(async move { f.append(bytes).await }).await
|
||||
}
|
||||
async fn set_size(&self, size: u64) -> Result<()> {
|
||||
let f = self.file.clone();
|
||||
self.mutate(async move { f.set_size(size).await }).await
|
||||
}
|
||||
async fn sync(&self) -> Result<()> {
|
||||
self.file.sync().await
|
||||
}
|
||||
async fn set_times(
|
||||
&self,
|
||||
accessed: Option<SystemTime>,
|
||||
modified: Option<SystemTime>,
|
||||
) -> Result<()> {
|
||||
let f = self.file.clone();
|
||||
self.mutate(async move { f.set_times(accessed, modified).await })
|
||||
.await
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use tokio::sync::mpsc;
|
||||
#[test]
|
||||
fn component_matching() {
|
||||
assert!(under("/mailbox/a", "/mailbox"));
|
||||
assert!(under("/mailbox", "/mailbox"));
|
||||
assert!(under("/anything", "/"));
|
||||
assert!(!under("/mailboxes/a", "/mailbox"));
|
||||
}
|
||||
/// Every visible mutation is delivered after the layer call, including rebased
|
||||
/// open handles in another process's namespace. Removed handles stay usable.
|
||||
#[tokio::test]
|
||||
async fn handles_follow_rename_and_unlink() {
|
||||
for host in [false, true] {
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
let process = Process::default();
|
||||
let layer: Arc<dyn Layer> = if host {
|
||||
Arc::new(Host::new(temp.path(), process.clone()).unwrap())
|
||||
} else {
|
||||
Arc::new(Memory::default())
|
||||
};
|
||||
let (tx, mut rx) = mpsc::unbounded_channel();
|
||||
let observer = Observer::new(move |p| {
|
||||
tx.send(p.to_owned()).unwrap();
|
||||
});
|
||||
let a = observer.layer(layer.clone(), "/run", process.clone());
|
||||
let b = observer.layer(layer, "/run", process);
|
||||
a.mkdir("/dir").await.unwrap();
|
||||
assert_eq!(rx.recv().await.unwrap(), "/run/dir");
|
||||
let f = a
|
||||
.open(
|
||||
"/dir/a",
|
||||
Open {
|
||||
create: true,
|
||||
write: true,
|
||||
..Open::default()
|
||||
},
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(rx.recv().await.unwrap(), "/run/dir/a");
|
||||
b.rename("/dir", "/moved").await.unwrap();
|
||||
assert_eq!(rx.recv().await.unwrap(), "/run/dir");
|
||||
assert_eq!(rx.recv().await.unwrap(), "/run/moved");
|
||||
f.write(0, b"new".to_vec()).await.unwrap();
|
||||
assert_eq!(rx.recv().await.unwrap(), "/run/moved/a");
|
||||
assert_eq!(
|
||||
b.open("/moved/a", Open::default())
|
||||
.await
|
||||
.unwrap()
|
||||
.read(0, 3)
|
||||
.await
|
||||
.unwrap(),
|
||||
b"new"
|
||||
);
|
||||
let old = b
|
||||
.open(
|
||||
"/old",
|
||||
Open {
|
||||
create: true,
|
||||
write: true,
|
||||
..Open::default()
|
||||
},
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
rx.recv().await.unwrap();
|
||||
b.rename("/moved/a", "/old").await.unwrap();
|
||||
rx.recv().await.unwrap();
|
||||
rx.recv().await.unwrap();
|
||||
old.write(0, b"invisible".to_vec()).await.unwrap();
|
||||
assert!(rx.try_recv().is_err());
|
||||
f.append(b"!".to_vec()).await.unwrap();
|
||||
assert_eq!(rx.recv().await.unwrap(), "/run/old");
|
||||
b.remove_file("/old").await.unwrap();
|
||||
assert_eq!(rx.recv().await.unwrap(), "/run/old");
|
||||
f.set_size(0).await.unwrap();
|
||||
assert!(rx.try_recv().is_err());
|
||||
assert!(b.remove_file("/missing").await.is_err());
|
||||
assert!(rx.try_recv().is_err());
|
||||
}
|
||||
}
|
||||
/// Killing a waiting writer does not discard observation of a completed mutation;
|
||||
/// the process's idle barrier includes the callback, not only the system call.
|
||||
#[tokio::test]
|
||||
async fn cancellation_keeps_mutation_and_observation() {
|
||||
let (tx, mut rx) = mpsc::unbounded_channel();
|
||||
let observer = Observer::new(move |p| {
|
||||
tx.send(p.to_owned()).unwrap();
|
||||
});
|
||||
let process = Process::default();
|
||||
let layer = observer.layer(Arc::new(Memory::default()), "/", process.clone());
|
||||
let order = observer.mutations.lock().await;
|
||||
let (started, ready) = tokio::sync::oneshot::channel();
|
||||
let p = process.clone();
|
||||
let task = tokio::spawn(async move {
|
||||
// Signal from inside the tracked operation, not before its guard exists.
|
||||
p.operation(async move {
|
||||
started.send(()).unwrap();
|
||||
layer.mkdir("/published").await
|
||||
})
|
||||
.await
|
||||
});
|
||||
ready.await.unwrap();
|
||||
task.abort();
|
||||
let _ = task.await;
|
||||
drop(order);
|
||||
process.idle().await;
|
||||
assert_eq!(rx.try_recv().unwrap(), "/published");
|
||||
}
|
||||
}
|
||||
+16
-1
@@ -36,7 +36,22 @@ impl Process {
|
||||
.await
|
||||
.map_err(std::io::Error::other)?
|
||||
}
|
||||
/// Wait for all outstanding system calls.
|
||||
/// Complete an asynchronous mutation and its observation even if the guest is cancelled.
|
||||
/// Its guard participates in idle(), so no mutation outlives process cleanup.
|
||||
pub async fn operation<T: Send + 'static>(
|
||||
&self,
|
||||
operation: impl std::future::Future<Output = std::io::Result<T>> + Send + 'static,
|
||||
) -> std::io::Result<T> {
|
||||
self.0.count.fetch_add(1, Ordering::SeqCst);
|
||||
let guard = Guard(self.0.clone());
|
||||
tokio::spawn(async move {
|
||||
let _guard = guard;
|
||||
operation.await
|
||||
})
|
||||
.await
|
||||
.map_err(std::io::Error::other)?
|
||||
}
|
||||
/// Wait for all outstanding system calls and observed mutations.
|
||||
/// First abort the guest task. Then await its JoinHandle, or drop its store.
|
||||
/// Only then await idle before releasing locks. Abort alone does not stop a running poll.
|
||||
/// This ordering also prevents later memory writes, which need no blocking guard.
|
||||
|
||||
Reference in New Issue
Block a user