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…
censar: 26 repositorios existen SÓLO en la máquina que se va a borrar — el paso 1 del plan
1#!/usr/bin/env python3
2"""censar.py — CENSO de una máquina: qué corre, qué sirve, qué datos tiene. Sin IA, sin adivinar.
3
4⚠ «Sólo lee» hay que decirlo con cuidado: NO ESCRIBE nada, pero las sondas de RED dejan huella. Ver
5`sondear_dominio` — censar gioser contra sí mismo hizo que su propio fail2ban lo baneara.
6
7Primer paso de la mudanza (SDD 29). Produce un inventario TOML que un humano revisa y que las etapas
8siguientes consumen. NO toca nada: todo lo que hace son lecturas.
9
10── LA REGLA QUE LO ORDENA TODO ─────────────────────────────────────────────────────────────────
11Cruzar SIEMPRE lo DECLARADO contra lo VIVO, y reportar las tres clases por separado:
12
13 vivo declarado Y corriendo ⇒ candidato a mudarse
14 declarado-muerto declarado y sin proceso ⇒ candidato a morir
15 no-declarado corriendo y sin declaración ⇒ EL TRABAJO REAL: nadie sabe cómo levantarlo
16
17No es teoría. Medido sobre gioser (2026-09-11):
18 · `rc-status` decía `stopped` de caddy, gitea, sshd, cronie y act-runner, y los CINCO estaban
19 vivos colgando de PID 1. Un censo que lea sólo el init habría producido un plan que no arranca.
20 · De los 19 dominios del Caddyfile, 8 no tenían DNS, 2 daban 502 y 3 ya vivían en OTRA máquina.
21 Sólo 6 eran reales. Un censo que lea sólo la config habría mudado 13 fósiles.
22 · Y el propio caddy de la caja NUEVA murió en un reinicio sin que nadie lo notara, porque estaba
23 arrancado a mano y no declarado. Esa es la clase `no-declarado`, y es la que duele.
24
25── POR QUÉ CADA SONDA ──────────────────────────────────────────────────────────────────────────
26`ppid==1` es la verdad de qué corre, no el init. Los sockets en LISTEN dicen qué SIRVE. El DNS y un
27GET dicen si alguien lo usa. `du` dice qué pesa. Nada de esto necesita juicio: son hechos, y el
28juicio (qué se muda, qué muere) lo pone el usuario en la etapa siguiente, sobre este fichero.
29
30Uso:
31 scripts/mudanza/censar.py --host root@1.2.3.4 [--key ~/.ssh/id] [--out censo.toml]
32 scripts/mudanza/censar.py --local # censa esta máquina
33
34La superficie va en inglés (CLAUDE.md regla 4); los mensajes, en castellano.
35"""
36import argparse, json, os, re, shlex, subprocess, sys, time
37
38# ── ejecución de sondas ─────────────────────────────────────────────────────────────────────────
39
40class Objetivo:
41 """Una máquina a censar. `run` devuelve (salida, ok) y NUNCA levanta: una sonda que falla es un
42 dato («esa máquina no tiene ss»), no un motivo para abortar el censo entero."""
43
44 def __init__(self, host=None, key=None, timeout=25):
45 self.host, self.key, self.timeout = host, key, timeout
46
47 def run(self, cmd):
48 if self.host:
49 base = ["ssh", "-o", "StrictHostKeyChecking=accept-new",
50 "-o", f"ConnectTimeout={self.timeout}", "-o", "BatchMode=yes"]
51 if self.key:
52 base += ["-i", os.path.expanduser(self.key)]
53 argv = base + [self.host, cmd]
54 else:
55 argv = ["sh", "-c", cmd]
56 try:
57 p = subprocess.run(argv, capture_output=True, text=True, timeout=self.timeout * 4)
58 return p.stdout.strip(), p.returncode == 0
59 except Exception as e:
60 return f"(sonda falló: {e})", False
61
62
63# ── sondas ──────────────────────────────────────────────────────────────────────────────────────
64
65def identidad(t):
66 """Quién es esta máquina. El hostname MIENTE (gioser dice `momento`): la IP es el discriminador."""
67 out, _ = t.run("hostname; ip -4 addr show scope global 2>/dev/null | grep -o 'inet [0-9.]*' | "
68 "cut -d' ' -f2 | head -3; uname -r; cat /proc/1/comm")
69 ls = [l for l in out.splitlines() if l.strip()]
70 return {
71 "hostname": ls[0] if ls else "?",
72 "ips": [l for l in ls[1:-2]] if len(ls) > 3 else [],
73 "kernel": ls[-2] if len(ls) >= 2 else "?",
74 "pid1": ls[-1] if ls else "?",
75 }
76
77
78def invocaciones(t, pids):
79 """La LÍNEA DE COMANDO y el `cwd` de cada servicio vivo, leídos de `/proc`.
80
81 Es el dato que convierte `no-declarado` de «acá hay un problema» en «acá está la solución»: si
82 nadie sabe cómo levantar un servicio, lo que hace falta para declararlo es exactamente cómo se
83 está ejecutando ahora. Sin esto el plan sólo puede decir «declaralo», que es lo que uno ya sabía.
84
85 ⚠ Se lee `cmdline` y `cwd`, NO el entorno: `/proc/<pid>/environ` suele traer tokens y
86 contraseñas, y un censo que se guarda en un fichero y se manda por ahí no puede llevarlos."""
87 out = {}
88 for nombre, ps in pids.items():
89 pid = ps[0]
90 # ⚠ SONDAS SEPARADAS, y es un bug pagado: iban en un solo comando, y como `readlink
91 # /proc/<pid>/cwd` necesita permiso de ptrace (dueño o root), en cualquier proceso de root
92 # el comando entero salía ≠0 y se descartaba TAMBIÉN el `cmdline`, que sí se podía leer.
93 # Resultado: 26 de 37 servicios sin invocación, justo el dato que da sentido al censo.
94 # Una sonda que falla es un dato; no puede arrastrarse a las que funcionaron.
95 cmd, _ = t.run(f"tr '\\0' ' ' < /proc/{pid}/cmdline 2>/dev/null")
96 cwd, _ = t.run(f"readlink /proc/{pid}/cwd 2>/dev/null")
97 # ⚠ Tercera sonda, y también separada. Muchos demonios REESCRIBEN su `argv[0]` para decir en
98 # qué andan (`sshd: /usr/bin/sshd [listener]`, `php-fpm: master process (…)`), así que la
99 # línea de comando NO dice cuál es el binario. `/proc/<pid>/exe` sí — pero necesita permiso
100 # de ptrace, o sea ser el dueño o root. Medido en gioser con uid 1001: 7 de 38 servicios
101 # quedaban en «no se pudo leer su binario» por esto, y no por ser realmente desconocidos.
102 exe, _ = t.run(f"readlink /proc/{pid}/exe 2>/dev/null")
103 cmd, cwd, exe = cmd.strip(), cwd.strip(), exe.strip()
104 # ⚠⚠ `/proc/<pid>/exe` termina en « (deleted)» cuando el fichero YA NO ESTÁ en disco: el
105 # proceso sostiene el inodo y nadie más lo puede abrir por su ruta. Medido en gioser: CUATRO
106 # servicios están así, y en dos de ellos hay AHORA otro fichero en la misma ruta, de distinto
107 # tamaño — `tejido` corre 12 750 368 bytes y en su ruta hay 13 815 864. Copiar la ruta muda
108 # OTRA COSA, en silencio, y el servicio nuevo no es el que estaba andando.
109 #
110 # Se recupera leyendo `/proc/<pid>/exe`, y SÓLO mientras el proceso viva: al reiniciar gioser
111 # —o al morirse ese pid— ese binario desaparece para siempre. En una mudanza que termina
112 # BORRANDO el origen, esto es lo más urgente del censo.
113 borrado = exe.endswith(" (deleted)")
114 if borrado:
115 exe = exe[:-len(" (deleted)")]
116 vivo_b = disco_b = ""
117 if borrado:
118 v, _ = t.run(f"stat -L -c %s /proc/{pid}/exe 2>/dev/null")
119 d, _ = t.run(f"stat -c %s {shlex.quote(exe)} 2>/dev/null")
120 vivo_b = v.strip() if v.strip().isdigit() else ""
121 disco_b = d.strip() if d.strip().isdigit() else ""
122 for v in ("cmd", "cwd", "exe"):
123 if locals()[v].startswith("(sonda falló"):
124 cmd, cwd, exe = (("" if v == "cmd" else cmd), ("" if v == "cwd" else cwd),
125 ("" if v == "exe" else exe))
126 sup = SUPERVISADOS.get(pid)
127 if sup:
128 cmd, exe = sup["cmdline"], sup["exec"]
129 if cmd or cwd or exe:
130 out[nombre] = {"cmdline": cmd, "cwd": cwd,
131 "exe": exe if exe.startswith("/") else "",
132 "usuario": (sup or {}).get("usuario", ""),
133 "exe_borrado": borrado, "pid": pid,
134 "bytes_vivo": vivo_b, "bytes_disco": disco_b}
135 return out
136
137
138def duenos(t, ejecutables):
139 """¿Quién PROVEE el binario de cada servicio? Determinista, preguntándole al gestor de paquetes
140 del origen.
141
142 Es lo que convierte «instalá el paquete» —que es lo que uno ya sabía— en una instrucción: o el
143 binario lo trae un paquete con nombre, o NO lo trae nadie y entonces es un compilado suelto que
144 hay que llevar o reconstruir. La diferencia decide el trabajo, y no se adivina.
145
146 Una consulta por lote, no una por servicio: son decenas de servicios y cada `ssh` cuesta."""
147 if not ejecutables:
148 return {}
149 lista = " ".join(shlex.quote(e) for e in sorted(set(ejecutables)))
150 # Se prueba el gestor que exista. `2>/dev/null || echo -` ⇒ un fichero sin dueño no aborta el lote.
151 guion = (
152 'for f in %s; do '
153 ' if command -v pacman >/dev/null 2>&1; then o=$(pacman -Qoq "$f" 2>/dev/null); '
154 ' elif command -v dpkg >/dev/null 2>&1; then o=$(dpkg -S "$f" 2>/dev/null | cut -d: -f1); '
155 ' elif command -v apk >/dev/null 2>&1; then o=$(apk info -W "$f" 2>/dev/null | tail -1 '
156 ' | sed "s/.* is owned by //;s/-[0-9].*//"); '
157 ' elif command -v rpm >/dev/null 2>&1; then o=$(rpm -qf "$f" 2>/dev/null); '
158 ' else o=""; fi; '
159 ' echo "$f|${o:-}"; done'
160 ) % lista
161 out, _ = t.run(guion)
162 res = {}
163 for l in out.splitlines():
164 if "|" in l:
165 f, o = l.split("|", 1)
166 res[f.strip()] = o.strip()
167 return res
168
169
170# Envoltorios que NO son el servicio: el nombre de verdad está en sus argumentos. Sin desenvolverlos,
171# los CINCO `supervise-daemon` de gioser se juntaban en UNA entrada llamada `supervise-daemo` — cinco
172# servicios distintos (shuma-daemon, dbus, metalog…) colapsados en una tarjeta con el nombre del
173# envoltorio. Un servicio de más es ruido; cinco servicios fundidos en uno es un plan que no arranca.
174SUPERVISORES = {"supervise-daemon", "start-stop-daemon", "s6-supervise", "runsv", "daemonize"}
175_COMM_SUP = {s[:15] for s in SUPERVISORES}
176
177# pid → lo que el supervisor manda de verdad. Se llena al listar los procesos y se consulta al leer
178# `/proc`: el pid con ppid==1 es el SUPERVISOR, así que su `cmdline` y su `exe` describen al
179# envoltorio, no al servicio.
180SUPERVISADOS = {}
181
182
183def _mandado_por_supervisor(args):
184 """El comando REAL que hay detrás de `supervise-daemon`, y con qué usuario corre.
185
186 El formato es `supervise-daemon <servicio> --start [opciones] <ejecutable> -- [argumentos]`, así
187 que el ejecutable es el ÚLTIMO token antes del `--` suelto. Comprobado contra los cinco de gioser
188 (dbus, dhcpcd, metalog, squid, shuma-daemon).
189
190 ⚠ Sin esto, el censo guardaba como `cmdline` la línea del SUPERVISOR — y una tarjeta de arje
191 hecha con eso arrancaría `supervise-daemon` DENTRO de arje, que ya supervisa. Y el `exec` salía
192 `/usr/bin/supervise-daemon`, o sea que `squid` figuraba como provisto por el paquete `openrc`.
193
194 ⚠⚠ Y se rescata el `--user`: `shuma-daemon` corre como `sergio`. Perder ese dato al desenvolver
195 sería la misma elisión que el escritor de arje reporta como SIN-TRADUCIR — un servicio que en el
196 origen corría sin privilegios terminaría de root en el destino, y nadie se enteraría."""
197 p = args.split()
198 if "--start" not in p:
199 return "", "", ""
200 resto = p[p.index("--start") + 1:]
201 usuario = ""
202 for i, x in enumerate(resto):
203 if x in ("--user", "-u") and i + 1 < len(resto):
204 usuario = resto[i + 1]
205 break
206 corte = resto.index("--") if "--" in resto else len(resto)
207 izq, der = resto[:corte], resto[corte + 1:]
208 if not izq or not izq[-1].startswith("/"):
209 return "", "", usuario
210 return izq[-1], " ".join([izq[-1]] + der), usuario
211
212
213def _desenvolver(comm, args):
214 """(nombre_real, args_reales) para un proceso que puede ser un envoltorio."""
215 p = args.split()
216 if not p:
217 return comm, args
218 base = os.path.basename(p[0])
219 if base not in SUPERVISORES and comm not in {s[:15] for s in SUPERVISORES}:
220 return comm, args
221 if base in ("supervise-daemon", "s6-supervise", "runsv") and len(p) > 1:
222 # `supervise-daemon <servicio> --start …` · `runsv /etc/service/<servicio>`
223 return os.path.basename(p[1].rstrip("/")), args
224 for i, x in enumerate(p): # start-stop-daemon
225 if x in ("--name", "-n") and i + 1 < len(p):
226 return p[i + 1], args
227 if x in ("--exec", "-x", "--startas", "-a") and i + 1 < len(p):
228 return os.path.basename(p[i + 1]), args
229 return comm, args
230
231
232def _destruncar(comm, args):
233 """`comm` viene del kernel y está capado a 15 caracteres: `willay-crosscheck` llega como
234 `willay-crossche`. Ese nombre truncado no es cosmético — es el que el plan mete en
235 `--in /etc/init.d/<nombre>` (ruta que no existe) y el que va de `label` en la tarjeta de arje.
236 La línea de comando sí trae el nombre entero, así que se usa ESA cuando confirma al truncado."""
237 if len(comm) < 15:
238 return comm
239 p = args.split()
240 if p:
241 base = os.path.basename(p[0])
242 if base.startswith(comm):
243 return base
244 return comm
245
246
247def procesos_vivos(t):
248 """Lo que REALMENTE corre, colgado de PID 1. La verdad, no la declaración."""
249 out, _ = t.run("ps -eo pid=,ppid=,comm=,args= 2>/dev/null | awk '$2==1 && $1!=1'")
250 vivos = {}
251 for l in out.splitlines():
252 parts = l.split(None, 3)
253 if len(parts) < 3 or not parts[0].isdigit():
254 continue
255 pid, comm, args = int(parts[0]), parts[2], (parts[3] if len(parts) > 3 else "")
256 nombre, args = _desenvolver(comm, args)
257 nombre = _destruncar(nombre, args)
258 exe, linea, usuario = _mandado_por_supervisor(args) if comm[:15] in _COMM_SUP else ("", "", "")
259 if exe:
260 SUPERVISADOS[pid] = {"exec": exe, "cmdline": linea, "usuario": usuario}
261 vivos.setdefault(nombre, []).append(pid)
262 # los kernel threads no son servicios
263 return {k: v for k, v in vivos.items() if not k.startswith(("kworker", "kthread", "ksoftirq",
264 "migration", "rcu_", "irq/", "idle_"))}
265
266
267def puertos(t):
268 """Qué SIRVE esta máquina, y quién. Un servicio sin puerto no se muda igual que uno con puerto."""
269 out, ok = t.run("ss -lntpH 2>/dev/null || netstat -lntp 2>/dev/null | tail -n +3")
270 res = []
271 for l in out.splitlines():
272 m = re.search(r'(\S+):(\d+)\s', l)
273 proc = re.search(r'\("([^"]+)"|/(\S+)\s*$', l)
274 # El PID es lo que ata el puerto a un servicio sin ambigüedad. Ver comentario en la
275 # asignación: por NOMBRE, un `shuma` declarado-muerto se quedaba con el puerto del
276 # `shuma-gateway` que lo escucha de verdad.
277 pidm = re.search(r'pid=(\d+)', l)
278 res.append({"addr": m.group(1), "port": int(m.group(2)),
279 "proc": (proc.group(1) or proc.group(2)) if proc else "?",
280 "pid": int(pidm.group(1)) if pidm else 0}) if m else None
281 # dedup por (puerto, proc)
282 vistos, uniq = set(), []
283 for r in sorted(res, key=lambda x: x["port"]):
284 k = (r["port"], r["proc"], r.get("pid", 0))
285 if k not in vistos:
286 vistos.add(k); uniq.append(r)
287 return uniq
288
289
290def declarados(t):
291 """Lo que el init DICE que hay. Se compara contra lo vivo — no se cree."""
292 fuentes = {}
293 # `rc-status -a` lista TODO lo disponible en el sistema, no lo que esta máquina usa: en gioser
294 # daba 100 «declarado-muerto» que no significan nada. `rc-update show` da lo ENCENDIDO por
295 # runlevel, que es lo que de verdad se declara.
296 out, ok = t.run("rc-update show 2>/dev/null | awk '{print $1}' | grep -E '^[a-z]'")
297 if ok and out:
298 fuentes["openrc"] = out.split()
299 out, ok = t.run("systemctl list-units --type=service --no-legend --no-pager 2>/dev/null | awk '{print $1}'")
300 if ok and out:
301 fuentes["systemd"] = [s.replace(".service", "") for s in out.split()]
302 out, ok = t.run("ls /etc/arje/cards.d/ 2>/dev/null")
303 if ok and out:
304 fuentes["arje-cards"] = [s.replace(".json", "") for s in out.split()]
305 out, ok = t.run("python3 -c \"import json;print(' '.join(n['label'] for n in "
306 "json.load(open('/ente/seed.card.json'))['genesis']))\" 2>/dev/null")
307 if ok and out:
308 fuentes["arje-seed"] = out.split()
309 out, ok = t.run("ls /etc/service /run/runit/service 2>/dev/null")
310 if ok and out:
311 fuentes["runit"] = out.split()
312 return fuentes
313
314
315# Config del servidor web → qué sitio apunta a qué directorio. Se lee con los LECTORES del centro de
316# traducción (`formatos/`), no con un parser propio: ya existen para caddy, nginx y apache, y tener
317# dos parsers del mismo formato es cómo se separan sin que nadie lo note.
318_CONFS = [("/etc/caddy/Caddyfile", "caddy"),
319 ("/etc/nginx/nginx.conf", "nginx"),
320 ("/etc/nginx/sites-enabled/*", "nginx"),
321 ("/etc/apache2/sites-enabled/*", "apache"),
322 ("/etc/httpd/conf.d/*", "apache")]
323
324
325def repos_git(t, raices, ips, dominios):
326 """Repositorios git bajo los datos, y si su remoto vive EN ESTA MÁQUINA.
327
328 ── LA DEPENDENCIA CIRCULAR QUE MATA LA MUDANZA AL FINAL ─────────────────────────────────────
329 Medido en gioser: **25 repositorios cuyo único remoto es el gitea de la propia máquina** — entre
330 ellos `tawasuyu`, que produce 10 de los 13 binarios que nadie más provee. Apagar el origen no
331 borra sólo unos servicios: borra **el código con el que se volverían a construir**, y los clones
332 de trabajo están en el mismo disco que también muere.
333
334 Es un fallo que no se ve desde ninguna otra parte del censo —el repo no es un proceso, ni un
335 puerto, ni un dominio— y que sólo se descubre cuando ya no hay de dónde sacarlo.
336
337 Un remoto que apunta AFUERA es la prueba de que el código sobrevive. Por eso lo que se reporta no
338 es «tiene remoto» sino **si alguno de sus remotos NO es esta máquina**."""
339 if not raices:
340 return []
341 busca = " ".join(shlex.quote(r) for r in raices)
342 out, ok = t.run(f"find {busca} -maxdepth 4 -name .git -prune 2>/dev/null | head -300")
343 if not ok or not out.strip():
344 return []
345 mios = set(dominios) | set(ips) | {"localhost", "127.0.0.1"}
346 res = []
347 for g in out.split():
348 r = g[:-5] if g.endswith("/.git") else g
349 urls, ok2 = t.run(f"git -C {shlex.quote(r)} config --get-regexp "
350 f"'remote\\..*\\.(url|pushurl)' 2>/dev/null")
351 if not ok2 or not urls.strip() or urls.startswith("(sonda falló"):
352 continue
353 dentro, fuera = [], []
354 for l in urls.splitlines():
355 p = l.split(None, 1)
356 if len(p) != 2:
357 continue
358 u = p[1]
359 # `ssh://gitea@host:2345/x.git`, `gitea@host:x.git`, `https://host/x.git`
360 h = u.split("://", 1)[-1].split("/", 1)[0].split("@")[-1].split(":")[0]
361 (dentro if h in mios else fuera).append(u)
362 if dentro:
363 res.append({"path": r, "dentro": " ".join(dentro),
364 "fuera": " ".join(fuera),
365 "solo_aqui": "si" if not fuera else "no"})
366 return res
367
368
369def sitios_web(t):
370 """Los sitios declarados en la config, con su raíz y si esa raíz EXISTE.
371
372 ── POR QUÉ ESTO NO LO PODÍA DECIR EL DNS ───────────────────────────────────────────────────
373 La sonda DNS dice si un dominio resuelve; no si el servidor tiene algo que servirle. Un bloque
374 cuyo `root` apunta a un directorio que NO existe es un fósil que devuelve 502 — y eso se lee del
375 fichero: **sin red, sin pedirle una página al servidor, sin arriesgar su fail2ban**. Medido en
376 gioser: 3 sitios (`aura`, `sigma`, `kosmofono`) apuntan a raíces borradas, lo que explica los
377 502 que en su día hicieron que el censo se baneara a sí mismo al sondearlos por HTTP.
378
379 Y sirve para lo contrario: un directorio que la config SÍ referencia no es un huérfano. Sin esto
380 el censo marcó `/var/www/git-tawasuyu` como «nadie lo recuerda» cuando es un sitio vivo."""
381 import formatos
382 lectores, _ = formatos.cargar()
383 res = []
384 for patron, fmt in _CONFS:
385 if fmt not in lectores:
386 continue
387 ficheros = [patron]
388 if "*" in patron:
389 out, ok = t.run(f"ls -1 {patron} 2>/dev/null")
390 ficheros = out.split() if ok and out.strip() else []
391 for f in ficheros:
392 texto, ok = t.run(f"cat {f} 2>/dev/null")
393 if not ok or not texto.strip() or texto.startswith("(sonda falló"):
394 continue
395 try:
396 cfg = lectores[fmt][0](texto, f)
397 except Exception as e:
398 # Un parser que revienta NO puede tumbar el censo entero, pero tampoco callarse:
399 # sin esto uno cree que el servidor no declara sitios, que es lo contrario del dato.
400 res.append({"config": f, "formato": fmt, "nombres": "", "raiz": "",
401 "raiz_existe": "error", "detalle": f"no se pudo leer: {e}"[:120]})
402 continue
403 for s in cfg.sitios:
404 # El `root` del sitio Y los de sus rutas anidadas: un `handle` con su propio `root`
405 # referencia disco igual, y no verlo es lo que hacía pasar por huérfano a un sitio vivo.
406 raices = [(s.raiz or "").rstrip("/")] + [
407 a.valor.rstrip("/") for r in s.rutas for a in r.acciones if a.tipo == "archivos"]
408 # A DÓNDE PROXEA este sitio: la config declara de qué servicios depende, y eso es
409 # lo único que puede cazar «este dominio se muda y el servicio que lo sirve se mata».
410 prox = [a.valor for a in s.acciones if a.tipo == "proxy"] + [
411 a.valor for r in s.rutas for a in r.acciones if a.tipo == "proxy"]
412 for raiz in dict.fromkeys(x for x in raices if x) or [""]:
413 res.append({"config": f, "formato": fmt,
414 "nombres": " ".join(s.nombres), "raiz": raiz,
415 "proxies": " ".join(dict.fromkeys(prox)),
416 "raiz_existe": "", "detalle": ""})
417 # Un solo comando para todas las raíces: una sonda por directorio sobre SSH es lentísima.
418 raices = sorted({r["raiz"] for r in res if r["raiz"]})
419 if raices:
420 guion = "; ".join(f'[ -d {shlex.quote(d)} ] && echo "SI {d}" || echo "NO {d}"' for d in raices)
421 out, _ = t.run(guion)
422 estado = {}
423 for l in out.splitlines():
424 p = l.split(None, 1)
425 if len(p) == 2:
426 estado[p[1]] = "si" if p[0] == "SI" else "no"
427 for r in res:
428 if r["raiz"]:
429 r["raiz_existe"] = estado.get(r["raiz"], "?")
430 return res
431
432
433def dominios(t):
434 """Los dominios que la máquina DICE servir, contrastados con DNS y con un GET real.
435
436 Las tres respuestas posibles importan y son distintas: sin DNS (nadie lo resuelve), con DNS pero
437 5xx (backend caído), y con DNS y 200 (vivo). Y hay una cuarta que sólo se ve mirando a DÓNDE
438 resuelve: un dominio que responde 200 desde OTRA IP ya está mudado, y su bloque de config acá
439 es un fósil."""
440 confs = ["/etc/caddy/Caddyfile", "/etc/nginx/nginx.conf", "/etc/nginx/sites-enabled/*",
441 "/etc/apache2/sites-enabled/*", "/etc/httpd/conf.d/*"]
442 out, _ = t.run("cat " + " ".join(confs) + " 2>/dev/null")
443 nombres = set()
444 for l in out.splitlines():
445 s = l.strip()
446 if s.startswith("#"):
447 continue
448 # caddy: «a.com, b.com {» · nginx/apache: «server_name a.com b.com;» / «ServerName a.com»
449 if s.endswith("{") and not s.startswith(("@", "}")):
450 cand = s[:-1]
451 elif s.lower().startswith(("server_name", "servername", "serveralias")):
452 cand = s.split(None, 1)[1].rstrip(";") if len(s.split(None, 1)) > 1 else ""
453 else:
454 continue
455 for d in re.split(r'[,\s]+', cand):
456 d = d.strip().rstrip(";")
457 if re.fullmatch(r'[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9-]+)+', d, re.I):
458 nombres.add(d.lower())
459 return sorted(nombres)
460
461
462def sondear_dominio(d, ips_maquina, http=True):
463 """DNS (+ HTTP opcional) desde donde corre el censo. Determinista, sin juicio.
464
465 ⚠⚠ **NO se hace contra la máquina que uno está censando desde ella misma.** «Sólo lee» era falso:
466 leer POR RED tiene efectos. Medido el 2026-09-11 — censar gioser en modo `--local` disparó 29
467 peticiones HTTPS a sus propios dominios, varios devuelven 502, y su `fail2ban` (jaula
468 `caddy-backend-down`) **baneó la propia IP de la máquina**. Resultado: gioser dejó de poder hablar
469 con su propio gitea y los `git push` empezaron a fallar con «Could not read from remote
470 repository». Un censo que deja la máquina incomunicada no es de sólo lectura.
471
472 Y además es metodológicamente mejor: lo que interesa es **qué ve el mundo**, no qué ve la máquina
473 de sí misma. Por eso la sonda se hace desde donde corre el censo —el operador o la caja nueva— y
474 se SALTA cuando se censa en local, salvo `--probe` explícito.
475
476 ── PERO EL DNS NO TOCA AL ORIGEN ───────────────────────────────────────────────────────────
477 Lo que dispara el fail2ban es el HTTP, no la resolución: `getent` le pregunta al DNS, no al
478 servidor. Con `--probe-dns` se sondea SÓLO el nombre, y eso ya contesta la pregunta que más
479 pesa en una mudanza — **cuáles de estos dominios siguen apuntando acá y cuáles son fósiles**.
480 Lo que el DNS solo NO puede decir es si el backend contesta, así que esos dominios quedan en
481 `apunta-aca`, que es una clase propia y no `vivo`: decir «vivo» sin haber pedido una página
482 sería exactamente la respuesta falsa con forma de respuesta que este censo existe para evitar."""
483 ip = ""
484 try:
485 r = subprocess.run(["getent", "ahostsv4", d], capture_output=True, text=True, timeout=10)
486 if r.returncode == 0 and r.stdout.strip():
487 ip = r.stdout.split()[0]
488 except Exception:
489 pass
490 code = ""
491 if ip and http:
492 try:
493 r = subprocess.run(["curl", "-sk", "-o", "/dev/null", "-w", "%{http_code}",
494 "--max-time", "8", f"https://{d}/"], capture_output=True, text=True, timeout=20)
495 code = r.stdout.strip() or "000"
496 except Exception:
497 pass
498 if not ip:
499 clase = "fosil-sin-dns"
500 elif ip not in ips_maquina:
501 clase = "ya-mudado" # resuelve a otra máquina: el bloque de acá es fósil
502 elif not http:
503 clase = "apunta-aca" # resuelve acá; si SIRVE no se preguntó, y no se inventa
504 elif code.startswith(("2", "3")):
505 clase = "vivo"
506 else:
507 clase = "backend-caido"
508 return {"domain": d, "dns": ip, "http": code, "class": clase}
509
510
511def datos(t, raices):
512 """Qué pesa y dónde. Sin esto no se puede dimensionar la mudanza — y `du` sobre hardlinks MIENTE
513 para dimensionar una COPIA (medido: 60 G por `du`, 85 G al copiar sin `-H`), así que se reportan
514 los dos números."""
515 res = []
516 for r in raices:
517 out, ok = t.run(f"du -sh {shlex.quote(r)} 2>/dev/null | cut -f1; "
518 f"du -sh --count-links {shlex.quote(r)} 2>/dev/null | cut -f1")
519 ls = out.splitlines()
520 if ok and ls:
521 res.append({"path": r, "size": ls[0],
522 "size_copy": ls[1] if len(ls) > 1 else ls[0]})
523 return res
524
525
526def montajes(t):
527 out, _ = t.run("df -h 2>/dev/null | grep -vE 'tmpfs|devtmpfs|^Filesystem|^Sist' ")
528 res = []
529 for l in out.splitlines():
530 f = l.split()
531 if len(f) >= 6:
532 res.append({"dev": f[0], "size": f[1], "used": f[2], "avail": f[3], "mount": f[-1]})
533 return res
534
535
536def fuera_de_git(t):
537 """Lo que NO viaja con el repo y sin lo cual el servidor nuevo no funciona. Se reporta la
538 EXISTENCIA, nunca el contenido: un censo no copia secretos."""
539 cands = ["~/.ssh", "/root/.ssh", "~/.config/hammer", "/root/.config/hammer",
540 "/etc/caddy", "/etc/nginx", "/etc/letsencrypt", "/var/lib/gitea",
541 "/etc/arje/cards.d", "/ente"]
542 res = []
543 for c in cands:
544 out, ok = t.run(f"ls -d {c} >/dev/null 2>&1 && ls -1 {c} 2>/dev/null | head -20")
545 if ok:
546 res.append({"path": c, "entries": out.split() if out else []})
547 out, _ = t.run("crontab -l 2>/dev/null | grep -vE '^#|^$' | wc -l")
548 if out.isdigit() and int(out) > 0:
549 res.append({"path": "crontab", "entries": [f"{out} líneas"]})
550 return res
551
552
553def contenido_web(t, raices=("/var/www", "/srv")):
554 """Qué hay en las raíces de contenido web, con su tamaño. Un nivel, sin juicio.
555
556 ── POR QUÉ EXISTE ──────────────────────────────────────────────────────────────────────────
557 La regla 2 del plan dice que lo que muere se nombra «por su nombre Y CON SU TAMAÑO». Los
558 servicios y los datos ya lo cumplían; los DOMINIOS no — se listaban pelados, y un dominio fósil
559 no pesa nada por sí mismo: pesa lo que dejó en disco. `terapeuta.ec` no resuelve en ningún DNS y
560 tiene 279 M en `/var/www/terapeuta`. Que eso se supiera dependía de que alguien se acordara.
561
562 ⚠ **No se afirma la correspondencia, se OFRECE.** El directorio se llama `terapeuta` y el
563 dominio `terapeuta.ec`: no coinciden. Una regla difusa que empareje «casi» acierta la mayoría de
564 las veces y el resto de las veces manda a borrar lo que no era. Se listan los candidatos con su
565 tamaño y decide el humano — y se listan TAMBIÉN los directorios que no se parecen a ningún
566 dominio, que son los que nadie recuerda (`gioser.bak.20260501`, `ogisoer`)."""
567 res = []
568 for raiz in raices:
569 out, ok = t.run(f"du -sh {raiz}/* 2>/dev/null | sort -rh | head -40")
570 if not ok or not out.strip():
571 continue
572 for l in out.splitlines():
573 p = l.split(None, 1)
574 if len(p) == 2 and p[1].startswith("/"):
575 res.append({"path": p[1], "size": p[0], "raiz": raiz})
576 return res
577
578
579def candidatos_de(dominio, contenido):
580 """Directorios que PODRÍAN ser de este dominio. Por etiqueta principal, no por nombre completo."""
581 d = dominio.lower()
582 etiquetas = [x for x in d.split(".") if x not in ("www", "com", "net", "org", "ec", "io", "dev")]
583 principal = etiquetas[-1] if etiquetas else d
584 out = []
585 for c in contenido:
586 base = os.path.basename(c["path"]).lower()
587 if principal and (principal in base or base.split(".")[0] in etiquetas):
588 out.append(c)
589 return out
590
591
592# ── clasificación ───────────────────────────────────────────────────────────────────────────────
593
594# Nombres que NO son servicios: son el andamiaje del sistema o hijos de un servicio. Contarlos como
595# `no-declarado` es ruido, y un censo con hallazgos falsos se ignora entero.
596NO_SERVICIOS = {
597 "agetty", "getty", "login", "bash", "sh", "dash", "zsh", "ssh", "sshd-session", "su", "sudo",
598 "bwrap", "ps", "awk", "sed", "tail", "sleep", "rsync", "scp", "cat", "python3", "perl",
599 # Restos de tubería reparentados a PID 1 cuando su padre muere. Medido: `head -15` figuraba como
600 # servicio `no-declarado` con ppid==1. No se esconden —salen en `descartados`, porque un huérfano
601 # ES un hallazgo— pero no son servicios y contarlos como tales es el ruido que mata un censo.
602 "head", "tr", "cut", "grep", "wc", "find", "xargs", "tee", "sort", "uniq", "env", "nohup",
603 "timeout", "flock", "tar", "gzip", "zstd", "dd", "md5sum", "sha256sum", "less", "more",
604}
605
606
607def normalizar(n):
608 """Un mismo servicio se llama distinto en cada sitio: OpenRC dice `act-runner`, `ps` dice
609 `act_runner`, systemd dice `act-runner.service`, y los getty por tty son `agetty.tty1`,
610 `agetty-tty2`… Sin normalizar, el MISMO proceso sale a la vez como `no-declarado` y como
611 `declarado-muerto`, que son las dos clases que más importan. Medido en gioser: pasaba con
612 `act_runner`."""
613 n = n.strip().lower()
614 for suf in (".service", ".socket", ".timer", ".target"):
615 if n.endswith(suf):
616 n = n[: -len(suf)]
617 n = n.replace("_", "-")
618 n = re.sub(r'[.\-]tty\d+$', '', n) # agetty.tty1 / agetty-tty2 → agetty
619 n = re.sub(r'\d+$', '', n) if re.fullmatch(r'[a-z-]+\d+', n) else n
620 return n
621
622
623def emparenta(vivo, declarado):
624 """¿Son el mismo servicio con distinto nombre? Los desajustes son sistemáticos, no caprichosos:
625 el DEMONIO y la UNIDAD se llaman distinto. Medidos en gioser: `crond`↔`cronie`,
626 `dbus-daemon`↔`dbus`, `fail2ban-server`↔`fail2ban`, `elogind-daemon`↔`elogind`.
627
628 Sin esto, cada uno de ésos aparece a la vez como `no-declarado` (falso: sí está declarado) y como
629 `declarado-muerto` (falso: sí está corriendo) — las dos clases que más importan, las dos mal."""
630 if vivo == declarado:
631 return True
632 for suf in ("-daemon", "-server", "-bin"):
633 if vivo.endswith(suf) and vivo[: -len(suf)] == declarado:
634 return True
635 # `crond` → `cron`, prefijo de `cronie`. `sshd` → `ssh`. Sólo quitando UNA `d` final y exigiendo
636 # prefijo: quitar letras a ciegas emparenta cosas que no tienen nada que ver.
637 if len(vivo) > 4 and vivo.endswith("d") and declarado.startswith(vivo[:-1]):
638 return True
639 return False
640
641
642def es_nombre_de_servicio(n):
643 """Descarta lo que claramente no es un servicio: versiones (`2.1.240`), rutas, vacíos. Salieron
644 de parsear `rc-status -a`, cuya salida incluye líneas que no son unidades."""
645 return bool(re.fullmatch(r'[a-z][a-z0-9@._+-]{1,40}', n)) and not re.fullmatch(r'[\d.]+', n)
646
647
648def clasificar(vivos, decl):
649 """Las tres clases. `no-declarado` es la importante: corre y nadie sabe cómo levantarlo."""
650 # índice normalizado: nombre-canónico → fuentes que lo declaran
651 idx = {}
652 for fuente, nombres in decl.items():
653 for n in nombres:
654 if es_nombre_de_servicio(n.lower()):
655 idx.setdefault(normalizar(n), set()).add(fuente)
656
657 out, vistos, descartados = [], set(), []
658 for nombre, pids in sorted(vivos.items()):
659 canon = normalizar(nombre)
660 if canon in NO_SERVICIOS or not es_nombre_de_servicio(canon):
661 # No se esconde: un proceso con ppid==1 que no es un servicio suele ser un HUÉRFANO, y
662 # eso es un hallazgo (procesos fugados que retienen locks, por ejemplo).
663 descartados.append(nombre)
664 continue
665 fuentes = sorted(idx.get(canon, set()))
666 if not fuentes: # segunda pasada: demonio vs unidad
667 emparentados = [f for d, fs in idx.items() if emparenta(canon, d) for f in fs]
668 fuentes = sorted(set(emparentados))
669 if fuentes:
670 vistos.update(d for d in idx if emparenta(canon, d))
671 vistos.add(canon)
672 out.append({"name": nombre, "pids": pids,
673 "class": "vivo" if fuentes else "no-declarado",
674 "declared_in": fuentes})
675 for canon in sorted(set(idx) - vistos):
676 if canon in NO_SERVICIOS:
677 continue
678 out.append({"name": canon, "pids": [],
679 "class": "declarado-muerto",
680 "declared_in": sorted(idx[canon])})
681 return out, descartados
682
683
684# ── salida ──────────────────────────────────────────────────────────────────────────────────────
685
686def toml_escape(s):
687 return '"' + str(s).replace("\\", "\\\\").replace('"', '\\"') + '"'
688
689
690def emitir_toml(c):
691 L = []
692 L.append("# censo de mudanza — generado por scripts/mudanza/censar.py. NO editar a mano salvo")
693 L.append("# para DECIDIR: la etapa siguiente lee `decision` de cada entrada.")
694 L.append(f"schema = \"takana-censo/1\"")
695 L.append(f"fecha = {toml_escape(c['fecha'])}")
696 L.append("")
697 L.append("[maquina]")
698 for k, v in c["identidad"].items():
699 L.append(f"{k} = {toml_escape(v) if isinstance(v, str) else json.dumps(v)}")
700 L.append("")
701 for m in c["montajes"]:
702 L.append("[[montaje]]")
703 for k, v in m.items():
704 L.append(f"{k} = {toml_escape(v)}")
705 L.append("")
706 for s in c["servicios"]:
707 L.append("[[servicio]]")
708 L.append(f"name = {toml_escape(s['name'])}")
709 L.append(f"class = {toml_escape(s['class'])}")
710 L.append(f"declared_in = {json.dumps(s['declared_in'])}")
711 L.append(f"pids = {json.dumps(s['pids'])}")
712 # ⚠ Por PID, no por nombre. Emparejar `proc.startswith(name[:15])` le daba el puerto 7378
713 # —que escucha `shuma-gateway`, comprobado con `ss -lntp`— al `shuma` DECLARADO-MUERTO, que
714 # por definición no puede estar escuchando nada. El puerto es la señal más fuerte de que algo
715 # sirve, así que colgárselo al servicio equivocado envenena todo lo que se derive de él.
716 _pids = set(s.get("pids") or [])
717 _mios = [p["port"] for p in c["puertos"] if p.get("pid") and p["pid"] in _pids]
718 if not _mios and _pids:
719 # Sin pid en la salida de `ss` (sin permisos, o `netstat` viejo) se cae al nombre, pero
720 # sólo para servicios VIVOS: un declarado-muerto nunca escucha.
721 _mios = [p["port"] for p in c["puertos"]
722 if not p.get("pid") and p["proc"].startswith(s["name"][:15])]
723 elif not _pids:
724 _mios = []
725 L.append(f"ports = {json.dumps(sorted(set(_mios)))}")
726 L.append(f"cmdline = {toml_escape(s.get('cmdline',''))}")
727 L.append(f"cwd = {toml_escape(s.get('cwd',''))}")
728 L.append(f"exec = {toml_escape(s.get('exec',''))}")
729 if s.get('usuario'):
730 L.append(f"usuario = {toml_escape(s['usuario'])}")
731 if s.get('exec_borrado'):
732 L.append("exec_borrado = true")
733 L.append(f"pid_vivo = {int(s.get('pid_vivo') or 0)}")
734 L.append(f"bytes_vivo = {toml_escape(s.get('bytes_vivo',''))}")
735 L.append(f"bytes_disco = {toml_escape(s.get('bytes_disco',''))}")
736 if s.get('exec_motivo'):
737 L.append(f"exec_motivo = {toml_escape(s['exec_motivo'])}")
738 L.append(f"paquete = {toml_escape(s.get('paquete',''))}")
739 L.append('decision = "" # muda | muere | (vacío = sin decidir)')
740 L.append("")
741 for x in c.get("repos", []):
742 L.append("[[repo]]")
743 for k, v in x.items():
744 L.append(f"{k} = {toml_escape(v)}")
745 L.append("")
746 for x in c.get("sitios", []):
747 L.append("[[sitio]]")
748 for k, v in x.items():
749 L.append(f"{k} = {toml_escape(v)}")
750 L.append("")
751 for x in c.get("contenido", []):
752 L.append("[[contenido]]")
753 for k, v in x.items():
754 L.append(f"{k} = {toml_escape(v)}")
755 L.append("")
756 for d in c["dominios"]:
757 L.append("[[dominio]]")
758 for k, v in d.items():
759 L.append(f"{k} = {toml_escape(v)}")
760 L.append('decision = "" # muda | muere | (vacío = sin decidir)')
761 L.append("")
762 for d in c["datos"]:
763 L.append("[[datos]]")
764 for k, v in d.items():
765 L.append(f"{k} = {toml_escape(v)}")
766 # ⚠ `destino` existe porque la ruta de origen NO tiene por qué caber en la misma ruta del
767 # destino. Medido contra la caja takana: `/` tiene 3,5 G libres y los datos de gioser son
768 # 33,6 G — el sitio está en `/work` (66 G) y en `/store` (19 G). Sin este campo el plan
769 # copiaba ruta→misma ruta y la mudanza no entraba, con el detalle de que el fallo aparece a
770 # mitad de un rsync de 22 G.
771 L.append('destino = "" # vacío = la MISMA ruta en el destino. Ej: "/work/home"')
772 L.append('decision = "" # muda | muere | (vacío = sin decidir)')
773 L.append("")
774 for f in c["fuera_de_git"]:
775 L.append("[[fuera_de_git]]")
776 L.append(f"path = {toml_escape(f['path'])}")
777 L.append(f"entries = {json.dumps(f['entries'])}")
778 L.append("")
779 return "\n".join(L) + "\n"
780
781
782def resumen(c):
783 i = c["identidad"]
784 print(f"\n══ CENSO de {i['hostname']} ({', '.join(i['ips']) or '?'}) ══")
785 print(f" kernel {i['kernel']} · PID 1: {i['pid1']}")
786 por_clase = {}
787 for s in c["servicios"]:
788 por_clase.setdefault(s["class"], []).append(s["name"])
789 print("\n── servicios ──")
790 for cl in ("vivo", "no-declarado", "declarado-muerto"):
791 n = por_clase.get(cl, [])
792 marca = "⚠ " if cl == "no-declarado" else " "
793 print(f"{marca}{cl:18} {len(n):3} {' '.join(sorted(n)[:8])}{' …' if len(n) > 8 else ''}")
794 if c.get("huerfanos"):
795 print(f" descartados (no son servicios: herramientas sueltas o HUÉRFANOS con ppid==1): "
796 f"{len(c['huerfanos'])} {' '.join(sorted(c['huerfanos'])[:8])}")
797 if por_clase.get("no-declarado"):
798 print(" ⚠ `no-declarado` = corre y NADIE sabe cómo levantarlo. Es el trabajo de la mudanza.")
799 if c["dominios"]:
800 print("\n── dominios ──")
801 pd = {}
802 for d in c["dominios"]:
803 pd.setdefault(d["class"], []).append(d["domain"])
804 for cl in ("vivo", "apunta-aca", "ya-mudado", "backend-caido", "fosil-sin-dns", "sin-sondear"):
805 n = pd.get(cl, [])
806 if n:
807 print(f" {cl:16} {len(n):3} {' '.join(sorted(n)[:6])}{' …' if len(n) > 6 else ''}")
808 if c["datos"]:
809 print("\n── datos ──")
810 for d in c["datos"]:
811 extra = f" (copiar sin -H: {d['size_copy']})" if d["size_copy"] != d["size"] else ""
812 print(f" {d['path']:28} {d['size']:>7}{extra}")
813 print()
814
815
816def main():
817 ap = argparse.ArgumentParser(description="Censo de una máquina para mudarla. Sólo lee.")
818 ap.add_argument("--host", help="usuario@host a censar por SSH")
819 ap.add_argument("--key", help="clave SSH")
820 ap.add_argument("--local", action="store_true", help="censar esta máquina")
821 ap.add_argument("--out", help="fichero TOML de salida (default: stdout sólo el resumen)")
822 ap.add_argument("--probe", action="store_true",
823 help="sondear los dominios por DNS+HTTP. Por defecto SÓLO con --host: hacerlo "
824 "contra uno mismo puede disparar el fail2ban de la propia máquina")
825 ap.add_argument("--probe-dns", action="store_true",
826 help="sondear SÓLO el DNS (sin HTTP): no toca al origen, así que es seguro "
827 "contra uno mismo. Dice qué dominios son fósiles y cuáles apuntan acá")
828 ap.add_argument("--no-probe", action="store_true", help="no sondear dominios")
829 ap.add_argument("--data-root", action="append", default=[],
830 help="raíz de datos a medir (repetible). Default: las habituales")
831 a = ap.parse_args()
832 if not a.host and not a.local:
833 ap.error("hace falta --host o --local")
834
835 t = Objetivo(a.host, a.key)
836 print(" censando… (no se ESCRIBE nada; las sondas de red sí dejan huella: ver --probe)",
837 file=sys.stderr)
838
839 ident = identidad(t)
840 vivos = procesos_vivos(t)
841 decl = declarados(t)
842 svc, huerfanos = clasificar(vivos, decl)
843 inv = invocaciones(t, vivos)
844 for e in svc:
845 i = inv.get(e['name'], {})
846 e['cmdline'] = i.get('cmdline', '')
847 e['cwd'] = i.get('cwd', '')
848 e['exe_real'] = i.get('exe', '')
849 if i.get('exe_borrado'):
850 e['exec_borrado'] = True
851 e['pid_vivo'] = i.get('pid', 0)
852 e['bytes_vivo'] = i.get('bytes_vivo', '')
853 e['bytes_disco'] = i.get('bytes_disco', '')
854 if i.get('usuario'):
855 e['usuario'] = i['usuario']
856 # `/proc/<pid>/exe` MANDA sobre `argv[0]`: es el binario de verdad y no lo puede reescribir el
857 # proceso. `argv[0]` queda de respaldo para cuando la sonda no tuvo permiso.
858 def _exe_de(e):
859 return e.get('exe_real') or (
860 (e.get('cmdline') or '').split(' ')[0] if (e.get('cmdline') or '').startswith('/') else '')
861 ejes = [x for x in (_exe_de(e) for e in svc) if x]
862 dn = duenos(t, ejes)
863 raiz = os.geteuid() == 0 if a.local else None
864 for e in svc:
865 exe = _exe_de(e)
866 e['exec'] = exe
867 e['paquete'] = dn.get(exe, '')
868 if not exe and e.get('pids'):
869 # Decir POR QUÉ no se sabe. «Averigualo a mano» y «volvé a correr el censo con sudo» son
870 # dos trabajos muy distintos, y confundirlos manda a alguien a investigar un permiso.
871 e['exec_motivo'] = ("el censo no corrió como root: `/proc/<pid>/exe` de un proceso de "
872 "otro usuario no se puede leer. Repetilo con sudo"
873 if raiz is False else
874 "el proceso reescribió su argv[0] y no se pudo leer /proc/<pid>/exe")
875 pts = puertos(t)
876 nombres = dominios(t)
877 cont = contenido_web(t)
878 sitios = sitios_web(t)
879 sondear = (a.probe or a.probe_dns or bool(a.host)) and not a.no_probe
880 http_ok = not a.probe_dns
881 if nombres and not sondear:
882 print(f" ⚠ {len(nombres)} dominio(s) declarados, SIN sondear: censando en local, y pedirle",
883 file=sys.stderr)
884 print(" a la máquina sus propios dominios puede disparar su fail2ban y dejarla",
885 file=sys.stderr)
886 print(" incomunicada (pasó). Sondealos desde otra máquina, o forzá con --probe.",
887 file=sys.stderr)
888 doms = [{"domain": d, "dns": "", "http": "", "class": "sin-sondear"} for d in nombres]
889 else:
890 doms = []
891 for i, d in enumerate(nombres):
892 if i and http_ok:
893 time.sleep(0.5) # no parecer un escaneo ante el propio fail2ban del objetivo
894 doms.append(sondear_dominio(d, set(ident["ips"]), http_ok))
895 raices = a.data_root or ["/var/www", "/var/lib", "/srv", "/opt", "/home", "/store"]
896 dat = datos(t, raices)
897 # Después de `raices`, que es de dónde salen los repos a mirar. (Estaba antes y `raices` todavía
898 # no existía: habría reventado con NameError en la primera corrida con datos.)
899 repos = repos_git(t, raices + ["/mnt/vvv"], ident.get("ips", []), nombres)
900 censo = {
901 "fecha": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
902 "identidad": ident, "servicios": svc, "huerfanos": huerfanos, "puertos": pts,
903 "dominios": doms, "datos": dat, "contenido": cont, "sitios": sitios, "repos": repos, "montajes": montajes(t),
904 "fuera_de_git": fuera_de_git(t),
905 }
906 resumen(censo)
907 if a.out:
908 with open(a.out, "w") as f:
909 f.write(emitir_toml(censo))
910 print(f" censo → {a.out} (decidí `decision` en cada entrada y pasalo a la etapa 2)")
911
912
913if __name__ == "__main__":
914 main()