Huginn/crates/huginn-daemon/src/main.rs

//! The process: open one instance's mind, bind one socket, serve until a stop
//! signal. A mind that will not open ends the process with the refusal on
//! stderr and no socket ever bound.

use std::sync::Arc;
use std::sync::atomic::AtomicBool;

use anyhow::{Context, Result};
use huginn_daemon::index::Backoff;
use huginn_daemon::index::ollama::pool;
use huginn_daemon::index::qdrant::QdrantIndex;
use huginn_daemon::serve::{ServeOptions, Started, parse_options, run, startup};

fn main() -> Result<()> {
    let options = parse_options(std::env::args().skip(1))?;
    let embedder = pool(&options.ollama_urls, &options.reserve_ollama_urls, &options.embedding_model);
    let index = QdrantIndex::new(&options.qdrant_url);
    let Started { mut daemon, mut hub, registry, mut desk } = match startup(&options, embedder, index, Backoff::default()) {
        Ok(started) => started,
        Err(error) => {
            eprintln!("huginn-daemon refuses to serve {}: {error:#}", options.instance.0);
            std::process::exit(1);
        }
    };

    // Idunn runs this process as PID 1 of its own PID namespace, and a
    // namespace init ignores every signal it has not caught. Without this,
    // a stop is a ninety-second wait for SIGKILL.
    let stopping = Arc::new(AtomicBool::new(false));
    for signal in [signal_hook::consts::SIGTERM, signal_hook::consts::SIGINT] {
        signal_hook::flag::register(signal, Arc::clone(&stopping))
            .context("registering Huginn's stop signal handler")?;
    }

    eprintln!("huginn-daemon serving {} on {}", options.instance.0, hub.local_addr()?);
    if let Some(door) = &desk {
        eprintln!("huginn-daemon serving the desk door on {}", door.path().display());
    }
    run(&mut daemon, &mut hub, &registry, desk.as_mut(), &stopping, &ServeOptions::default())
}