memoryd: the Honcho worker sends conclusions, their deletions and fleet notes

Co-Authored-By: ornith-1.5-35b-a3b <agent@wntrmute.dev>

crates/memoryd/src/honcho/start.rs

@@ -0,0 +1,85 @@
+//! `memoryd`'s Honcho side at start (M5c spec, sections 5 and 10): the ledger read through, the
+//! sessions that wait again, the clients with their keys, and the worker's thread.
+
+use std::sync::{Arc, Mutex};
+
+use bxcore::SessionId;
+
+use crate::config::Config;
+use crate::honcho::client::{Clients, Timeouts};
+use crate::honcho::config::HonchoConfig;
+use crate::honcho::ledger::Ledger;
+use crate::honcho::mirror::Mirror;
+use crate::honcho::state;
+use crate::honcho::turns::{LEDGER, TurnSync};
+use crate::honcho::worker::{AskBox, Tuning, Wake, Worker};
+use crate::serve::{Log, StartError};
+
+/// With `[honcho]`, at start: the ledger read through, the sessions that wait again, and the
+/// clients with their keys read. Nothing is bound or started yet.
+pub struct Opened {
+    pub sync: Arc<Mutex<TurnSync>>,
+    clients: Clients,
+    agent: String,
+    owner: String,
+}
+
+impl Opened {
+    /// The memory writes' side of the ledger (task 12).
+    pub fn mirror(&self) -> Mirror {
+        let ledger = self
+            .sync
+            .lock()
+            .unwrap_or_else(|p| p.into_inner())
+            .shared_ledger();
+        Mirror::new(ledger, &self.agent, &self.owner)
+    }
+}
+
+/// Open the ledger (a cut-off last line is logged), resume the waiting sessions, and build the
+/// clients (their key files' warnings are logged). A key that cannot be read is `Secret`.
+pub fn open(config: &Config, honcho: &HonchoConfig, log: &Log) -> Result<Opened, StartError> {
+    let path = config.memory_dir().join(LEDGER);
+    let ledger = Ledger::open(&path).map_err(StartError::Ledger)?;
+    if ledger.repaired() {
+        (log)(&format!(
+            "memoryd: {}: a last line cut off by a crash was dropped",
+            path.display()
+        ));
+    }
+    let mut sync = TurnSync::new(ledger, &honcho.agent, &config.sessions_dir());
+    sync.resume();
+    let env = |name: &str| std::env::var_os(name);
+    let (clients, warnings) =
+        Clients::new(honcho, &env, Timeouts::WRITES).map_err(StartError::Secret)?;
+    for warning in warnings {
+        (log)(&warning);
+    }
+    Ok(Opened {
+        sync: Arc::new(Mutex::new(sync)),
+        clients,
+        agent: honcho.agent.clone(),
+        owner: honcho.owner.clone(),
+    })
+}
+
+/// Start the worker's thread, asking `brokerd` on `config`'s state socket.
+pub fn spawn(opened: Opened, config: &Config, wake: Arc<Wake>, log: Log) -> Result<(), String> {
+    let socket = config.state_socket();
+    let ask: AskBox =
+        Box::new(move |session: &SessionId| state::ask(&socket, session, state::WAIT));
+    let worker = Worker::new(
+        opened.sync,
+        opened.clients,
+        wake,
+        ask,
+        log,
+        Tuning::DEFAULT,
+        &opened.agent,
+    );
+    std::thread::Builder::new()
+        .name("honcho".to_string())
+        .spawn(move || worker.run())
+        .map(|_| ())
+        .map_err(|e| format!("cannot start the Honcho worker: {e}"))
+}