sergio/takana

1//! `hammerd` — daemon de hammer. Tres responsabilidades:
2//!   1. Diario de mutaciones: fanotify sobre /bin,/sbin,/lib,/etc → `hammer-journal`.
3//!   2. FIFO de control humano: `/run/init.control` (texto crudo, una línea por comando).
4//!   3. Bus de agente: `/run/agent.sock` (JSON-líneas, SO_PEERCRED). Ver `docs/07-agent-bus.md`.
5//!
6//! Cada subsistema vive en su thread. Si uno falla en init (típicamente el watcher sin
7//! CAP_SYS_ADMIN), los demás siguen arrancando: el daemon en dev puede correr sin sudo y aún
8//! así probar el bus.
9
10use std::path::PathBuf;
11use std::thread;
12
13use clap::Parser;
14
15mod bus;
16mod control;
17mod events;
18mod watcher;
19
20#[derive(Parser)]
21#[command(name = "hammerd", version, about = "Daemon de hammer: bus de agente + diario.")]
22struct Args {
23    /// Socket del bus de agente.
24    #[arg(long, default_value = "/run/agent.sock")]
25    agent_sock: String,
26    /// FIFO de control humano del init.
27    #[arg(long, default_value = "/run/init.control")]
28    init_control: PathBuf,
29    /// Directorio del diario de mutaciones.
30    #[arg(long, default_value = "/var/lib/hammer/journal")]
31    journal: String,
32    /// Directorio raíz de overlays (para que el watcher pueda filtrar eventos bajo overlays
33    /// activos). Default coincide con `hammer try`.
34    #[arg(long, default_value = hammer_overlay::DEFAULT_STATE_ROOT)]
35    overlay_state_root: String,
36    /// Directorios extra a vigilar; si vacío, usa los defaults del FHS (SDD 05 §2).
37    #[arg(long = "watch")]
38    extra_watch: Vec<PathBuf>,
39    /// Store CAS donde sellar artefactos de COMPILE.
40    #[arg(long, default_value = "/store")]
41    store: PathBuf,
42    /// Modo dev: desactiva el watcher fanotify (útil cuando hammerd corre sin CAP_SYS_ADMIN
43    /// y sólo queremos probar el bus). Igual que arrancar sin permisos, pero explícito.
44    #[arg(long)]
45    no_watcher: bool,
46    /// Fichero de política de capacidades del bus. Si existe, sustituye a la política por
47    /// defecto (misma-UID ⇒ casi todo; otros ⇒ query). Ver `docs/07-agent-bus.md` §4.
48    #[arg(long, default_value = "/etc/hammer/agent-caps.toml")]
49    agent_caps: PathBuf,
50}
51
52fn main() -> anyhow::Result<()> {
53    tracing_subscriber::fmt()
54        .with_writer(std::io::stderr)
55        .with_env_filter(
56            tracing_subscriber::EnvFilter::try_from_default_env()
57                .unwrap_or_else(|_| "info".into()),
58        )
59        .init();
60
61    let args = Args::parse();
62    tracing::info!(
63        agent_sock = %args.agent_sock,
64        init_control = %args.init_control.display(),
65        journal = %args.journal,
66        store = %args.store.display(),
67        "hammerd: arranque"
68    );
69
70    let event_bus = events::EventBus::new();
71
72    // FIFO de control humano: lo creamos siempre que se pueda (no es fatal).
73    let init_fifo_ok = match control::ensure_fifo(&args.init_control) {
74        Ok(path) => {
75            let reader_path = path.clone();
76            thread::Builder::new()
77                .name("init-ctl-reader".into())
78                .spawn(move || {
79                    if let Err(e) = control::run_reader(&reader_path) {
80                        tracing::warn!(error = %e, "init-ctl-reader: terminó");
81                    }
82                })
83                .ok();
84            true
85        }
86        Err(e) => {
87            tracing::warn!(error = %e, "init-control: no pude crear FIFO; INIT del bus fallará");
88            false
89        }
90    };
91
92    // Watcher fanotify: opcional. Si falla (no caps), el daemon sigue con el bus solo.
93    if !args.no_watcher {
94        let journal = hammer_journal::Journal::open(&args.journal)?;
95        let mut dirs = watcher::default_watch_dirs();
96        dirs.extend(args.extra_watch.clone());
97        let overlay_root = PathBuf::from(&args.overlay_state_root);
98        let bus_for_watcher = event_bus.clone();
99        match watcher::Watcher::start_with_events(
100            &dirs,
101            journal,
102            Some(overlay_root),
103            Some(bus_for_watcher),
104        ) {
105            Ok(w) => {
106                tracing::info!("watcher fanotify activo");
107                thread::Builder::new()
108                    .name("watcher".into())
109                    .spawn(move || {
110                        if let Err(e) = w.run_forever() {
111                            tracing::warn!(error = %e, "watcher: terminó con error");
112                        }
113                    })
114                    .ok();
115            }
116            Err(e) => {
117                tracing::warn!(
118                    error = %e,
119                    "watcher fanotify NO arrancó; daemon sigue (sin diario en este run)"
120                );
121            }
122        }
123    } else {
124        tracing::info!("--no-watcher: omitiendo fanotify");
125    }
126
127    // Bus de agente: bloqueante en este thread. Si falla, fin del daemon.
128    // Política de caps: del fichero si existe, si no la heurística por-UID por defecto.
129    let policy = match hammer_core::AgentCapsConfig::load(&args.agent_caps) {
130        Ok(Some(cfg)) => {
131            tracing::info!(path = %args.agent_caps.display(), rules = cfg.rule.len(),
132                "bus: política de caps cargada de fichero");
133            bus::policy_from_config(cfg)
134        }
135        Ok(None) => {
136            tracing::info!(path = %args.agent_caps.display(),
137                "bus: sin fichero de caps; uso la política por defecto (por-UID)");
138            bus::default_policy()
139        }
140        Err(e) => {
141            // Config presente pero inválida: fallar cerrado sería más seguro, pero romper el
142            // arranque del daemon por un typo es peor en la práctica. Avisamos fuerte y caemos
143            // a la política por defecto (restrictiva para no-dueños).
144            tracing::error!(path = %args.agent_caps.display(), error = %e,
145                "bus: fichero de caps inválido; uso la política por defecto");
146            bus::default_policy()
147        }
148    };
149    let ctx = bus::BusContext {
150        store_root: args.store,
151        init_control: if init_fifo_ok {
152            args.init_control
153        } else {
154            // Apuntamos a un path inexistente: cualquier INIT fallará con "init_send_failed"
155            // y un mensaje claro. Mejor que callar.
156            PathBuf::from("/dev/null/init-control-missing")
157        },
158        events: event_bus,
159    };
160    bus::serve_agent_bus(std::path::Path::new(&args.agent_sock), policy, ctx)?;
161    Ok(())
162}