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
@@ -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