⎇ d270c5e67457195cd845f783c0b3b7bd66b9add0
crates/ente-zero/src/seed.rs
Ñawpa willay
Pi imata llamkarqan
ch'uya
1//! Construcción de la Tarjeta Semilla.
2//!
3//! Tres caminos:
4//! 1. `--restore <path>`: leer `FractalSnapshot` y reconstruir Semilla
5//! con seed_id preservado + entes anteriores como genesis.
6//! 2. `seed.card.json` en disco: deserialize directo (prod o dev).
7//! 3. Fallback dev: sintetizar Semilla + 6 genesis Entes que ejercitan
8//! todas las capacidades del fractal.
9
10use anyhow::Context;
11use ente_card::{
12 Capability, CardError, CgroupSpec, EntityCard, NamespaceSet, Payload,
13 ResourceLimits, SomaSpec, Supervision, CARD_SCHEMA_VERSION,
14};
15use std::collections::BTreeSet;
16use std::path::{Path, PathBuf};
17use std::time::Duration;
18use tracing::{info, warn};
19use ulid::Ulid;
20
21const SEED_PATH_PROD: &str = "/ente/seed.card";
22const SEED_PATH_DEV: &str = "seed.card";
23
24pub fn load(dev_mode: bool, restore: Option<&Path>) -> anyhow::Result<EntityCard> {
25 let card = if let Some(path) = restore {
26 load_from_snapshot(path)?
27 } else {
28 load_or_synthesize(dev_mode)?
29 };
30 card.validate()
31 .map_err(|e: CardError| anyhow::anyhow!("semilla inválida: {e}"))?;
32 Ok(card)
33}
34
35fn load_from_snapshot(path: &Path) -> anyhow::Result<EntityCard> {
36 let snap = ente_snapshot::FractalSnapshot::read(path)
37 .with_context(|| format!("read snapshot {}", path.display()))?;
38 info!(
39 path = %path.display(),
40 seed_id = %snap.seed_id,
41 entes = snap.entes.len(),
42 timestamp_ms = snap.timestamp_ms,
43 "snapshot cargado, restaurando fractal"
44 );
45 // Reconstruimos la Semilla con su Ulid original. Las Cards persistidas
46 // van a `genesis` con sus Ulids preservados — son las mismas identidades
47 // que vivieron antes del checkpoint.
48 let mut provides = BTreeSet::new();
49 provides.insert(Capability::Spawn);
50 provides.insert(Capability::Journal);
51 Ok(EntityCard {
52 schema_version: CARD_SCHEMA_VERSION,
53 id: snap.seed_id,
54 lineage: None,
55 label: snap.seed_label,
56 provides,
57 requires: BTreeSet::new(),
58 soma: SomaSpec::default(),
59 payload: Payload::Virtual,
60 supervision: Supervision::OneShot,
61 genesis: snap.entes,
62 })
63}
64
65fn load_or_synthesize(dev_mode: bool) -> anyhow::Result<EntityCard> {
66 // Buscamos primero `.json` (canónico), luego sin extensión por
67 // compatibilidad con instalaciones que dejan el archivo crudo. La puerta
68 // genética se cruza vía `ente_brain::load_card_file` que pasa por
69 // `validate()` extendido.
70 let candidates: &[&str] = if dev_mode {
71 &["seed.card.json", SEED_PATH_DEV]
72 } else {
73 &["/ente/seed.card.json", SEED_PATH_PROD]
74 };
75 for cand in candidates {
76 let path = PathBuf::from(cand);
77 if !path.exists() { continue; }
78 let card = ente_brain::load_card_file(&path)
79 .with_context(|| format!("load {}", path.display()))?;
80 info!(path = %path.display(), "Tarjeta Semilla cargada y validada");
81 return Ok(card);
82 }
83 if dev_mode {
84 info!("sin seed.card — sintetizando semilla mínima (dev)");
85 return Ok(synthesize_dev_seed());
86 }
87 anyhow::bail!("seed.card no encontrada en /ente/seed.card.json ni /ente/seed.card")
88}
89
90fn synthesize_dev_seed() -> EntityCard {
91 let mut provides = BTreeSet::new();
92 provides.insert(Capability::Spawn);
93 provides.insert(Capability::Journal);
94
95 // Pre-registramos el módulo Wasm demo en el CAS y obtenemos su SHA real.
96 // Si el CAS no es escribible (raro en dev) caemos a un SHA cero — la
97 // resolución fallará y el Wasm no encarnará, pero el resto queda intacto.
98 let demo_wasm_sha = match ente_wasm::demo_module_bytes()
99 .and_then(|b| ente_cas::store(&b))
100 {
101 Ok(sha) => sha,
102 Err(e) => {
103 warn!(?e, "CAS no disponible — demo-wasm no encarnará");
104 [0u8; 32]
105 }
106 };
107
108 let mut genesis = Vec::new();
109 genesis.push(make_card("demo-sleep", Payload::Native {
110 exec: "/bin/sleep".into(), argv: vec!["1".into()], envp: vec![],
111 }, Supervision::OneShot));
112
113 genesis.push(make_card("demo-persist", Payload::Native {
114 exec: "/bin/sleep".into(), argv: vec!["60".into()], envp: vec![],
115 }, restart_supervision()));
116
117 // Card namespaced: padre escribe uid_map, hijo cat /proc/self/uid_map.
118 let mut ns_card = make_card("demo-userns", Payload::Native {
119 exec: "/bin/cat".into(),
120 argv: vec!["/proc/self/uid_map".into()],
121 envp: vec![],
122 }, Supervision::OneShot);
123 ns_card.soma = SomaSpec {
124 namespaces: NamespaceSet { user: true, ..Default::default() },
125 ..Default::default()
126 };
127 genesis.push(ns_card);
128
129 genesis.push(make_card("demo-wasm", Payload::Wasm {
130 module_sha256: demo_wasm_sha,
131 entry: "_start".into(),
132 }, Supervision::OneShot));
133
134 if let Some(card) = optional_native_card(
135 "demo-echo", "target/debug/ente-echo",
136 [ente_echo::echo_capability()].into_iter().collect(),
137 restart_supervision(),
138 ) {
139 genesis.push(card);
140 }
141
142 if let Some(card) = optional_native_card(
143 "compat-logind", "target/debug/ente-logind-compat",
144 [Capability::LegacyLogind].into_iter().collect(),
145 restart_supervision(),
146 ) {
147 genesis.push(card);
148 }
149
150 // Constelación de shims D-Bus que reemplazan systemd: cada uno provee
151 // un nombre `org.freedesktop.X1` que GNOME/KDE consultan al boot.
152 for (label, bin) in &[
153 ("compat-hostnamed", "target/debug/ente-hostnamed-compat"),
154 ("compat-timedated", "target/debug/ente-timedated-compat"),
155 ("compat-localed", "target/debug/ente-localed-compat"),
156 ("compat-journald", "target/debug/ente-journald-compat"),
157 ("compat-resolved", "target/debug/ente-resolved-compat"),
158 ("compat-polkit", "target/debug/ente-polkit-compat"),
159 ("compat-machined", "target/debug/ente-machined-compat"),
160 ("policy-provider", "target/debug/ente-policy-provider"),
161 ("compat-systemd1", "target/debug/ente-systemd1-compat"),
162 ("compat-notify", "target/debug/ente-notify-compat"),
163 ("compat-timer", "target/debug/ente-timer-compat"),
164 ] {
165 if let Some(card) = optional_native_card(
166 label, bin,
167 std::collections::BTreeSet::new(),
168 restart_supervision(),
169 ) {
170 genesis.push(card);
171 }
172 }
173
174 EntityCard {
175 schema_version: CARD_SCHEMA_VERSION,
176 id: Ulid::new(),
177 lineage: None,
178 label: "ente-zero-dev".into(),
179 provides,
180 requires: BTreeSet::new(),
181 soma: SomaSpec {
182 namespaces: NamespaceSet::default(),
183 rlimits: ResourceLimits::default(),
184 cgroup: CgroupSpec {
185 path: "ente.slice/zero".into(),
186 cpu_weight: None,
187 io_weight: None,
188 },
189 cpu_affinity: None,
190 },
191 payload: Payload::Virtual,
192 supervision: Supervision::OneShot,
193 genesis,
194 }
195}
196
197fn make_card(label: &str, payload: Payload, supervision: Supervision) -> EntityCard {
198 EntityCard {
199 schema_version: CARD_SCHEMA_VERSION,
200 id: Ulid::new(),
201 lineage: None,
202 label: label.into(),
203 provides: BTreeSet::new(),
204 requires: BTreeSet::new(),
205 soma: SomaSpec::default(),
206 payload,
207 supervision,
208 genesis: vec![],
209 }
210}
211
212fn optional_native_card(
213 label: &str,
214 bin_path: &str,
215 provides: BTreeSet<Capability>,
216 supervision: Supervision,
217) -> Option<EntityCard> {
218 let path = Path::new(bin_path);
219 if !path.exists() {
220 return None;
221 }
222 Some(EntityCard {
223 schema_version: CARD_SCHEMA_VERSION,
224 id: Ulid::new(),
225 lineage: None,
226 label: label.into(),
227 provides,
228 requires: BTreeSet::new(),
229 soma: SomaSpec::default(),
230 payload: Payload::Native {
231 exec: path.to_string_lossy().into_owned(),
232 argv: vec![],
233 envp: vec![],
234 },
235 supervision,
236 genesis: vec![],
237 })
238}
239
240fn restart_supervision() -> Supervision {
241 Supervision::Restart {
242 initial: Duration::from_millis(100),
243 max: Duration::from_secs(30),
244 }
245}