sergio/takana
> Una distribución Linux construida con un laboratorio funcional y hermético en el > sótano, y una terminal mutable, clásica y anárquica en el piso de arriba — diseñada > desde el suelo para que una IA programadora entienda, modifique y co…
mudanza: el tercer camino — mudar, RESPALDAR o abandonar, cosa por cosa y con su descripción
1#!/usr/bin/env python3
2"""planear.py — convierte un CENSO decidido en un PLAN ejecutable y exportable (SDD 29 etapa 2).
3
4El plan es el producto: un documento que se revisa, se versiona, se lleva a otro proveedor y se
5vuelve a correr. **Cada paso lleva su comando literal**, así que el plan se puede ejecutar con la
6herramienta o a mano, línea por línea, sin la herramienta y sin este repo.
7
8── LAS TRES REGLAS, Y POR QUÉ ──────────────────────────────────────────────────────────────────
91. **Nada sin decidir se ejecuta.** Una entrada con `decision = ""` ABORTA el plan, nombrándola. El
10 silencio no es consentimiento: si nadie dijo qué hacer con un servicio, la respuesta no es
11 «entonces no lo muevo» —eso lo mata en silencio— ni «entonces lo muevo» —eso muda fósiles—.
122. **Lo que muere se dice por su nombre y con su tamaño, ANTES de borrar nada.** En esta mudanza
13 `terapeuta.ec` eran 279 M sin DNS: la diferencia entre «lo decidimos» y «se nos pasó» es una
14 línea escrita.
153. **Cada copia se verifica EN DESTINO.** «Lo copié» no prueba nada: el `rsync` que llenó el disco
16 de la caja nueva devolvió 0 y dejó 1367 artefactos VACÍOS, y sólo se vio contando del otro lado.
17
18── LO QUE EL PLAN SABE QUE UN GUIÓN A MANO OLVIDA ──────────────────────────────────────────────
19· **Dimensiona con el tamaño de COPIA, no con `du`.** Un árbol con hardlinks mide 60 G y ocupa 85 G
20 al copiarlo sin `-H` (medido). El preflight compara contra el número correcto y falla ANTES.
21· **`rsync -aH` y excluyendo cachés.** Sin `-H` los hardlinks se expanden; `.dmerge` son 11 G de
22 caché regenerable que llenó un disco.
23· **Los servicios `no-declarado` no se copian: se DECLARAN.** Copiar un binario no lo levanta al
24 arrancar — el caddy de la caja nueva murió en el primer reinicio por exactamente eso.
25· **La traducción de la configuración es un PASO, no una advertencia.** Decir «cambiar de servidor
26 web obliga a reescribir la config» es cierto y deja al humano con un párrafo y ninguna herramienta.
27 El plan emite el comando literal de `traducir.py` cuando el par EXISTE —se le pregunta al registro
28 de plugins, no se lista acá— y dice que no existe cuando no. Su verificación es HUMANA: el
29 traductor sale ≠0 si algo quedó sin traducir, así que darlo por bueno por código de salida sería
30 justo al revés de lo que hay que mirar.
31
32Uso:
33 scripts/mudanza/planear.py --censo censo.toml --target root@1.2.3.4 [--decide] --out plan.toml
34"""
35import argparse, os, sys, shlex, time, tomllib
36
37sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
38import formatos # noqa: E402
39import censar # noqa: E402
40from censar import candidatos_de as candidatos # noqa: E402
41
42_REPO = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
43_AQUI = os.path.join("scripts", "mudanza", "traducir.py")
44
45# ── tamaños ─────────────────────────────────────────────────────────────────────────────────────
46
47_MUL = {"K": 1 / 1024, "M": 1, "G": 1024, "T": 1024 * 1024}
48
49
50def a_mib(s):
51 """'61.5G' → MiB. Devuelve None si no se entiende: un tamaño ilegible NO se inventa como 0,
52 porque un 0 inventado apaga el preflight justo cuando más hace falta."""
53 s = (s or "").strip()
54 if not s or not s[0].isdigit():
55 return None
56 try:
57 return float(s[:-1]) * _MUL.get(s[-1].upper(), 1) if s[-1].isalpha() else float(s)
58 except ValueError:
59 return None
60
61
62def humano(mib):
63 if mib is None:
64 return "?"
65 return f"{mib/1024:.1f}G" if mib >= 1024 else f"{mib:.0f}M"
66
67
68# ── decisión ────────────────────────────────────────────────────────────────────────────────────
69
70# ── TRES CAMINOS, NO DOS (pedido del usuario, 2026-09-16) ───────────────────────────────────────
71# Con `muda`/`muere` una cosa que no va a la caja nueva sólo podía MORIR, así que todo lo dudoso se
72# marcaba `muda` «por las dudas» y la mudanza engordaba con cosas que nadie iba a usar. El tercer
73# camino es el que la gente usa de verdad: *esto no lo quiero corriendo allá, pero tampoco lo quiero
74# perder*. `respalda` lo copia al corral de respaldo y NO lo instala en el destino.
75#
76# ⚠ `respalda` cuenta como «no se muda» para la recomendación derivada de los servicios: un binario
77# que queda archivado no puede arrancar en la caja nueva. Confundirlos daría un servicio marcado
78# `muda` cuyo ejecutable no va a existir allá — y eso se descubre al arrancarlo, no al decidir.
79DECISIONES = ("muda", "respalda", "muere")
80
81
82def entradas(censo):
83 """Todo lo que necesita una decisión, con una etiqueta legible."""
84 out = []
85 for s in censo.get("servicio", []):
86 # `declarado-muerto` no necesita decisión: no corre. Se informa y se deja morir.
87 if s.get("class") != "declarado-muerto":
88 out.append(("servicio", s["name"], s))
89 for d in censo.get("dominio", []):
90 # ⚠ Los `fosil-sin-dns` ENTRAN. Antes se filtraban con el argumento de que un dominio sin DNS
91 # no necesita ningún paso — y es cierto para el DNS, pero no para lo que arrastra: en gioser
92 # son 13 de 29, y `terapeuta.ec` tenía 279 M de contenido y su bloque en el caddy. Sacarlos
93 # de la lista los volvía INVISIBLES, así que nadie decidía borrarlos y sus datos viajaban a
94 # la caja nueva por omisión. Es exactamente el «mudar fósiles» que este plan existe para
95 # evitar, y la regla 2 dice que lo que muere se nombra ANTES de borrar nada.
96 out.append(("dominio", d["domain"], d))
97 for d in censo.get("datos", []):
98 out.append(("datos", d["path"], d))
99 return out
100
101
102# ── servicios que NO APLICAN en una caja remota ─────────────────────────────────────────────────
103# Correr en el origen no significa que tenga sentido en el destino. Un servidor en un datacenter no
104# tiene bluetooth, ni módem, ni batería, ni teclado — y arrastrarlos es peor que inútil: algunos
105# PELEAN con el destino. Cada familia con su motivo, porque una recomendación sin motivo no se puede
106# discutir y entonces se acepta a ciegas o se ignora entera.
107NO_APLICA = {
108 "hardware local (una caja remota no tiene ese dispositivo)": {
109 "bluetoothd", "bluetooth", "modemmanager", "upowerd", "upower", "acpid", "adb",
110 "thermald", "iio-sensor-proxy", "fwupd", "alsactl", "pcscd", "cups", "cupsd",
111 },
112 "escritorio o pantalla (un servidor no los tiene)": {
113 "waypipe", "xorg", "x", "wayland", "gdm", "sddm", "lightdm", "pipewire",
114 "wireplumber", "pulseaudio", "carmen-dm",
115 },
116 "la red del destino ya la configura su propio init — pelearían": {
117 "networkmanager", "dhcpcd", "wpa-supplicant", "connman", "systemd-networkd", "dhclient",
118 },
119 "el destino tiene su propio journal (la semilla de arje declara `provides: [\"Spawn\", \"Journal\"]`)": {
120 "metalog", "syslogd", "syslog-ng", "rsyslogd", "rsyslog", "busybox-syslogd", "socklog",
121 },
122 "lo provee el init del destino, no se muda": {
123 "agetty", "getty", "console-getty", "udevd", "udevadm", "systemd-udevd", "eudev",
124 "elogind-daemon", "elogind", "polkitd", "dbus-daemon", "dbus",
125 },
126}
127
128
129def _no_aplica(nombre):
130 n = nombre.lower().replace("_", "-")
131 for motivo, conjunto in NO_APLICA.items():
132 if n in conjunto:
133 return motivo
134 return None
135
136
137# Paquetes que proveen un RUNTIME, no un programa. Que exista `recipes/nodejs.toml` no significa que
138# `openclaw` esté cubierto: el intérprete se resuelve y el programa sigue faltando.
139INTERPRETES = {"python", "python3", "nodejs", "node", "perl", "ruby", "php", "lua", "java", "jre"}
140
141# El paquete del origen y la receta del catálogo no siempre se llaman igual ni siquiera para el mismo
142# intérprete: Artix empaqueta `python` y el catálogo tiene `python3.toml`. Sin esto, tres servicios
143# salían «hace falta una receta takana» cuando el runtime YA está sellado y lo que falta es el
144# programa — dos trabajos muy distintos.
145ALIAS_INTERPRETE = {"python": "python3", "node": "nodejs", "jre": "java"}
146
147
148# ── familias de equivalentes funcionales ────────────────────────────────────────────────────────
149# Agrupa cosas que hacen EL MISMO trabajo, para poder ofrecer alternativas. Es conocimiento de
150# dominio, no gusto: que nginx y caddy sirvan HTTP es un hecho. Lo que NO se decide acá es cuál es
151# mejor — eso sale de datos medibles (¿está en el catálogo? ¿está sellado?) y del costo de cambiar.
152FAMILIAS = {
153 "servidor web / proxy": ["caddy", "nginx", "apache", "httpd", "lighttpd", "traefik", "haproxy"],
154 "base de datos": ["postgresql", "mariadb", "mysql", "sqlite"],
155 "caché en memoria": ["redis", "valkey", "memcached"],
156 "forja git": ["gitea", "forgejo", "gitlab"],
157 "contenedores": ["docker", "podman", "containerd"],
158 "dns": ["unbound", "bind", "dnsmasq", "coredns"],
159 "correo": ["postfix", "exim", "opensmtpd"],
160 "base vectorial": ["qdrant", "milvus", "weaviate"],
161}
162
163
164# ── enganche con el CENTRO DE TRADUCCIÓN ────────────────────────────────────────────────────────
165# El plan ya decía «cambiar de servidor web obliga a REESCRIBIR la configuración entera». Eso es
166# cierto y es la advertencia correcta, pero dejaba al humano con un párrafo y ninguna herramienta.
167# Acá ese párrafo se vuelve **un comando literal**, cuando y sólo cuando el par existe de verdad:
168# los pares se PREGUNTAN al registro de plugins, no se listan acá. Una lista propia se
169# desincronizaría del centro y ofrecería una traducción que no existe — el plan mintiendo.
170
171# Dónde vive la declaración del servicio en cada init de origen.
172_RUTA_UNIDAD = {"openrc": "/etc/init.d/{n}",
173 "systemd": "/etc/systemd/system/{n}.service"}
174
175# Dónde vive la configuración de cada servicio. Conocimiento de dominio, igual que `FAMILIAS`: que
176# nginx lea `/etc/nginx/nginx.conf` es un hecho, no una preferencia. Lo que NO está acá no se
177# adivina — se dice que hay que ubicarlo a mano.
178_RUTA_CONFIG = {"nginx": "/etc/nginx/nginx.conf",
179 "apache": "/etc/apache2/apache2.conf",
180 "httpd": "/etc/httpd/conf/httpd.conf",
181 "caddy": "/etc/caddy/Caddyfile"}
182
183
184def traducciones(s):
185 """Comandos de traducción que le corresponden a un servicio que se muda.
186
187 Dos cosas distintas, y confundirlas es un error caro:
188 · la **declaración** (cómo se levanta) — de `openrc`/`systemd` a la tarjeta de arje;
189 · la **configuración** (qué hace) — sólo si se eligió un equivalente, p. ej. nginx → caddy.
190 Un servicio que se muda a sí mismo NO necesita lo segundo: su config sirve tal cual, y ofrecer
191 traducirla sería inventar trabajo."""
192 lectores, escritores = formatos.cargar()
193 out = []
194
195 # 1) la declaración → tarjeta de arje (el init del destino)
196 if "arje" in escritores:
197 for fuente in s.get("declared_in", []):
198 if fuente in lectores and fuente in _RUTA_UNIDAD:
199 ruta = _RUTA_UNIDAD[fuente].format(n=s["name"])
200 out.append({
201 "que": f"declaración de {s['name']} ({fuente} → arje)",
202 "cmd": f"{_AQUI} --from {fuente} --to arje \\\n"
203 f" --in {ruta} --out {s['name']}.card.json",
204 "nota": f"lee la unidad de {fuente} en el ORIGEN y emite la tarjeta. Sale con "
205 "código ≠0 si algo quedó sin traducir: eso NO es un fallo del comando, "
206 "es el acta pidiendo que la leas."})
207 break
208
209 # 2) la configuración → sólo si se cambia de servicio
210 alt = s.get("alternativa")
211 if alt and alt != s["name"]:
212 desde, hacia = s["name"].lower().replace("_", "-"), alt.lower()
213 if desde in lectores and hacia in escritores and \
214 lectores[desde][1] == escritores[hacia][1]:
215 org = _RUTA_CONFIG.get(desde, f"<config de {desde}: ubicala>")
216 dst = _RUTA_CONFIG.get(hacia, f"<config de {hacia}>")
217 out.append({
218 "que": f"configuración de {desde} → {hacia}",
219 "cmd": f"{_AQUI} --from {desde} --to {hacia} \\\n"
220 f" --in {org} --out {os.path.basename(dst)}",
221 "nota": "traduce lo mecánico y DICE con número de línea lo que no pudo. Desplegar "
222 "sin resolver el acta es desplegar un servidor incompleto que además "
223 "parece funcionar."})
224 else:
225 # No hay par: se dice. Ofrecer un comando que no existe es peor que no ofrecer nada.
226 out.append({
227 "que": f"configuración de {desde} → {hacia}",
228 "cmd": f"# NO hay traductor `{desde} → {hacia}` en el centro.\n"
229 f"# Ver los que sí hay: {_AQUI} --list\n"
230 f"# Hay que reescribir la configuración a mano.",
231 "nota": "el centro no tiene ese par; se escribe a mano o se agrega el plugin."})
232 return out
233
234
235def _receta(nombre, repo):
236 """(existe, sellado) para un nombre de receta."""
237 import glob
238 f = os.path.join(repo, "recipes", f"{nombre}.toml")
239 if not os.path.exists(f):
240 return False, False
241 return True, bool(glob.glob(os.path.join(repo, "store", f"*-{nombre}")))
242
243
244def alternativas(nombre, repo):
245 """Equivalentes funcionales del servicio, con una recomendación RAZONADA.
246
247 ── LOS CRITERIOS, Y POR QUÉ ÉSOS ────────────────────────────────────────────────────────────
248 No se recomienda «el mejor» en abstracto: eso es gusto, y un gusto disfrazado de dato es peor que
249 no recomendar. Se recomienda con hechos comprobables y en este orden:
250
251 1. **El que YA CORRE, si takana lo construye.** Cambiar de servidor web no es cambiar un
252 binario: es **reescribir la configuración entera**. Ése es el costo real y casi siempre
253 supera cualquier ventaja teórica del otro.
254 2. Si el que corre NO está en el catálogo pero un equivalente sí, se recomienda el equivalente
255 — porque es el que takana puede construir, firmar y reproducir. Y se dice lo que cuesta.
256 3. Si no hay ninguno, se dice que hay que escribir la receta. No se sugiere «usá otro» sin
257 decir que ese otro tampoco está.
258
259 Devuelve `(lista, recomendado, motivo)` o `(None, None, None)` si el servicio no cae en ninguna
260 familia conocida — que es lo normal y no es un error."""
261 n = nombre.lower().replace("_", "-")
262 fam = next((f for f, miembros in FAMILIAS.items() if n in miembros), None)
263 if not fam:
264 return None, None, None
265 lista = []
266 for cand in FAMILIAS[fam]:
267 existe, sellado = _receta(cand, repo)
268 lista.append({"nombre": cand, "receta": existe, "sellado": sellado, "actual": cand == n})
269 yo = next((x for x in lista if x["actual"]), None)
270 disponibles = [x for x in lista if x["sellado"]]
271
272 if yo and yo["sellado"]:
273 return (lista, n,
274 f"es el que YA corre y takana lo construye (sellado). Cambiar a otro de la familia "
275 f"«{fam}» no es cambiar un binario: obliga a REESCRIBIR la configuración entera")
276 if disponibles:
277 otros = ", ".join(x["nombre"] for x in disponibles)
278 return (lista, disponibles[0]["nombre"],
279 f"el que corre ({n}) no está en el catálogo de takana; de la familia «{fam}» sí "
280 f"están sellados: {otros}. Cambiar implica reescribir la configuración — es una "
281 f"decisión, no un trámite")
282 return (lista, None,
283 f"de la familia «{fam}» NO hay ninguno en el catálogo de takana: ni {n} ni sus "
284 f"equivalentes. Hay que escribir la receta del que se elija")
285
286
287def origen_binario(e, repo=None):
288 """De dónde sale el binario, y por lo tanto QUÉ HAY QUE HACER para tenerlo en el destino.
289
290 «Instalá el paquete» es lo que uno ya sabía. Esto responde otra cosa, cruzando dos hechos: quién
291 posee el fichero en el ORIGEN (se lo preguntó el censo a su gestor de paquetes) y si el corpus de
292 takana tiene una receta con ese nombre. Los tres casos piden trabajo distinto:
293
294 · `receta-takana` — lo mejor: takana ya sabe construirlo. Se instala del repo firmado.
295 · `paquete-ajeno` — lo trae el gestor del origen. En el destino hace falta una receta, o
296 `qorpa` (ADR 0015) si se acepta una jaula con la distro ajena.
297 · `suelto` — NADIE lo provee: un binario puesto a mano. Hay que LLEVARLO con su árbol
298 o escribirle una receta. Es el que se pierde al apagar el origen.
299
300 Medido en gioser: 13 servicios con paquete y **13 binarios sueltos** — `caddy`, `qdrant`,
301 `matilda`, `act_runner`, `pacha-secretos`… en `/usr/local/bin` o en un home. La mitad."""
302 nombre, exe, pkg = e.get("name", ""), e.get("exec", ""), e.get("paquete", "")
303 # scripts/mudanza/planear.py → scripts/mudanza → scripts → RAÍZ. Con un `dirname` de menos
304 # apuntaba a `scripts/`, no encontraba ninguna receta, y TODO salía `suelto` — incluido `caddy`,
305 # que sí tiene `recipes/caddy.toml`. Un clasificador que contesta siempre lo mismo no clasifica.
306 repo = repo or os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
307 if not os.path.isdir(os.path.join(repo, "recipes")):
308 # Falla ruidosamente: sin el catálogo no se puede distinguir `receta-takana` de `suelto`, y
309 # contestar `suelto` a todo sería una respuesta falsa con forma de respuesta.
310 raise SystemExit(f"!! no encuentro el catálogo de recetas en {repo}/recipes — "
311 f"pasá --repo o corré desde el repo")
312 # ⚠ El nombre del SERVICIO no es el nombre del paquete: `sshd` lo trae `openssh`, `crond` lo trae
313 # `cronie`. Buscar sólo por el nombre del servicio daba «no hay receta» para cinco que el catálogo
314 # SÍ construye y tiene selladas. El censo ya le preguntó al gestor de paquetes quién posee el
315 # binario, así que ese nombre también se prueba.
316 import glob
317 for cand in (nombre, nombre.replace("_", "-"), os.path.basename(exe or ""),
318 pkg, (pkg or "").removesuffix("-bin"), ALIAS_INTERPRETE.get(pkg or "", "")):
319 if not cand or not os.path.exists(os.path.join(repo, "recipes", f"{cand}.toml")):
320 continue
321 # ⚠⚠ Y la trampa, que es la que haría mentir al perfil: un paquete INTÉRPRETE provee el
322 # runtime, no el programa. `openclaw` lo posee `nodejs` y `fail2ban-server` lo posee
323 # `python`; tener esas recetas NO te da esos servicios. Contarlos como cubiertos haría que el
324 # perfil saliera N/N describiendo un servidor al que le faltan cuatro programas.
325 if pkg in INTERPRETES and cand in (pkg, ALIAS_INTERPRETE.get(pkg or "", "")) and cand != nombre:
326 sellado = bool(glob.glob(os.path.join(repo, "store", f"*-{cand}")))
327 return ("interprete",
328 f"lo corre el intérprete `{pkg}`, que takana SÍ construye (`recipes/{cand}.toml`"
329 + (", sellada)" if sellado else ", sin sellar)")
330 + f" — pero el intérprete NO es el programa: `{nombre}` es código que hay que "
331 f"llevar y declarar aparte. El perfil resuelve el runtime y nada más")
332 sellado = bool(glob.glob(os.path.join(repo, "store", f"*-{cand}")))
333 via = "" if cand in (nombre, nombre.replace("_", "-")) else f" (por su paquete `{pkg}`)" \
334 if cand in (pkg, (pkg or "").removesuffix("-bin")) else f" (por su binario)"
335 return ("receta-takana",
336 f"takana YA lo construye{via}: `recipes/{cand}.toml`"
337 + (" (sellado en el store)" if sellado else " (sin sellar: hay que construirlo)")
338 + f" ⇒ instalarlo del repo firmado, no copiar el binario de {exe or '?'}")
339 if pkg:
340 return ("paquete-ajeno",
341 f"lo provee el gestor del origen: paquete `{pkg}`. En el destino hace falta una "
342 f"receta takana, o `qorpa` si se acepta una jaula con la distro ajena (ADR 0015)")
343 if exe and e.get("exec_borrado"):
344 # Su propia clase, y la más urgente del censo: el fichero YA NO EXISTE. No es «hay que
345 # llevarlo», es «se pierde en el próximo reinicio y el que está en su ruta NO es el mismo».
346 pid = e.get("pid_vivo") or (e.get("pids") or [0])[0]
347 bv, bd = e.get("bytes_vivo", ""), e.get("bytes_disco", "")
348 dif = (f" El que hay AHORA en esa ruta pesa {bd} bytes y el que corre {bv}: NO SON EL MISMO."
349 if bv and bd and bv != bd else
350 (" En esa ruta ya no hay nada." if not bd else ""))
351 return ("borrado",
352 f"⚠ el binario que CORRE fue borrado o reemplazado: `{exe}` ya no existe en disco."
353 f"{dif} Sólo vive mientras viva el pid {pid}; al reiniciar el origen se pierde PARA "
354 f"SIEMPRE. Rescatalo ya: sudo cat /proc/{pid}/exe > {os.path.basename(exe)} "
355 f"&& chmod +x {os.path.basename(exe)}")
356 if exe:
357 return ("suelto",
358 f"NADIE lo provee: binario puesto a mano en {exe}. Hay que LLEVARLO (con lo que "
359 f"necesite alrededor) o escribirle una receta — es de los que se pierden al apagar "
360 f"el origen")
361 motivo = e.get("exec_motivo") if isinstance(e, dict) else ""
362 return ("desconocido", motivo or "no se pudo leer su binario: hace falta averiguarlo a mano")
363
364
365def recomendar(tipo, e, datos_que_mueren=(), sitios=(), locales=()):
366 """Devuelve `(decision, motivo)`. **Recomendación, nunca decisión**: se imprime con su razón para
367 que aceptarla sea barato y equivocarse sea caro de no notar.
368
369 Un motivo no es cortesía: una recomendación sin razón no se puede discutir, así que o se acepta a
370 ciegas o se ignora entera. Las dos son malas."""
371 c = e.get("class", "")
372
373 if tipo == "servicio":
374 m = _no_aplica(e.get("name", ""))
375 if m:
376 return "muere", m
377 # DERIVADA, y es la más fuerte: si el binario vive en un árbol que NO se muda, el servicio no
378 # va a poder arrancar allá. Se detecta cruzando su `cmdline` contra las decisiones de datos.
379 exe = (e.get("cmdline") or "").split(" ")[0]
380 for raiz in datos_que_mueren:
381 if exe.startswith(raiz.rstrip("/") + "/"):
382 return "muere", f"su binario vive en {raiz}, que NO se muda ⇒ no podría arrancar allá"
383 if c == "no-declarado":
384 p = e.get("ports") or []
385 return "muda", ("corre y sirve " + ", ".join(str(x) for x in p) + ": alguien lo quiere, "
386 "y NADIE lo declara" if p else
387 "corre sin estar declarado: alguien lo quiso, y nadie sabe levantarlo")
388 if c == "vivo":
389 return "muda", "declarado y corriendo"
390 return "", ""
391
392 if tipo == "dominio":
393 # ⚠ Evidencia más fuerte que el DNS, y sin tocar la red: si el bloque de este dominio en la
394 # config del servidor apunta a un directorio que NO EXISTE, no hay nada que servir — devuelve
395 # 502 resuelva donde resuelva. Medido en gioser: `aura`, `sigma` y `kosmofono` apuntan a
396 # raíces borradas, y son justo los que en su día devolvían los 502 que hicieron que el censo
397 # se baneara a sí mismo al sondearlos por HTTP. Se lee del fichero; no hace falta preguntar.
398 for st in sitios:
399 if e.get("domain") in (st.get("nombres") or "").split() and st.get("raiz_existe") == "no":
400 return "muere", (f"su bloque en {st['config']} apunta a `{st['raiz']}`, que NO "
401 f"EXISTE: no hay nada que servir, devuelve 502 resuelva donde resuelva")
402 if c == "vivo":
403 return "muda", "resuelve a esta máquina y contesta"
404 if c == "ya-mudado":
405 return "muere", f"su DNS ya apunta a {e.get('dns','otra máquina')}: el bloque de acá es fósil"
406 if c == "backend-caido":
407 return "muere", f"resuelve acá pero devuelve {e.get('http','5xx')}: no hay backend"
408 if c == "apunta-aca":
409 # El DNS dice que apunta acá; si SIRVE no se preguntó. Recomendar «muda» sería tratar el
410 # silencio como una respuesta afirmativa, que es el error que este censo evita en todos
411 # los demás lugares. Se recomienda mudar porque el DNS hay que reapuntarlo igual, pero
412 # se DICE lo que no se miró.
413 return "muda", (f"su DNS apunta acá ({e.get('dns','?')}), así que hay que reapuntarlo. "
414 "⚠ NO se sondeó por HTTP: si el backend estaba caído, esto muda un fósil")
415 if c == "fosil-sin-dns":
416 return "muere", ("no resuelve en ningún DNS: nadie puede llegar a él. Revisá si dejó "
417 "contenido en disco o un bloque en el servidor web — eso sí viaja si "
418 "nadie lo borra")
419 if c == "sin-sondear":
420 return "", "sin sondear (censado en local): hace falta mirarlo desde afuera"
421 return "", ""
422
423 if tipo == "datos":
424 # ── LO QUE SIGUE SIN RECOMENDARSE, Y LO QUE SÍ ──────────────────────────────────────────
425 # La regla de fondo no cambió: **qué datos VALEN no se deduce de la máquina** — `terapeuta.ec`
426 # eran 279 M sin DNS y el usuario decidió que murieran; nada en el sistema podía decidir eso.
427 # Pero hay tres hechos que sí decide la máquina, y callarlos obliga a mirar 169 entradas a
428 # ojo: que el servidor web lo SIRVA, que un proceso vivo lo USE, y que sea recuperable de
429 # otro lado (un repo limpio con remoto) o regenerable (una caché). Se recomienda SÓLO sobre
430 # esos hechos, con el hecho como motivo, y el resto sale en blanco a propósito.
431 if e.get("servido_por"):
432 return "muda", ("lo SIRVE " + ", ".join(e["servido_por"]) +
433 ": si no viaja, ese sitio deja de existir")
434 if e.get("usado_por"):
435 return "muda", ("lo usa un proceso vivo (" + ", ".join(e["usado_por"]) +
436 "): un servicio que se muda sin sus datos arranca vacío")
437 base = os.path.basename(e.get("path", ""))
438 if base in _CACHES or base in ("swap", "lost+found"):
439 return "muere", f"`{base}` es caché o estado transitorio: se regenera solo en el destino"
440 rem = e.get("git_remoto") or ""
441 # ⚠ UN REMOTO QUE APUNTA A ESTA MISMA MÁQUINA NO ES UN RESPALDO, ES EL MISMO DISCO.
442 # Sin esto, «tiene remoto ⇒ se vuelve a clonar» recomienda ABANDONAR un repo cuyo único
443 # ejemplar se borra con la máquina. Medido en gioser: el remoto de `/mnt/vvv/humanoid` es
444 # `ssh://git@127.0.0.1:2345/…` — el gitea de acá. El censo ya lo sabe (`[[repo]] solo_aqui`)
445 # y lo que faltaba era cruzarlo.
446 if rem and any(x and x in rem for x in locales):
447 return "respalda", (f"su remoto ({rem}) es ESTA MISMA MÁQUINA: no es un respaldo, es el "
448 "mismo disco. Clonarlo después de borrarla no se puede")
449 if rem and not e.get("git_sucio"):
450 return "muere", (f"repo git LIMPIO con remoto ({rem}): se vuelve a clonar")
451 if rem and e.get("git_sucio"):
452 return "respalda", ("repo git con remoto pero CON CAMBIOS SIN COMMITEAR: lo commiteado "
453 "se vuelve a clonar, lo de encima sólo está acá")
454 if e.get("git_fecha") and not rem:
455 return "respalda", (f"repo git SIN remoto (último commit {e['git_fecha']}): su historia "
456 "existe únicamente en este disco")
457 return "", "los datos no se recomiendan solos: sólo vos sabés si valen"
458 return "", ""
459
460
461# Nombres cuyo contenido se REGENERA. No es una lista de «cosas grandes»: es de cosas que el destino
462# vuelve a crear solo. Borrar por tamaño sería adivinar; por regenerabilidad es un hecho.
463_CACHES = {
464 ".cache", ".npm", ".npm-global", ".gradle", ".pub-cache", ".dartServer", ".cargo", ".rustup",
465 ".m2", ".gem", ".go", "go", ".yarn", ".bun", ".deno", ".venvs", ".local-cache", "node_modules",
466 "target", "__pycache__", ".mozilla-cache", ".thumbnails", ".ccache", ".sccache",
467}
468
469
470def sugerir(tipo, e, datos_que_mueren=()):
471 return recomendar(tipo, e, datos_que_mueren, sitios)[0]
472
473
474def _etiqueta(tipo, nombre, e):
475 if tipo == "datos":
476 extra = e.get("size", "?")
477 if e.get("size_copy") and e["size_copy"] != e.get("size"):
478 extra += f" (copiar {e['size_copy']})"
479 return extra
480 if tipo == "servicio":
481 p = e.get("ports") or []
482 return ("puertos " + ",".join(str(x) for x in p)) if p else e.get("class", "")
483 return f"{e.get('dns','')} {e.get('http','')}".strip() or e.get("class", "")
484
485
486def revisar(censo, interactivo=True):
487 """Muestra TODO con su recomendación y su motivo, y deja elegir.
488
489 ── EL ORDEN NO ES CAPRICHOSO ────────────────────────────────────────────────────────────────
490 Primero los DATOS, después servicios y dominios. Porque la recomendación más fuerte sobre un
491 servicio se DERIVA de los datos: si su binario vive en un árbol que no se muda, no va a poder
492 arrancar allá. Al revés no se puede calcular.
493 """
494 todos = entradas(censo)
495 datos = [(t, n, e) for t, n, e in todos if t == "datos"]
496 # Con qué se compara un remoto para saber si apunta a esta misma máquina. Sale del censo, no de
497 # una lista cableada: las IPs y el hostname los midió `identidad()`.
498 maq = censo.get("maquina", {})
499 locales = {"127.0.0.1", "localhost", "0.0.0.0"} | set(maq.get("ips", []) or [])
500 if maq.get("hostname"):
501 locales.add(maq["hostname"])
502 resto = [(t, n, e) for t, n, e in todos if t != "datos"]
503
504 # ── 1. datos ────────────────────────────────────────────────────────────────────────────────
505 if datos:
506 print("\n══ 1/2 · DATOS — esto no se recomienda solo ═══════════════════════════════════")
507 print(" Qué datos valen no se deduce de la máquina: sólo vos sabés. Y de esto se deriva")
508 print(" la recomendación de los servicios, así que va primero.\n")
509 for t, n, e in datos:
510 marca = e.get("decision") or "—"
511 rec, motivo = recomendar("datos", e, locales=locales)
512 e["_rec"], e["_motivo"] = rec, motivo
513 print(f" {n:46} {e.get('size','?'):>6} {marca if marca != '—' else (rec or '—'):>8}"
514 f" {e.get('descripcion', '')[:70]}")
515 if interactivo:
516 print("\n [m]uda = va a la caja nueva · [r]espalda = se copia al corral y NO se instala"
517 " · [x] muere con la máquina\n")
518 for t, n, e in datos:
519 if e.get("decision") in DECISIONES:
520 continue
521 rec = e.get("_rec", "")
522 print(f" {n} {e.get('size','?')}")
523 if e.get("descripcion"):
524 print(f" {e['descripcion'][:100]}")
525 if e.get("_motivo"):
526 print(f" ↳ sugerido: {rec} — {e['_motivo'][:90]}")
527 r = input(f" [m]uda/[r]espalda/[x]muere"
528 f"{'/Enter=' + rec if rec else ''} > ").strip().lower()
529 e["decision"] = {"m": "muda", "r": "respalda", "x": "muere", "": rec}.get(r, "")
530
531 # ⚠ `respalda` entra acá junto a `muere`: las dos significan «su ruta NO va a existir en el
532 # destino», que es lo único que la derivación de servicios necesita saber.
533 mueren = [e["path"] for t, n, e in datos if e.get("decision") in ("muere", "respalda")]
534
535 # ── 2. lo demás, con recomendación y motivo ─────────────────────────────────────────────────
536 grupos = {"muda": [], "respalda": [], "muere": [], "": []}
537 for t, n, e in resto:
538 d, motivo = recomendar(t, e, mueren, censo.get("sitio", []))
539 e["_rec"], e["_motivo"] = d, motivo
540 grupos[d].append((t, n, e))
541
542 print("\n══ 2/2 · SERVICIOS Y DOMINIOS ════════════════════════════════════════════════════")
543 titulos = {"muda": "se recomienda MUDAR", "respalda": "se recomienda RESPALDAR",
544 "muere": "se recomienda NO mudar", "": "SIN recomendación — hay que decidir"}
545 for g in ("muda", "respalda", "muere", ""):
546 if not grupos[g]:
547 continue
548 print(f"\n── {titulos[g]} ({len(grupos[g])}) " + "─" * 30)
549 for t, n, e in sorted(grupos[g], key=lambda x: (x[0], x[1])):
550 print(f" {t:8} {n:30} {_etiqueta(t,n,e):>18}")
551 if e.get("_motivo"):
552 print(f" └─ {e['_motivo']}")
553 if t == "servicio" and e.get("decision") != "muere" and g != "muere":
554 oc, od = origen_binario(e)
555 print(f" └─ binario: [{oc}] {od[:96]}")
556 if e.get("usuario") and e["usuario"] != "root":
557 # No es un detalle: la tarjeta de arje NO tiene campo de usuario (lo dice el
558 # escritor `formatos/arje.py`). Si esto no se ve al decidir, un servicio que acá
559 # corre sin privilegios termina de root en el destino y nadie se entera.
560 print(f" └─ ⚠ corre como `{e['usuario']}`, NO como root: el destino "
561 f"no tiene dónde guardar eso — hay que bajar el privilegio en el comando")
562 lista, rec, motivo = alternativas(n, _REPO)
563 if lista:
564 op = " ".join(
565 ("**" + x["nombre"] + "**" if x["nombre"] == rec else x["nombre"])
566 + ("✓" if x["sellado"] else ("·" if x["receta"] else "✗"))
567 for x in lista)
568 print(f" └─ alternativas: {op} (✓ sellado · receta sin sellar · ✗ no está)")
569 print(f" recomendado: {rec or 'ninguno'} — {motivo[:110]}")
570
571 if not interactivo:
572 return censo
573
574 print("\n [a] aceptar todas las recomendaciones · [e] revisar una por una · [q] salir")
575 r = input(" > ").strip().lower()
576 if r == "q":
577 return censo
578 for t, n, e in resto:
579 if e.get("decision") in DECISIONES:
580 continue
581 rec = e.get("_rec", "")
582 if r == "a" and rec:
583 e["decision"] = rec
584 continue
585 sug = f"[{rec}]" if rec else "[sin recomendación]"
586 resp = input(f" {t:8} {n:30} {sug} {e.get('_motivo','')[:60]}\n"
587 f" [m]uda/[r]espalda/[x]muere/Enter={rec or 'nada'} > ").strip().lower()
588 e["decision"] = {"m": "muda", "r": "respalda", "x": "muere", "": rec}.get(resp, "")
589 if e["decision"] == "muda" and t == "servicio":
590 lista, alt_rec, motivo = alternativas(n, _REPO)
591 if lista and len([x for x in lista if x["sellado"]]) > 1:
592 op = " ".join(f"[{i}]{x['nombre']}" + ("✓" if x["sellado"] else "")
593 for i, x in enumerate(lista))
594 print(f" alternativas: {op}")
595 print(f" recomendado: {alt_rec} — {motivo[:100]}")
596 r2 = input(f" número, o Enter para {alt_rec}: ").strip()
597 if r2.isdigit() and int(r2) < len(lista):
598 e["alternativa"] = lista[int(r2)]["nombre"]
599 else:
600 e["alternativa"] = alt_rec
601 return censo
602
603
604def guardar_censo(censo, ruta, respaldar=True):
605 """Vuelve a escribir el censo con las decisiones puestas, usando el MISMO emisor que lo creó.
606
607 Dos detalles que no son de estilo: se descartan las claves internas (`_rec`, `_motivo`, que
608 `revisar()` cuelga de cada entrada y NO son parte del censo), y se escribe con temporal +
609 `rename` — si la herramienta muere a mitad, el fichero anterior sigue entero. Perder el censo a
610 medio decidir es perder el trabajo que más cuesta de toda la mudanza."""
611 limpio = {}
612 for k, v in censo.items():
613 if isinstance(v, list):
614 limpio[k] = [{kk: vv for kk, vv in e.items() if not kk.startswith("_")}
615 if isinstance(e, dict) else e for e in v]
616 else:
617 limpio[k] = v
618 # El emisor de `censar` habla en plural; el TOML, en singular. El puente va acá y no allá para
619 # no tocar el censo, que es quien define el formato.
620 puente = {
621 "fecha": limpio.get("fecha", ""), "identidad": limpio.get("maquina", {}),
622 "servicios": limpio.get("servicio", []), "huerfanos": limpio.get("huerfano", []),
623 "puertos": limpio.get("puerto", []), "dominios": limpio.get("dominio", []),
624 "datos": limpio.get("datos", []), "datos_raiz": limpio.get("datos_raiz", []),
625 "contenido": limpio.get("contenido", []), "sitios": limpio.get("sitio", []),
626 "repos": limpio.get("repo", []), "montajes": limpio.get("montaje", []),
627 "fuera_de_git": limpio.get("fuera_de_git", []),
628 }
629 texto = censar.emitir_toml(puente)
630 # Y se RELEE antes de pisar nada: el mismo guardián que el plan. Un censo que no vuelve a
631 # parsear deja la mudanza sin su fichero central y sin forma de saber cuándo se rompió.
632 try:
633 vuelto = tomllib.loads(texto)
634 except tomllib.TOMLDecodeError as e:
635 sys.exit(f"✗ el censo regenerado NO es TOML válido: {e}\n No se escribe nada.")
636 n_dec = sum(1 for _t, _n, x in entradas(vuelto) if x.get("decision"))
637 n_esp = sum(1 for _t, _n, x in entradas(censo) if x.get("decision"))
638 if n_dec != n_esp:
639 sys.exit(f"✗ el censo regenerado perdió decisiones ({n_esp} → {n_dec}). No se escribe nada.")
640 if respaldar and os.path.exists(ruta):
641 with open(ruta, encoding="utf-8") as fh:
642 open(ruta + ".bak", "w", encoding="utf-8").write(fh.read())
643 tmp = ruta + ".tmp"
644 with open(tmp, "w", encoding="utf-8") as fh:
645 fh.write(texto)
646 fh.flush()
647 os.fsync(fh.fileno())
648 os.replace(tmp, ruta)
649
650
651def validar(censo):
652 """Regla 1: nada sin decidir se ejecuta."""
653 faltan = [(t, n) for t, n, e in entradas(censo) if e.get("decision") not in DECISIONES]
654 if faltan:
655 print("\n!! el plan NO se genera: hay decisiones sin tomar.", file=sys.stderr)
656 print(" El silencio no es consentimiento — sin decisión, ni mudar ni matar es correcto.\n",
657 file=sys.stderr)
658 for t, n in faltan[:40]:
659 print(f" {t:9} {n}", file=sys.stderr)
660 if len(faltan) > 40:
661 print(f" … y {len(faltan)-40} más", file=sys.stderr)
662 print("\n Corré con --decide, o poné `decision` a mano en el censo.", file=sys.stderr)
663 sys.exit(2)
664
665
666# ── plan ────────────────────────────────────────────────────────────────────────────────────────
667
668_TRIPLE_SIMPLE = "'" * 3
669_TRIPLE_DOBLE = '"' * 3
670
671
672def bloque_toml(texto):
673 """Un texto libre como cadena TOML, de modo que el plan se pueda VOLVER A LEER.
674
675 ⚠ Medido, y era un fallo del producto: con la cadena BÁSICA el TOML interpreta las escapes, así
676 que el primer comando con una barra de continuación de línea dejaba el plan ILEGIBLE
677 (`Unescaped '\' in a string`) — y el plan es el producto: uno que no se puede volver a parsear no
678 se puede ni ejecutar ni exportar, que son las dos únicas cosas para las que existe. Apareció
679 recién al meter un comando multilínea, o sea que estuvo latente desde el principio.
680
681 Se usa la cadena LITERAL, que no interpreta nada. Si el texto la contuviera, se cae a la básica
682 con las escapes puestas a mano — el caso raro se maneja, no se supone que no pasa."""
683 if _TRIPLE_SIMPLE not in texto:
684 return _TRIPLE_SIMPLE + "\n" + texto + "\n" + _TRIPLE_SIMPLE
685 escapado = texto.replace("\\", "\\\\").replace(_TRIPLE_DOBLE, '\\"\\"\\"')
686 return _TRIPLE_DOBLE + "\n" + escapado + "\n" + _TRIPLE_DOBLE
687
688
689def incoherencias(censo):
690 """Cruza lo que la config DECLARA NECESITAR contra lo que se decidió con cada servicio.
691
692 ── LO QUE ESTO CAZA Y NADA MÁS PODÍA ───────────────────────────────────────────────────────
693 Un dominio que se muda y el servicio que lo sirve marcado `muere`. Las dos decisiones son
694 razonables por separado —el dominio se usa, el servicio parecía prescindible— y juntas dejan el
695 sitio nuevo devolviendo 502. No lo ve el DNS, no lo ve el censo de procesos y no lo ve quien
696 decide de a una entrada por vez, que es como se decide.
697
698 También caza el revés: un `reverse_proxy` a un puerto que NINGÚN servicio censado sirve. Eso ya
699 está roto HOY, en el origen, y mudarlo es mudar un 502."""
700 por_puerto, por_nombre = {}, {}
701 for s in censo.get("servicio", []):
702 por_nombre[s["name"].lower()] = s
703 for p in s.get("ports", []):
704 por_puerto[str(p)] = s
705 dec = {}
706 for d in censo.get("dominio", []):
707 dec[d["domain"]] = d.get("decision", "")
708
709 out = []
710 for st in censo.get("sitio", []):
711 doms = [d for d in (st.get("nombres") or "").split() if dec.get(d) == "muda"]
712 if not doms:
713 continue
714 for destino in (st.get("proxies") or "").split():
715 if destino.startswith("unix/"):
716 # `unix//run/php-fpm/php-fpm.sock` → el servicio se identifica por su nombre.
717 base = destino.rstrip("/").split("/")[-1].removesuffix(".sock")
718 svc = por_nombre.get(base) or por_nombre.get(base.split("-")[0])
719 clave = base
720 else:
721 clave = destino.rsplit(":", 1)[-1]
722 svc = por_puerto.get(clave)
723 if svc is None:
724 out.append((", ".join(doms), destino,
725 "NINGÚN servicio censado sirve ese destino: el sitio ya devuelve 502 "
726 "HOY, en el origen. Mudarlo es mudar un 502"))
727 elif svc.get("decision") == "muere":
728 out.append((", ".join(doms), f"{destino} → {svc['name']}",
729 f"el dominio se MUDA y `{svc['name']}`, que es quien lo sirve, está "
730 f"marcado MUERE. El sitio nuevo va a devolver 502"))
731 elif not svc.get("decision"):
732 out.append((", ".join(doms), f"{destino} → {svc['name']}",
733 f"el dominio se muda y `{svc['name']}`, que lo sirve, NO tiene decisión"))
734 return out
735
736
737def destino_respaldo_default():
738 """El corral de respaldo sale de `scripts/respaldo-storagebox.sh`, NO de una constante nueva acá.
739
740 Dos ficheros con la misma dirección escrita a mano divergen, y el que se queda viejo no falla:
741 respalda a un sitio que nadie mira. Se leen sus defaults (`SB_USER`/`SB_HOST`/`SB_PORT`), que es
742 donde el proyecto ya guarda lo que se guarda por si acaso."""
743 ruta = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "respaldo-storagebox.sh")
744 v = {}
745 try:
746 with open(ruta, encoding="utf-8") as fh:
747 for linea in fh:
748 for k in ("SB_USER", "SB_HOST", "SB_PORT"):
749 if linea.startswith(f'{k}="${{{k}:-'):
750 v[k] = linea.split(":-", 1)[1].split("}", 1)[0]
751 except OSError:
752 return "", ""
753 if not (v.get("SB_USER") and v.get("SB_HOST")):
754 return "", ""
755 return f'{v["SB_USER"]}@{v["SB_HOST"]}:respaldo-mudanza/', v.get("SB_PORT", "22")
756
757
758def pasos(censo, target, key, respaldo=None, respaldo_port=None):
759 ssh_opts = "-o StrictHostKeyChecking=accept-new -o ConnectTimeout=20"
760 if key:
761 ssh_opts = f"-i {key} " + ssh_opts
762 ssh = f"ssh {ssh_opts} {target}"
763 P = []
764
765 def paso(clase, titulo, cmd, verifica=None, nota=None, verifica_tipo="cmd"):
766 # `verifica_tipo` no es decoración: el aplicador NO puede tratar igual «corré esto» que «un
767 # humano tiene que mirar esto». Dar por buena una verificación humana porque «no dio error»
768 # es exactamente cómo un aplicador miente.
769 P.append({"clase": clase, "titulo": titulo, "cmd": cmd,
770 "verifica": verifica or "", "verifica_tipo": verifica_tipo, "nota": nota or ""})
771
772 datos_muda = [d for d in censo.get("datos", []) if d.get("decision") == "muda"]
773 datos_resp = [d for d in censo.get("datos", []) if d.get("decision") == "respalda"]
774 svc_muda = [s for s in censo.get("servicio", []) if s.get("decision") == "muda"]
775 doms_muda = [d for d in censo.get("dominio", []) if d.get("decision") == "muda"]
776 muere = [(t, n, e) for t, n, e in entradas(censo) if e.get("decision") == "muere"]
777 contenido = censo.get("contenido", [])
778
779 # ── 0. CÓDIGO QUE SÓLO EXISTE ACÁ ───────────────────────────────────────────────────────────
780 # El primer paso del plan entero, por delante incluso del rescate de binarios: aquello es un
781 # servicio que se pierde, esto es EL CÓDIGO CON EL QUE SE VOLVERÍA A CONSTRUIR. Y no se ve desde
782 # ninguna otra parte del censo —un repo no es un proceso, ni un puerto, ni un dominio—, así que
783 # se descubre cuando ya no hay de dónde sacarlo.
784 solos = [r for r in censo.get("repo", []) if r.get("solo_aqui") == "si"]
785 if solos:
786 det = ["# Estos repositorios NO tienen ningún remoto fuera de esta máquina. Apagarla borra el",
787 "# código, y los clones de trabajo están en el mismo disco que también muere.",
788 "#",
789 "# Por cada uno: agregarle un remoto que viva en otro lado y empujar. El propio takana",
790 "# lo hace así (`scripts/espejo-setup.sh`: pushurl doble a gitea Y a un espejo privado).",
791 "#"]
792 for r in solos:
793 det.append(f"# {r['path']}")
794 det.append(f"# remoto actual (en esta máquina): {r['dentro'][:88]}")
795 paso("codigo", f"{len(solos)} repositorio(s) que sólo existen en la máquina que se va a borrar",
796 "\n".join(det),
797 verifica="revisión humana: cada uno tiene que tener un remoto FUERA antes de apagar nada",
798 verifica_tipo="humano",
799 nota="⚠ Es la dependencia circular de esta mudanza: `tawasuyu` produce 10 de los 13 "
800 "binarios que nadie más provee, y su único remoto es el gitea de esta misma "
801 "máquina. Sin esto, apagar el origen deja servicios que no se pueden reconstruir.")
802
803 # ── 0 bis. LO QUE NO VIAJA CON NINGÚN REPO ──────────────────────────────────────────────────
804 # El paso 1 salva el CÓDIGO; éste salva lo que hace que ese código sirva de algo: las llaves, los
805 # certificados, los tokens y la configuración que no está versionada en ninguna parte. Va acá
806 # arriba por la misma razón —se pierde para siempre— y con una diferencia que importa: un repo
807 # sin copia fuera se nota al intentar clonarlo, y una clave privada borrada no se nota hasta la
808 # próxima vez que alguien firma. La peor de todas es `~/.config/takana/keys/release.ed25519`: el
809 # `.pub` vive EN el repo, la privada sólo en esta máquina.
810 fg = [f for f in censo.get("fuera_de_git", []) if f.get("path") != "crontab"]
811 if fg:
812 ciegos = [f for f in fg if f.get("estado") == "sin_permiso"]
813 det = ["# Config, llaves y credenciales que no están en ningún repo. Se listan por su ruta,",
814 "# su DUEÑO y su tamaño; el censo nunca leyó su contenido.", "#"]
815 for f in sorted(fg, key=lambda x: (x.get("owner", ""), x["path"])):
816 duenio = f" [{f['owner']}]" if f.get("owner") else ""
817 det.append(f"# {f['path']}{duenio} ({f.get('size', '?')})")
818 if f.get("porque"):
819 det.append(f"# {f['porque']}")
820 nota = ("⚠ `~` NO es un home: el censo corre como root y sólo mira `/root` salvo que se le "
821 "pidan los homes de `/etc/passwd`. Lo que se censa por su nombre se decide; lo que "
822 "sólo viaja dentro del bloque `/home` viaja sin que nadie lo haya mirado.")
823 if ciegos:
824 # Un `ls` sin permiso se lee IGUAL que un directorio ausente: decir cuál de las dos es
825 # la única forma de que «no hay nada ahí» sea una afirmación y no un silencio.
826 nota += (" ⚠⚠ " + str(len(ciegos)) + " de estas rutas EXISTEN y el censo NO pudo leerlas "
827 "(" + ", ".join(f["path"] for f in ciegos[:4]) + "): volvé a censar como su "
828 "dueño antes de decidir, o vas a decidir sobre una lista incompleta.")
829 paso("secretos", f"{len(fg)} ruta(s) de config y credenciales fuera de todo repo",
830 "\n".join(det),
831 verifica="revisión humana: por cada una, decidir `muda` o `muere` — y para las que "
832 "mudan, que el destino la tenga ANTES de apagar nada",
833 verifica_tipo="humano", nota=nota)
834
835 for f in fg:
836 if f.get("decision") != "muda":
837 continue
838 origen = f["path"]
839 dst = f.get("destino") or origen
840 # `-aHAX --numeric-ids`: permisos, ACLs y xattrs. Una llave que llega con el modo
841 # cambiado no falla al copiarse, falla al usarse («permissions are too open»), que es
842 # varios pasos más tarde y en otro sitio.
843 paso("secretos", f"copiar {origen} → {dst} ({f.get('size', '?')})",
844 f"rsync -aHAX --numeric-ids --partial "
845 f"-e {shlex.quote('ssh ' + ssh_opts)} {shlex.quote(origen)} "
846 f"{target}:{shlex.quote(os.path.dirname(dst.rstrip('/')) or '/')}/",
847 # Verificación POR CONTENIDO sin revelar contenido: el digest de los digests.
848 # Contar ficheros no alcanza — una llave truncada cuenta igual que una entera.
849 verifica=(f"h() {{ find \"$1\" -type f -exec sha256sum {{}} + 2>/dev/null "
850 f"| awk '{{print $1}}' | sort | sha256sum | cut -c1-16; }}; "
851 f"src=$(h {shlex.quote(origen)}); "
852 f"dst=$({ssh} \""
853 f"find {shlex.quote(dst)} -type f -exec sha256sum {{}} + 2>/dev/null "
854 f"| awk '{{print \\$1}}' | sort | sha256sum | cut -c1-16\"); "
855 f'echo "digest: origen=$src destino=$dst"; [ "$src" = "$dst" ]'),
856 nota="El digest es de los CONTENIDOS, no de los nombres ni de la cuenta: una llave "
857 "truncada a la mitad cuenta como un fichero igual que la entera.")
858
859 # ── 0 ter. COHERENCIA ───────────────────────────────────────────────────────────────────────
860 incoh = incoherencias(censo)
861 if incoh:
862 det = ["# Cada línea es un dominio que se MUDA cuyo backend no va a estar del otro lado.",
863 "# Las dos decisiones son razonables por separado; juntas dejan un 502.", "#"]
864 for dom, destino, motivo in incoh:
865 det.append(f"# {dom[:44]}")
866 det.append(f"# ↳ {destino}")
867 det.append(f"# {motivo}")
868 paso("coherencia", f"{len(incoh)} dominio(s) que se mudan SIN su backend", "\n".join(det),
869 verifica="revisión humana: o se muda el backend, o el dominio no se muda",
870 verifica_tipo="humano",
871 nota="Nadie más puede cazar esto: no lo ve el DNS, no lo ven los procesos, y no lo ve "
872 "quien decide de a una entrada por vez — que es como se decide.")
873
874 # ── 0 bis. RESCATE, antes que nada ──────────────────────────────────────────────────────────
875 # Va PRIMERO, antes del preflight, porque es el único paso del plan que puede volverse
876 # IMPOSIBLE mientras se piensa el resto: estos binarios ya no existen en disco y sólo viven en el
877 # inodo que sostiene su proceso. Un reinicio del origen —o que se caiga ese pid— y se pierden
878 # para siempre. Y en dos de los cuatro hay AHORA otro fichero en la misma ruta, de distinto
879 # tamaño: copiar la ruta no falla, muda otra cosa.
880 borrados = [s for s in censo.get("servicio", [])
881 if s.get("exec_borrado") and s.get("decision") == "muda"]
882 if borrados:
883 lineas, ver = [], []
884 for s in borrados:
885 pid = s.get("pid_vivo") or (s.get("pids") or [0])[0]
886 nom = os.path.basename(s.get("exec") or s["name"])
887 lineas.append(f"sudo cat /proc/{pid}/exe > rescate/{shlex.quote(nom)} && "
888 f"chmod +x rescate/{shlex.quote(nom)}")
889 if s.get("bytes_vivo"):
890 # La verificación COMPARA contra el tamaño del que CORRE. Un `cat` de un /proc que ya
891 # no existe crea un fichero VACÍO y devuelve 0: sin comparar, el rescate «pasa».
892 ver.append(f"[ \"$(stat -c %s rescate/{shlex.quote(nom)} 2>/dev/null)\" = "
893 f"\"{s['bytes_vivo']}\" ] || {{ echo 'FALTA {nom}'; exit 1; }}")
894 paso("rescate", f"rescatar {len(borrados)} binario(s) BORRADOS del disco (sólo mientras corran)",
895 "mkdir -p rescate\n" + "\n".join(lineas),
896 verifica="\n".join(ver) + "\necho ' ✓ los binarios rescatados coinciden con los que corren'",
897 nota="⚠ ESTE PASO CADUCA. `/proc/<pid>/exe` deja de existir cuando muere el proceso, y "
898 "estos ficheros ya no están en su ruta. Si el origen se reinicia antes de correr "
899 "esto, el binario que estaba andando NO se puede recuperar de ninguna manera.")
900
901 # ── 0. preflight ────────────────────────────────────────────────────────────────────────────
902 # ⚠ El sitio se mide POR SISTEMA DE FICHEROS, no contra `/`. Medido en la caja takana: `/` tiene
903 # 3,5 G libres, `/store` 19 G y `/work` 66 G — un preflight que sume 33,6 G y los compare contra
904 # `/` da un veredicto correcto por casualidad si todo cae en `/`, y COMPLETAMENTE FALSO en cuanto
905 # una ruta va a otro montaje: diría que no entra cuando entra, o al revés. Y además: aquí el
906 # veredicto lo saca el propio comando (exit ≠0 si falta sitio), no un humano leyendo una columna.
907 need = sum(x for x in (a_mib(d.get("size_copy") or d.get("size")) for d in datos_muda)
908 if x is not None)
909 ilegibles = [d["path"] for d in datos_muda
910 if a_mib(d.get("size_copy") or d.get("size")) is None]
911 chks = []
912 for d in datos_muda:
913 mib = a_mib(d.get("size_copy") or d.get("size"))
914 if mib is None:
915 continue
916 dst = (d.get("destino") or "").strip() or d["path"]
917 chks.append(f"chk {shlex.quote(dst)} {int(mib)}")
918 guion = "\n".join([
919 "set -u",
920 "chk() {",
921 ' t="$1"',
922 ' while [ ! -d "$t" ] && [ "$t" != "/" ]; do t=$(dirname "$t"); done',
923 ' df -Pm "$t" | tail -1 | awk -v n="$2" -v r="$1" \'{print $6, $4, n, r}\'',
924 "}",
925 "{",
926 *[" " + c for c in chks],
927 "} | awk '",
928 " { libre[$1]=$2; falta[$1]+=$3; rutas[$1]=rutas[$1] \" \" $4 }",
929 " END { mal=0",
930 ' for (f in falta) {',
931 ' printf " %-16s necesita %8d MiB · libres %8d ⇐%s\\n", f, falta[f], libre[f], rutas[f]',
932 ' if (falta[f] > libre[f]) { mal=1; printf " ✗ NO ENTRA en %s: faltan %d MiB\\n", f, falta[f]-libre[f] }',
933 " }",
934 ' if (mal==0) printf " ✓ entra en todos los sistemas de ficheros\\n"',
935 " exit mal }'",
936 ])
937 paso("preflight", f"el destino responde y tiene sitio ({humano(need)} en total)",
938 f"{ssh} 'sh -s' <<'FIN'\n{guion}\nFIN",
939 verifica=f"{ssh} 'sh -s' <<'FIN'\n{guion}\nFIN",
940 nota=("⚠ tamaños ilegibles, NO contados en el total: " + ", ".join(ilegibles)) if ilegibles else
941 "Dimensionado con el tamaño de COPIA (hardlinks expandidos), no con `du`, y medido "
942 "contra el sistema de ficheros de CADA destino.")
943
944 # ── 1. datos ────────────────────────────────────────────────────────────────────────────────
945 for d in datos_muda:
946 p = d["path"]
947 dst = (d.get("destino") or "").strip() or p
948 # Ver la nota del paso de respaldo: con el censo detallado hay entradas que son FICHEROS, y
949 # a un fichero no se le pone barra (y su verificación no es `find -type f | wc -l` en un
950 # directorio, sino comparar el fichero mismo).
951 es_dir = d.get("tipo", "dir") != "fichero"
952 org, dst_r = (p + "/", dst + "/") if es_dir else (p, dst)
953 ver = ((f"src=$(find {shlex.quote(p)} -type f | wc -l); "
954 f"dst=$({ssh} 'find {shlex.quote(dst)} -type f | wc -l'); "
955 f'echo "ficheros: origen=$src destino=$dst"; [ "$src" = "$dst" ]') if es_dir else
956 (f"src=$(stat -c%s {shlex.quote(p)}); "
957 f"dst=$({ssh} 'stat -c%s {shlex.quote(dst)}' 2>/dev/null || echo ausente); "
958 f'echo "bytes: origen=$src destino=$dst"; [ "$src" = "$dst" ]'))
959 paso("datos", f"copiar {p} → {dst} ({d.get('size','?')})",
960 f"rsync -aH --partial --info=stats2 --exclude='.dmerge' "
961 f"-e {shlex.quote('ssh ' + ssh_opts)} {shlex.quote(org)} {target}:{shlex.quote(dst_r)}",
962 verifica=ver,
963 nota="`-H` obligatorio: sin él los hardlinks se expanden (60 G medidos → 85 G). "
964 "Y la verificación COMPARA, no informa: cuenta los ficheros de los dos lados y "
965 "FALLA si no coinciden. La versión anterior imprimía el número de directorios "
966 "vacíos y devolvía 0 igual — un guardián que siempre pasa no es un guardián. "
967 "Hace falta porque un rsync que se corta deja el destino a medias y devuelve 0: "
968 "así se llenó un disco y quedaron 1367 artefactos vacíos.")
969
970 # ── 1 bis. lo que se RESPALDA ───────────────────────────────────────────────────────────────
971 # Ni se muda ni se pierde. Va al corral de respaldo y NO se instala en el destino: la caja nueva
972 # no se entera de que esto existe. Por eso es un paso propio y no un `datos` con otro destino —
973 # su verificación es distinta y su fallo significa otra cosa (no rompe el servidor nuevo, pero
974 # borra el original sin copia si nadie lo mira).
975 if datos_resp:
976 if not respaldo:
977 # Un corral vacío convertiría cada `respalda` en un `rsync` a ninguna parte que además
978 # devuelve 0. Abortar acá es la única forma de que no se lea como «respaldado».
979 sys.exit("✗ hay entradas marcadas `respalda` y no sé a dónde respaldarlas.\n"
980 " Pasá --respaldo <destino> (host:ruta o ruta local). No invento uno: un\n"
981 " respaldo a un sitio equivocado se ve igual que un respaldo.")
982 rsh = f"ssh -p {respaldo_port} {ssh_opts}" if respaldo_port else f"ssh {ssh_opts}"
983 remoto = ":" in respaldo.split("/", 1)[0]
984 for d in datos_resp:
985 ruta = d["path"]
986 # Aplanada: `/home/sergio/humanoid` → `home-sergio-humanoid`. El corral junta cosas de
987 # rutas distintas, y conservar el árbol haría que dos orígenes se pisaran en el mismo
988 # nombre. El nombre aplanado DICE de dónde salió, que es lo que hace falta para volver.
989 nombre = ruta.strip("/").replace("/", "-")
990 dst = respaldo.rstrip("/") + "/" + nombre
991 # ⚠ Un FICHERO no lleva barra final y su destino es el directorio que lo contiene.
992 # Con el censo detallado entran ficheros sueltos (`mapas.tgz`, `gu.png`, un `.docx`), y
993 # `rsync fichero/ destino/` no es «copiá el fichero»: es un error. El censo ya dice cuál
994 # es cuál (`tipo`), así que no hay que adivinarlo.
995 es_dir = d.get("tipo", "dir") != "fichero"
996 org = ruta + "/" if es_dir else ruta
997 dst_r = dst + "/" if es_dir else dst
998 # ⚠ `--mkpath` NO es opcional, y lo cazó el guardián de dos sentidos: sin él rsync
999 # muere con `mkdir "/home/respaldo-mudanza/prueba-guardian" failed` en cuanto el corral
1000 # tiene un nivel que todavía no existe — y el primer respaldo SIEMPRE lo tiene.
1001 base = (f"rsync -aH --mkpath --partial --partial-dir=.rsync-partial --info=stats2 "
1002 + (f"-e {shlex.quote(rsh)} " if remoto else "")
1003 + f"{shlex.quote(org)} {shlex.quote(dst_r)}")
1004 # La verificación se le pregunta a RSYNC, no a `du` ni a `find`: el corral puede ser un
1005 # Storage Box, cuya shell restringida no tiene `find` ni acepta tuberías (medido). Una
1006 # corrida en seco compara tamaño y fecha CONTRA EL DESTINO REAL y dice qué falta.
1007 ver = (f"pend=$({base.replace('rsync -aH ', 'rsync -aHn ').replace('--info=stats2', chr(39)+'--out-format=%n'+chr(39))}"
1008 f" | grep -v '/$' | wc -l); echo \"pendientes en el corral: $pend\"; [ \"$pend\" -eq 0 ]")
1009 paso("respaldo", f"respaldar {ruta} → {dst} ({d.get('size','?')})", base,
1010 verifica=ver,
1011 nota="NO se instala en el destino: esto es archivo, no mudanza. Y `du` en el "
1012 "corral puede dar MENOS que el origen sin que falte nada (un Storage Box "
1013 "comprime: 1,3 G subidos se veían como 576 M). Por eso verifica rsync.")
1014
1015 # ── 2. servicios ────────────────────────────────────────────────────────────────────────────
1016 for s in svc_muda:
1017 nd = s.get("class") == "no-declarado"
1018 # Antes de declarar: TRADUCIR lo que ya está escrito en el origen. Va como paso propio y no
1019 # metido dentro del de arriba porque tiene su propia verificación, y es HUMANA: `traducir.py`
1020 # sale ≠0 cuando algo quedó sin traducir, así que darlo por bueno por código de salida sería
1021 # justo al revés. Lo que verifica este paso es que alguien LEYÓ el acta.
1022 for tr in traducciones(s):
1023 paso("traducir", f"traducir {tr['que']}", tr["cmd"],
1024 verifica=f"# ¿leíste el acta de `{tr['que']}`? Cada línea SIN-TRADUCIR es"
1025 f" trabajo a mano que el destino NO va a hacer solo.",
1026 verifica_tipo="humano", nota=tr["nota"])
1027 paso("servicio", f"declarar y levantar {s['name']}" + (" ⚠ NO-DECLARADO" if nd else ""),
1028 ((f"# ⚠ SE ELIGIÓ UN EQUIVALENTE: {s['alternativa']} en vez de {s['name']}.\n"
1029 f"# Eso NO es cambiar un binario: hay que REESCRIBIR la configuración del servicio.\n"
1030 f"# La del origen no sirve tal cual.\n#\n")
1031 if s.get("alternativa") and s["alternativa"] != s["name"] else "")
1032 + (f"# DE DÓNDE SALE EL BINARIO: {origen_binario(s)[0]}\n"
1033 f"# {origen_binario(s)[1]}\n"
1034 f"#\n"
1035 f"# CÓMO CORRE HOY EN EL ORIGEN (leído de /proc, es lo que hay que reproducir):\n"
1036 f"# cmdline: {s.get('cmdline') or '(no se pudo leer)'}\n"
1037 + (f"# cwd : {s['cwd']}\n" if s.get("cwd") else "")
1038 + (f"# puertos: {', '.join(str(p) for p in s['ports'])}\n" if s.get("ports") else "")
1039 + f"#\n# 1) conseguir el binario según lo de arriba\n"
1040 f"# 2) DECLARARLO en el init del destino con ESA línea de comando\n"
1041 f"# (arje: una tarjeta en /ente/seed.card.json · systemd: una unit)\n"
1042 f"# 3) arrancarlo"),
1043 verifica=f"{ssh} 'ps -eo ppid,comm | awk \"\\$1==1\" | grep -w {shlex.quote(s['name'])}'"
1044 + (f" && {ssh} 'ss -lnt | grep -E \":({'|'.join(str(p) for p in s.get('ports', []))}) \"'"
1045 if s.get("ports") else ""),
1046 nota="⚠ ESTE SERVICIO CORRE SIN ESTAR DECLARADO en el origen: copiar el binario no lo "
1047 "levanta al arrancar. Hay que escribir su declaración — es el trabajo real de la "
1048 "mudanza, y el que se olvida (el caddy de la caja nueva murió así)." if nd else
1049 "Declarado en el origen: traducir su unidad al init del destino.")
1050
1051 # ── 3. dominios ─────────────────────────────────────────────────────────────────────────────
1052 for d in doms_muda:
1053 paso("dominio", f"apuntar {d['domain']} a la máquina nueva",
1054 f"# cambiar el registro A de {d['domain']}: {d.get('dns','?')} → <IP NUEVA>",
1055 verifica=f"getent ahostsv4 {d['domain']} | head -1 && "
1056 f"curl -sk -o /dev/null -w '%{{http_code}}' https://{d['domain']}/",
1057 nota="La mudanza NO está hecha hasta que el dominio contesta 2xx contra la IP NUEVA. "
1058 "Comprobarlo desde AFUERA, nunca desde la máquina: pedirle a un servidor sus "
1059 "propios dominios puede disparar su fail2ban (pasó).")
1060
1061 # ── 4. lo que muere ─────────────────────────────────────────────────────────────────────────
1062 if muere:
1063 # ⚠ Un dominio fósil no pesa nada POR SÍ MISMO: pesa lo que dejó en disco. Listarlo pelado
1064 # cumple la mitad de la regla 2 («por su nombre Y CON SU TAMAÑO») y deja lo caro invisible:
1065 # `terapeuta.ec` no resuelve en ningún DNS y tiene 279 M en `/var/www/terapeuta`. Que eso se
1066 # supiera dependía de que alguien se acordara.
1067 det = []
1068 for t, n, e in muere:
1069 tam = f" ({e.get('size')})" if e.get("size") else ""
1070 det.append(f"# {t:9} {n}{tam}")
1071
1072 # ⚠ Un dominio fósil no pesa nada POR SÍ MISMO: pesa lo que dejó en disco. Listarlo pelado
1073 # cumple la mitad de la regla 2 («por su nombre Y CON SU TAMAÑO») y deja lo caro invisible:
1074 # `terapeuta.ec` no resuelve en ningún DNS y tiene 279 M en `/var/www/terapeuta`. Que eso se
1075 # supiera dependía de que alguien se acordara.
1076 #
1077 # Se lista UN RENGLÓN POR DIRECTORIO, no uno por dominio: siete dominios `*.gioser.net` que
1078 # mueren reclaman el mismo `gioser.bak`, y repetirlo siete veces convierte el aviso en ruido.
1079 # Y se dice «podría», nunca «es»: el directorio se llama `terapeuta` y el dominio
1080 # `terapeuta.ec`. Emparejar «casi» acierta casi siempre, y el resto de las veces manda a
1081 # borrar lo que no era.
1082 if contenido:
1083 doms_muertos = [n for t, n, _ in muere if t == "dominio"]
1084 det.append("#")
1085 det.append("# CONTENIDO EN LAS RAÍCES WEB — esto NO lo mueve ningún paso de este plan.")
1086 # ⚠ Un directorio que la CONFIG referencia no es un huérfano, diga lo que diga su
1087 # nombre. Sin esto el censo marcó `/var/www/git-tawasuyu` como «nadie lo recuerda»
1088 # estando servido en la línea 174 del Caddyfile — y ese aviso, aplicado, tira el sitio.
1089 servidos = {}
1090 for st in censo.get("sitio", []):
1091 if st.get("raiz"):
1092 servidos.setdefault(st["raiz"].rstrip("/"), []).append(st.get("nombres", ""))
1093 for c in contenido:
1094 ruta = c["path"].rstrip("/")
1095 quien = [d for d in doms_muertos if c in candidatos(d, [c])]
1096 if ruta in servidos:
1097 marca = ("⚠ LO SIRVE la config para: " +
1098 ", ".join(" ".join(servidos[ruta]).split()[:3]) +
1099 " — no es huérfano; moverlo tira el sitio")
1100 elif quien:
1101 marca = ("podría ser de: " + ", ".join(quien[:4]) +
1102 (f" (+{len(quien)-4})" if len(quien) > 4 else ""))
1103 else:
1104 marca = "no corresponde a NINGÚN dominio que muera ni lo sirve la config: miralo"
1105 det.append(f"# {ruta:34} {c['size']:>6} ← {marca}")
1106
1107 paso("muere", f"{len(muere)} cosa(s) NO se mudan y mueren con la máquina vieja",
1108 "# NO SE BORRA NADA ACÁ. Esta lista existe para leerse antes de apagar el origen:\n"
1109 + "\n".join(det),
1110 verifica="revisión humana: leer la lista completa antes de destruir el origen",
1111 verifica_tipo="humano",
1112 nota="El día que se apague la máquina vieja esto no se puede recuperar. Que esté "
1113 "escrito ES el paso.")
1114 return P
1115
1116
1117def emitir(censo, P, target):
1118 L = ["# PLAN DE MUDANZA — generado por scripts/mudanza/planear.py (SDD 29 etapa 2).",
1119 "#",
1120 "# Cada paso lleva su COMANDO LITERAL: este fichero se puede ejecutar a mano, línea por",
1121 "# línea, sin la herramienta y sin el repo. Ésa es la idea — es el registro exportable.",
1122 'schema = "takana-plan/1"',
1123 f'fecha = "{time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())}"',
1124 f'origen = "{censo.get("maquina", {}).get("hostname", "?")}"',
1125 f'destino = "{target}"',
1126 ""]
1127 for i, p in enumerate(P, 1):
1128 L.append(f"[[paso]]")
1129 L.append(f'n = {i}')
1130 L.append(f'clase = "{p["clase"]}"')
1131 L.append(f'titulo = """{p["titulo"]}"""')
1132 L.append("cmd = " + bloque_toml(p["cmd"]))
1133 if p["verifica"]:
1134 L.append("verifica = " + bloque_toml(p["verifica"]))
1135 L.append(f'verifica_tipo = "{p["verifica_tipo"]}"')
1136 if p["nota"]:
1137 L.append("nota = " + bloque_toml(p["nota"]))
1138 L.append("")
1139 return "\n".join(L) + "\n"
1140
1141
1142def main():
1143 ap = argparse.ArgumentParser(description="Convierte un censo decidido en un plan ejecutable.")
1144 ap.add_argument("--censo", required=True)
1145 ap.add_argument("--target", required=True, help="usuario@host destino")
1146 ap.add_argument("--key", help="clave SSH para el destino")
1147 ap.add_argument("--decide", action="store_true",
1148 help="mostrar TODO con su recomendación y su motivo, y elegir")
1149 ap.add_argument("--revisar", action="store_true",
1150 help="sólo mostrar la revisión con recomendaciones, sin preguntar")
1151 ap.add_argument("--out", help="fichero del plan (default: stdout)")
1152 ap.add_argument("--censo-out", help="dónde escribir el censo con las decisiones tomadas "
1153 "(default: sobre el mismo censo, con copia `.bak`)")
1154 ap.add_argument("--respaldo", help="corral donde va lo marcado `respalda` (host:ruta o ruta "
1155 "local). Default: el Storage Box de respaldo-storagebox.sh")
1156 ap.add_argument("--respaldo-port", help="puerto SSH del corral (el Storage Box usa 23)")
1157 a = ap.parse_args()
1158
1159 with open(a.censo, "rb") as f:
1160 censo = tomllib.load(f)
1161 if a.revisar:
1162 revisar(censo, interactivo=False)
1163 return
1164 if a.decide:
1165 censo = revisar(censo, interactivo=True)
1166 # ── LAS DECISIONES SE GUARDAN, O NO EXISTIERON ──────────────────────────────────────────
1167 # Antes `--decide` sólo las usaba para generar el plan de esa corrida: cerrabas la terminal
1168 # y las 169 elecciones se perdían. El censo ES la interfaz (SDD 29 §3), así que volver a
1169 # escribirlo no es comodidad, es lo que hace que decidir a medias sea posible — y decidir
1170 # 169 cosas SIEMPRE se hace a medias.
1171 destino_censo = a.censo_out or a.censo
1172 guardar_censo(censo, destino_censo, respaldar=(destino_censo == a.censo))
1173 print(f" decisiones guardadas → {destino_censo}")
1174 validar(censo)
1175
1176 resp_dst, resp_port = (a.respaldo, a.respaldo_port)
1177 if not resp_dst:
1178 resp_dst, resp_port = destino_respaldo_default()
1179 P = pasos(censo, a.target, a.key, resp_dst, resp_port)
1180 por_clase = {}
1181 for p in P:
1182 por_clase[p["clase"]] = por_clase.get(p["clase"], 0) + 1
1183 print(f"\n══ PLAN: {censo.get('maquina',{}).get('hostname','?')} → {a.target} ══")
1184 for c, n in por_clase.items():
1185 print(f" {c:10} {n:3} paso(s)")
1186 txt = emitir(censo, P, a.target)
1187
1188 # ── el plan tiene que VOLVER A LEERSE, y eso se comprueba, no se supone ──────────────────────
1189 # No es celo: emitir TOML inválido ya pasó. Un comando con una barra de continuación de línea
1190 # rompía la cadena y el fichero quedaba ilegible — y el error no aparecía al generarlo sino
1191 # DESPUÉS, cuando alguien intentaba ejecutarlo, que es el peor momento posible. Escribir y
1192 # releer cuesta milisegundos y convierte un fallo diferido en uno inmediato.
1193 try:
1194 tomllib.loads(txt)
1195 except tomllib.TOMLDecodeError as e:
1196 sys.exit(f"✗ el plan generado NO es TOML válido: {e}\n"
1197 f" No se escribe nada. Un plan que no vuelve a parsear no se puede ejecutar ni\n"
1198 f" exportar, que son las dos únicas cosas para las que existe.")
1199
1200 if a.out:
1201 open(a.out, "w").write(txt)
1202 print(f"\n plan → {a.out} ({len(P)} pasos, con su comando literal cada uno)")
1203 else:
1204 print(txt)
1205
1206
1207if __name__ == "__main__":
1208 main()