sausage core: modules per topic, journal writer thread with WAL and batches, hash cache by metadata, 49 tests per rule

Blank stdout lines give no warning. core.exit requests the exit in its
own handler.

cli/src/host.rs

@@ -0,0 +1,131 @@
+//! Host startup, boot calls, and the public library API.
+use crate::{RpcResult, components, journal, runtime::Runtime, world::World};
+use crate::{
+    locks::Lock,
+    native::NativePlugin,
+    process::{Process, ProcessInfo},
+};
+use serde_json::{Value, json};
+use std::{
+    collections::HashMap,
+    path::Path,
+    sync::{Arc, Mutex},
+};
+use tokio::sync::watch;
+use uuid::Uuid;
+pub(crate) struct State {
+    pub(crate) processes: HashMap<String, Process>,
+    pub(crate) locks: HashMap<String, Lock>,
+    pub(crate) native: HashMap<String, NativePlugin>,
+}
+pub(crate) struct Inner {
+    pub(crate) world: World,
+    pub(crate) runtime: Arc<Runtime>,
+    pub(crate) state: Mutex<State>,
+    pub(crate) journal: journal::Journal,
+    pub(crate) notifications: tokio::sync::broadcast::Sender<Value>,
+    pub(crate) exit: watch::Sender<bool>,
+    pub(crate) components: components::Components,
+}
+#[derive(Clone)]
+/// A cloneable handle to a world and its running processes.
+pub struct Host(pub(crate) Arc<Inner>);
+
+impl Host {
+    /// Start a world with the default compile cache and its ordered boot calls.
+    pub async fn start(path: &Path) -> anyhow::Result<Self> {
+        let base = std::env::var_os("XDG_CACHE_HOME")
+            .map(std::path::PathBuf::from)
+            .unwrap_or_else(|| {
+                std::path::PathBuf::from(std::env::var_os("HOME").unwrap_or_default())
+                    .join(".cache")
+            });
+        Self::start_with_cache(path, &base.join("sausage")).await
+    }
+    /// Start a world with an explicit compile cache folder.
+    pub async fn start_with_cache(path: &Path, cache: &Path) -> anyhow::Result<Self> {
+        let path = path.to_path_buf();
+        let cache = cache.to_path_buf();
+        let (world, runtime) = tokio::task::spawn_blocking(move || -> anyhow::Result<_> {
+            Ok((World::open(&path)?, Runtime::new(&cache)?))
+        })
+        .await??;
+        let journal =
+            journal::Journal::open(world.state_dir("core").join("journal.sqlite")).await?;
+        let host = Self(Arc::new(Inner {
+            world,
+            runtime,
+            journal,
+            state: Mutex::new(State {
+                processes: HashMap::new(),
+                locks: HashMap::new(),
+                native: HashMap::new(),
+            }),
+            notifications: tokio::sync::broadcast::channel(1024).0,
+            exit: watch::channel(false).0,
+            components: components::Components::default(),
+        }));
+        let boot: Vec<Value> = serde_json::from_slice(
+            &tokio::fs::read(host.0.world.root.join("config/boot.json")).await?,
+        )?;
+        for service in boot {
+            let result = host
+                .route(
+                    "core".into(),
+                    Some(json!(Uuid::now_v7().to_string())),
+                    service["method"].as_str().unwrap_or("").into(),
+                    service["params"].clone(),
+                    true,
+                )
+                .await;
+            if let Err(e) = result {
+                host.0.journal.write("core", "core", "core", &e.to_string());
+            }
+        }
+        Ok(host)
+    }
+    /// Register a native plugin for subsequent calls.
+    pub fn register_native(&self, name: &str, plugin: NativePlugin) {
+        self.0
+            .state
+            .lock()
+            .unwrap()
+            .native
+            .insert(name.into(), plugin);
+    }
+    /// Subscribe to notifications addressed to the console.
+    pub fn subscribe(&self) -> tokio::sync::broadcast::Receiver<Value> {
+        self.0.notifications.subscribe()
+    }
+    /// Snapshot the metadata of each process that has not ended.
+    pub fn processes(&self) -> HashMap<String, ProcessInfo> {
+        self.0
+            .state
+            .lock()
+            .unwrap()
+            .processes
+            .iter()
+            .map(|(p, s)| (p.clone(), s.info.clone()))
+            .collect()
+    }
+    /// Make a console-side call and wait for its JSON result.
+    pub async fn call(&self, method: &str, params: Value) -> RpcResult {
+        self.route(
+            "console".into(),
+            Some(json!(Uuid::now_v7().to_string())),
+            method.into(),
+            params,
+            false,
+        )
+        .await
+    }
+    /// Wait until a core.exit handler requests a restart.
+    pub async fn exit_requested(&self) {
+        let mut exit = self.0.exit.subscribe();
+        let _ = exit.wait_for(|requested| *requested).await;
+    }
+    /// Return whether a core.exit handler requested a restart.
+    pub fn restart_requested(&self) -> bool {
+        *self.0.exit.borrow()
+    }
+}