core: sausage-vfs per process (/, /proc, /self, /run), activation, graph, watcher, upgrades

- /proc is a core layer: core/ (PROTOCOL.md, graph.json, graph.dot,
  locks.json, plugins/<name>/discover.json and client.rs) and one folder
  per process (info.json, log, and its /self files).
- Locks are released only after the task ended, the store dropped, and
  in-flight file operations returned.
- core.activate and core.revert with copies, discovery, compatibility
  checks of imports and consumers, groups, force. An admission gate
  makes the snapshot of old processes complete.
- Graph of discover documents by hash, refreshed by a file watcher.
- Upgrades: grace periods (x-sausage-grace), stop, service restarts,
  rpc.retired.
- SDK plugins in the real core (cli/tests/sdk.rs).

cli/src/filesystem.rs

@@ -0,0 +1,301 @@
+//! Per-process mount tables, reserved self files, and the live process namespace.
+use crate::Host;
+use sausage_vfs::{
+    Entry, File, Generated, Layer, Memory, Mounts, Open, Process, Result, Stat, async_trait,
+};
+use std::{io, sync::Arc};
+
+fn denied<T>() -> Result<T> {
+    Err(io::ErrorKind::ReadOnlyFilesystem.into())
+}
+fn missing<T>() -> Result<T> {
+    Err(io::ErrorKind::NotFound.into())
+}
+fn directory() -> Stat {
+    Stat {
+        directory: true,
+        symlink: false,
+        size: 0,
+        accessed: None,
+        modified: None,
+    }
+}
+fn entry(name: String, directory: bool) -> Entry {
+    Entry {
+        name,
+        directory,
+        symlink: false,
+    }
+}
+fn reserved(path: &str) -> bool {
+    matches!(
+        path.trim_start_matches('/').split('/').next(),
+        Some("info.json" | "log" | "fs")
+    )
+}
+
+impl Host {
+    /// Create a console filesystem view without adding a process. Its `/self` is private and ephemeral.
+    pub async fn filesystem(&self) -> anyhow::Result<Mounts> {
+        self.mounts(None, Memory::default(), Process::default())
+            .await
+    }
+    pub(crate) async fn mounts(
+        &self,
+        pid: Option<String>,
+        memory: Memory,
+        tracker: Process,
+    ) -> anyhow::Result<Mounts> {
+        let root = self.0.world.root.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("/proc", Arc::new(Proc(self.clone())), true);
+        mounts.mount(
+            "/self",
+            Arc::new(SelfFolder {
+                host: self.clone(),
+                pid,
+                memory,
+            }),
+            false,
+        );
+        mounts.mount("/run", Arc::new(self.0.run.clone()), false);
+        Ok(mounts)
+    }
+    fn core_files(&self) -> Generated {
+        let mut files = Generated::default();
+        let protocol = include_bytes!("../../PROTOCOL.md");
+        files.insert("/PROTOCOL.md", move || Ok(protocol.to_vec()));
+        let graph = self.graph_json();
+        files.insert("/graph.json", move || Ok(graph.clone()));
+        let dot = self.graph_dot();
+        files.insert("/graph.dot", move || Ok(dot.clone()));
+        let locks = {
+            let state = self.0.state.lock().unwrap();
+            let locks: std::collections::BTreeMap<_, _> = state
+                .locks
+                .iter()
+                .map(|(path, lock)| {
+                    let waiting: Vec<_> = lock.queue.iter().map(|(pid, _)| pid).collect();
+                    let info = serde_json::json!({
+                        "owner": lock.owner,
+                        "waiting": waiting,
+                    });
+                    (path.clone(), info)
+                })
+                .collect();
+            serde_json::to_vec(&locks).unwrap()
+        };
+        files.insert("/locks.json", move || Ok(locks.clone()));
+        for name in self.discovered_plugins() {
+            if let Some(doc) = self.discover_document(&name) {
+                let bytes = serde_json::to_vec(&doc).unwrap();
+                files.insert(&format!("/plugins/{name}/discover.json"), move || {
+                    Ok(bytes.clone())
+                });
+                files.insert(&format!("/plugins/{name}/client.rs"), move || {
+                    sausage_interface::client_rs(&name, &doc)
+                        .map(String::into_bytes)
+                        .map_err(io::Error::other)
+                });
+            }
+        }
+        files
+    }
+}
+struct Proc(Host);
+impl Proc {
+    fn folder(&self, path: &str) -> Result<(SelfFolder, String)> {
+        let (pid, rest) = path
+            .trim_start_matches('/')
+            .split_once('/')
+            .unwrap_or((path.trim_start_matches('/'), ""));
+        let memory = self
+            .0
+            .0
+            .state
+            .lock()
+            .unwrap()
+            .processes
+            .get(pid)
+            .map(|p| p.memory.clone())
+            .ok_or(io::ErrorKind::NotFound)?;
+        Ok((
+            SelfFolder {
+                host: self.0.clone(),
+                pid: Some(pid.into()),
+                memory,
+            },
+            format!("/{rest}"),
+        ))
+    }
+}
+#[async_trait]
+impl Layer for Proc {
+    async fn stat(&self, path: &str, follow: bool) -> Result<Stat> {
+        if matches!(path.trim_end_matches('/'), "" | "/core" | "/core/plugins") {
+            return Ok(directory());
+        }
+        if let Some(path) = path.strip_prefix("/core/") {
+            return self.0.core_files().stat(&format!("/{path}"), follow).await;
+        }
+        let (folder, path) = self.folder(path)?;
+        folder.stat(&path, follow).await
+    }
+    async fn list(&self, path: &str) -> Result<Vec<Entry>> {
+        if path == "/" {
+            let mut entries = vec![entry("core".into(), true)];
+            entries.extend(self.0.processes().into_keys().map(|pid| entry(pid, true)));
+            entries.sort_by(|a, b| a.name.cmp(&b.name));
+            return Ok(entries);
+        }
+        if path.trim_end_matches('/') == "/core/plugins" {
+            return Ok(self
+                .0
+                .discovered_plugins()
+                .into_iter()
+                .filter(|name| self.0.discover_document(name).is_some())
+                .map(|name| entry(name, true))
+                .collect());
+        }
+        if path.trim_end_matches('/') == "/core" {
+            let mut entries = self.0.core_files().list("/").await?;
+            if !entries.iter().any(|e| e.name == "plugins") {
+                entries.push(entry("plugins".into(), true));
+            }
+            return Ok(entries);
+        }
+        if let Some(path) = path.strip_prefix("/core/") {
+            return self.0.core_files().list(&format!("/{path}")).await;
+        }
+        let (folder, path) = self.folder(path)?;
+        folder.list(&path).await
+    }
+    async fn open(&self, path: &str, options: Open) -> Result<Arc<dyn File>> {
+        if options.write || options.create || options.truncate {
+            return denied();
+        }
+        if matches!(path.trim_end_matches('/'), "" | "/core" | "/core/plugins") {
+            return Memory::default().open("/", options).await;
+        }
+        if let Some(path) = path.strip_prefix("/core/") {
+            return self.0.core_files().open(&format!("/{path}"), options).await;
+        }
+        let (folder, path) = self.folder(path)?;
+        folder.open(&path, options).await
+    }
+    async fn mkdir(&self, _: &str) -> Result<()> {
+        denied()
+    }
+    async fn remove_file(&self, _: &str) -> Result<()> {
+        denied()
+    }
+    async fn remove_dir(&self, _: &str) -> Result<()> {
+        denied()
+    }
+    async fn rename(&self, _: &str, _: &str) -> Result<()> {
+        denied()
+    }
+}
+struct SelfFolder {
+    host: Host,
+    pid: Option<String>,
+    memory: Memory,
+}
+impl SelfFolder {
+    async fn generated(&self, path: &str) -> Result<Generated> {
+        let pid = self.pid.as_ref().ok_or(io::ErrorKind::NotFound)?;
+        let bytes = match path {
+            "/info.json" => {
+                let info = self
+                    .host
+                    .0
+                    .state
+                    .lock()
+                    .unwrap()
+                    .processes
+                    .get(pid)
+                    .map(|p| p.info.clone())
+                    .ok_or(io::ErrorKind::NotFound)?;
+                serde_json::to_vec(&info).unwrap()
+            }
+            "/log" => {
+                let lines = self
+                    .host
+                    .0
+                    .journal
+                    .query(serde_json::json!({"pid":pid,"limit":i64::MAX}))
+                    .await;
+                let mut bytes = Vec::new();
+                for line in lines.as_array().unwrap() {
+                    serde_json::to_writer(&mut bytes, line).unwrap();
+                    bytes.push(b'\n');
+                }
+                bytes
+            }
+            _ => return missing(),
+        };
+        let mut files = Generated::default();
+        files.insert(path, move || Ok(bytes.clone()));
+        Ok(files)
+    }
+}
+#[async_trait]
+impl Layer for SelfFolder {
+    async fn stat(&self, path: &str, follow: bool) -> Result<Stat> {
+        if reserved(path) {
+            self.generated(path).await?.stat(path, follow).await
+        } else {
+            self.memory.stat(path, follow).await
+        }
+    }
+    async fn list(&self, path: &str) -> Result<Vec<Entry>> {
+        let mut entries = self.memory.list(path).await?;
+        if path == "/" && self.pid.is_some() {
+            entries.extend([entry("info.json".into(), false), entry("log".into(), false)]);
+        }
+        Ok(entries)
+    }
+    async fn open(&self, path: &str, options: Open) -> Result<Arc<dyn File>> {
+        if reserved(path) {
+            if options.write || options.create || options.truncate {
+                return denied();
+            }
+            self.generated(path).await?.open(path, options).await
+        } else {
+            self.memory.open(path, options).await
+        }
+    }
+    async fn mkdir(&self, path: &str) -> Result<()> {
+        if reserved(path) {
+            denied()
+        } else {
+            self.memory.mkdir(path).await
+        }
+    }
+    async fn remove_file(&self, path: &str) -> Result<()> {
+        if reserved(path) {
+            denied()
+        } else {
+            self.memory.remove_file(path).await
+        }
+    }
+    async fn remove_dir(&self, path: &str) -> Result<()> {
+        if reserved(path) || path == "/" {
+            denied()
+        } else {
+            self.memory.remove_dir(path).await
+        }
+    }
+    async fn rename(&self, from: &str, to: &str) -> Result<()> {
+        if reserved(from) || reserved(to) || from == "/" || to == "/" {
+            denied()
+        } else {
+            self.memory.rename(from, to).await
+        }
+    }
+}