sergio/takana

1#!/usr/bin/env python3
2"""¿El navegador le entrega un torrent a la suite, y lo toma un daemon que le sobrevive? (SDD 26 §6.9)
3
4    python3 scripts/test-atuq-torrent.py                     # el daemon lo toma
5    python3 scripts/test-atuq-torrent.py --negative-control   # sin el daemon: lo dice, no lo finge
6
7── QUÉ SE EJERCITA ───────────────────────────────────────────────────────────────────────────
8    página de la extensión → fondo → connectNative → puriy-costura
9      → /usr/bin/puriy-costura-torrent add   (que LEVANTA el daemon si no está)
10      → daemon: alta en la sesión de librqbit
11
12El daemon **no estaba corriendo**: no hay servicio en la imagen. Que aparezca es la mitad de
13«perezoso», y es lo que este guardián comprueba.
14
15── DOS COSAS QUE ESTE GUARDIÁN NO HACE, Y POR QUÉ ────────────────────────────────────────────
161. **No usa un `magnet:` sino un `.torrent` servido por HTTP.** Dar de alta un magnet BLOQUEA
17   esperando la metadata del enjambre —lo dice el propio `foreign-torrent::resolve`— y sin peers eso
18   no llega nunca: el guardián mediría un timeout, no la cadena. Con un `.torrent` la metadata viene
19   en el fichero, el alta termina, y lo único que falta son los peers (que no hacen falta para
20   probar la costura). El `.torrent` se arma acá, en bencode a mano: un binario de prueba metido en
21   el repo es una dependencia que nadie revisa.
222. **No pasa por el despacho de protocolos de Gecko.** Un clic en un `magnet:` abre el diálogo de
23   «¿con qué lo abro?», que en headless no contesta nadie; eso es una elección del usuario, no
24   código nuestro. Se abre directamente la página de la extensión —la misma que el handler abriría—
25   descubriendo su URL base del `dump` de la primera corrida, porque el UUID lo asigna Gecko por
26   perfil y adivinarlo sería inventar.
27
28REQUISITOS: el rootfs de `scripts/atuq-nested.sh`, y `atuq` + `puriy-costura` +
29`puriy-costura-torrent` sellados.
30"""
31import hashlib
32import http.server
33import os
34import shutil
35import signal
36import socket
37import subprocess
38import sys
39import tempfile
40import threading
41import time
42
43ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
44RFS = os.environ.get("RFS", "/mnt/cosecha/escritorios/atuq-rootfs")
45ALPINE = os.path.join(ROOT, ".dev-fs/alpine")
46HAMMER = os.path.join(ROOT, "target/release/takana")
47STORE = os.environ.get("HAMMER_STORE", os.path.join(ROOT, "store"))
48CLIENTE = "/usr/bin/puriy-costura-torrent"
49# Tope del sandbox entero: 60 s los pone `timeout` sobre el navegador, y el resto es
50# arranque + despedida del daemon. Si se pasa, no hay veredicto: hay algo colgado.
51TOPE_SANDBOX = 180
52
53
54def fatal(msg):
55    print(f"✗ {msg}", file=sys.stderr)
56    raise SystemExit(1)
57
58
59def artefacto(receta, nombre, escotilla=None):
60    forzado = os.environ.get(escotilla) if escotilla else None
61    if forzado:
62        if not os.path.isdir(forzado):
63            fatal(f"{escotilla}={forzado} no existe")
64        print(f"⚠ {escotilla}: se mide {os.path.basename(forzado)}, que NO es necesariamente el vigente")
65        return forzado
66    r = subprocess.run([HAMMER, "--store", STORE, "hash", f"recipes/{receta}.toml"],
67                       cwd=ROOT, capture_output=True, text=True)
68    if r.returncode != 0:
69        fatal(f"no pude hashear {receta}: {r.stderr.strip()}")
70    h = r.stdout.strip().splitlines()[-1].removeprefix("b3:")
71    d = os.path.join(STORE, f"{h}-{nombre}")
72    if not os.path.isdir(d):
73        fatal(f"{nombre} b3:{h[:8]} no está sellado — construilo antes")
74    return d
75
76
77def bencode(v):
78    """Bencode, lo justo para un `.torrent` de un solo fichero."""
79    if isinstance(v, int):
80        return b"i" + str(v).encode() + b"e"
81    if isinstance(v, bytes):
82        return str(len(v)).encode() + b":" + v
83    if isinstance(v, list):
84        return b"l" + b"".join(bencode(x) for x in v) + b"e"
85    if isinstance(v, dict):
86        salida = b"d"
87        for k in sorted(v):
88            salida += bencode(k) + bencode(v[k])
89        return salida + b"e"
90    raise TypeError(type(v))
91
92
93CONTENIDO = b"un objeto con identidad, bajado por el enjambre\n" * 16
94PIEZA = 16384
95
96
97def torrent_de_prueba(puerto):
98    info = {
99        b"name": b"prueba-atuq.bin",
100        b"piece length": PIEZA,
101        b"length": len(CONTENIDO),
102        b"pieces": hashlib.sha1(CONTENIDO).digest(),
103    }
104    # El tracker no existe y no hace falta: el alta se completa con la metadata del
105    # propio fichero, que es justo lo que este guardián necesita.
106    return bencode({b"announce": f"http://127.0.0.1:{puerto}/announce".encode(), b"info": info})
107
108
109class Servidor(http.server.SimpleHTTPRequestHandler):
110    puerto = 0
111
112    def log_message(self, *a):
113        pass
114
115    def do_GET(self):
116        if self.path.startswith("/prueba.torrent"):
117            datos, tipo = torrent_de_prueba(Servidor.puerto), "application/x-bittorrent"
118        else:
119            datos, tipo = b"<html><body>ok</body></html>", "text/html"
120        self.send_response(200)
121        self.send_header("Content-Type", tipo)
122        self.send_header("Content-Length", str(len(datos)))
123        self.end_headers()
124        self.wfile.write(datos)
125
126
127def daemons_vivos():
128    """PIDs de daemons de torrent vivos AHORA, vistos desde el hub.
129
130    El daemon corre dentro del sandbox, pero `bwrap` no oculta los procesos al host:
131    `ps -C` los ve con su PID de acá. Es por nombre de proceso a propósito — `pkill -f`
132    empareja la línea de comandos entera y se lleva puesta la shell que corre el test
133    (medido, sale 144 y lo que sigue no corre).
134    """
135    r = subprocess.run(["ps", "-o", "pid=", "-C", "puriy-costura-torrent"],
136                       capture_output=True, text=True, check=False)
137    return {int(l) for l in r.stdout.split()}
138
139
140def puerto_libre():
141    s = socket.socket()
142    s.bind(("127.0.0.1", 0))
143    p = s.getsockname()[1]
144    s.close()
145    return p
146
147
148def correr(atuq, costura, daemon, salida, url, negativo):
149    borrar = f"rm -f {CLIENTE}" if negativo else "true"
150    guion = f"""
151    mkdir -p /root /salida/hogar /salida/run
152    [ -s /etc/machine-id ] || tr -d - < /proc/sys/kernel/random/uuid > /etc/machine-id
153    export HOME=/salida/hogar XDG_RUNTIME_DIR=/salida/run XDG_STATE_HOME=/salida/hogar/.local/state
154    {borrar}
155    timeout 60 /usr/bin/atuq --profile /salida/perfil --no-remote --headless '{url}' \
156        > /salida/consola.log 2>&1
157    # El socket se anota ACÁ ADENTRO, antes de despedir al daemon: al irse lo borra,
158    # así que mirarlo después desde el hub no mediría nada.
159    [ -S /salida/run/puriy-costura-torrent.sock ] && echo si > /salida/socket-visto
160    # Y hay que despedirlo a mano. Medido (2026-09-10): el daemon se va «tras 300s sin
161    # nada», pero un torrent sin enjambre NUNCA termina ⇒ nunca está «sin nada»; y
162    # `bwrap --unshare-pid` no vuelve hasta que su namespace de PIDs queda vacío.
163    # Sin este `stop` el guardián se cuelga PARA SIEMPRE, y de paso deja el sandbox
164    # entero vivo (un `bwrap` huérfano pinneando el overlay borrado).
165    command -v puriy-costura-torrent >/dev/null 2>&1 && puriy-costura-torrent stop >/dev/null 2>&1
166    exit 0
167    """
168    capas = ["--overlay-src", ALPINE, "--overlay-src", RFS, "--overlay-src", atuq,
169             "--overlay-src", costura]
170    if daemon:
171        capas += ["--overlay-src", daemon]
172    proceso = subprocess.Popen([
173        "bwrap", *capas, "--tmp-overlay", "/",
174        "--dev-bind", "/dev", "/dev", "--proc", "/proc", "--bind", "/sys", "/sys",
175        "--tmpfs", "/tmp", "--unshare-pid",
176        "--bind", salida, "/salida",
177        "--uid", "0", "--gid", "0",
178        "--setenv", "PATH", "/usr/bin:/bin:/usr/sbin:/sbin",
179        "--setenv", "XDG_DATA_DIRS", "/usr/share", "--setenv", "MOZ_HEADLESS", "1",
180        "--setenv", "MOZ_DISABLE_CONTENT_SANDBOX", "1",
181        "--setenv", "MOZ_DISABLE_GMP_SANDBOX", "1",
182        "--setenv", "MOZ_DISABLE_RDD_SANDBOX", "1",
183        "--setenv", "MOZ_DISABLE_SOCKET_PROCESS_SANDBOX", "1",
184        "--setenv", "MOZ_DISABLE_UTILITY_SANDBOX", "1",
185        "sh", "-c", guion,
186    ])
187    try:
188        proceso.wait(timeout=TOPE_SANDBOX)
189    except subprocess.TimeoutExpired:
190        # No es un fallo del navegador: es que algo quedó vivo dentro del namespace.
191        proceso.kill()
192        proceso.wait(timeout=30)
193        fatal(f"el sandbox no volvió en {TOPE_SANDBOX}s — quedó algo vivo adentro"
194              " (el sospechoso es el daemon: `bwrap` espera a que el namespace de PIDs"
195              " se vacíe)")
196    log = open(os.path.join(salida, "consola.log"), errors="replace").read()
197    return [l[len("TORRENT "):] for l in log.splitlines() if l.startswith("TORRENT ")], log
198
199
200def main():
201    negativo = "--negative-control" in sys.argv[1:]
202    if negativo:
203        print("== MODO CONTROL NEGATIVO: sin el cliente del daemon; tiene que DECIRLO")
204    if not os.path.isdir(RFS):
205        fatal(f"no está el rootfs en {RFS} — corré antes `scripts/atuq-nested.sh`")
206    atuq = artefacto("atuq", "atuq", "ATUQ_DIR")
207    costura = artefacto("puriy-costura", "puriy-costura")
208    daemon = artefacto("puriy-costura-torrent", "puriy-costura-torrent")
209    print(f"artefactos: {os.path.basename(atuq)}\n            {os.path.basename(costura)}"
210          f"\n            {os.path.basename(daemon)}")
211
212    # Censo previo: puede haber un daemon de otra corrida o de otro agente, y ése no
213    # es nuestro. Lo que se juzga al final es la DIFERENCIA.
214    ajenos = daemons_vivos()
215
216    puerto = puerto_libre()
217    Servidor.puerto = puerto
218    servidor = http.server.ThreadingHTTPServer(("127.0.0.1", puerto), Servidor)
219    threading.Thread(target=servidor.serve_forever, daemon=True).start()
220
221    tmp = tempfile.mkdtemp(prefix="atuq-torrent-")
222    salida = os.path.join(tmp, "salida")
223    os.makedirs(os.path.join(salida, "perfil"))
224    try:
225        with open(os.path.join(salida, "perfil", "user.js"), "w") as fh:
226            fh.write('user_pref("browser.dom.window.dump.enabled", true);\n')
227            fh.write('user_pref("browser.shell.checkDefaultBrowser", false);\n')
228
229        # Corrida 1: sólo para saber la URL base de la extensión (Gecko le asigna un
230        # UUID por perfil; adivinarlo sería inventar).
231        lineas, log = correr(atuq, costura, daemon, salida, "about:blank", negativo)
232        base = None
233        for l in lineas:
234            if l.startswith("BASE "):
235                base = l.split(" ", 1)[1].strip()
236        if not base:
237            destino = os.path.join(ROOT, "work", "atuq-torrent.log")
238            os.makedirs(os.path.dirname(destino), exist_ok=True)
239            open(destino, "w").write(log)
240            fatal(f"la extensión no dijo su URL base — ¿se instaló? log en {destino}")
241        print(f"\nextensión en {base}")
242
243        # Corrida 2: su propia página, con el `.torrent` como origen.
244        origen = f"http://127.0.0.1:{puerto}/prueba.torrent"
245        pagina = f"{base}tomado.html?m={origen}"
246        lineas, log = correr(atuq, costura, daemon, salida, pagina, negativo)
247        for l in lineas:
248            print("   " + l)
249
250        # La página no valida la forma del origen (lo hace el host, que es quien
251        # decide), así que le pasa el `.torrent` al fondo igual que un `magnet:`. Si
252        # no hubiera línea MAGNET, el mensaje no llegó al fondo y esto falla — que es
253        # lo correcto.
254        if not any(l.startswith("MAGNET ") for l in lineas):
255            destino = os.path.join(ROOT, "work", "atuq-torrent.log")
256            os.makedirs(os.path.dirname(destino), exist_ok=True)
257            open(destino, "w").write(log)
258            fatal(f"el fondo de la extensión no recibió el origen — log en {destino}")
259
260        tomado = [l for l in lineas if l.startswith("TOMADO ")]
261        rechazo = [l for l in lineas if l.startswith("RECHAZO ")]
262
263        if negativo:
264            if tomado:
265                fatal(f"sin el cliente del daemon dijo que lo tomó: {tomado}")
266            if not rechazo:
267                fatal("sin el cliente, el host tenía que fallar DICIÉNDOLO")
268            if "no hay cliente de torrent" not in " ".join(rechazo):
269                fatal(f"el motivo no nombra lo que falta: {rechazo}")
270            print("\n✓ control negativo: sin el daemon no se finge nada, y el motivo lo nombra")
271            return 0
272
273        if rechazo:
274            fatal(f"el host rechazó el torrent: {rechazo}")
275        if not tomado:
276            fatal("el daemon no acusó recibo del torrent")
277        if "prueba-atuq.bin" not in tomado[0]:
278            fatal(f"el daemon no leyó la metadata del .torrent: {tomado[0]}"
279                  " — si dice «(sin nombre todavía)», el alta no trajo el nombre")
280
281        # Y la prueba de la PEREZA: el daemon no estaba corriendo, y su socket
282        # apareció porque el cliente lo levantó.
283        # La huella la dejó el propio sandbox antes de despedir al daemon: el socket
284        # se lo lleva al salir, así que buscarlo ahora sería medir el reloj, no el hecho.
285        if not os.path.exists(os.path.join(salida, "socket-visto")):
286            fatal("no hubo socket del daemon: no llegó a levantarse")
287        print("\nsocket del daemon: run/puriy-costura-torrent.sock (visto adentro)")
288        print("\n✓ el navegador le entrega el torrent a la suite y el daemon lo toma")
289        print("✓ y NADIE lo arrancó: no hay servicio en la imagen — lo levantó su cliente")
290
291        # Y que se haya IDO. Esto no es prolijidad: el sandbox se cerró, sus overlays
292        # están borrados, y un daemon vivo los sostiene abiertos indefinidamente —
293        # su torrent de prueba no tiene enjambre, así que nunca termina y nunca está
294        # «sin nada» que hacer. Medido: sin el `stop` de adentro el guardián decía ✓
295        # igual y dejaba el daemon Y su `bwrap` corriendo. Un residuo que nadie mide
296        # se ve igual que no haberlo dejado.
297        for _ in range(15):
298            quedaron = daemons_vivos() - ajenos
299            if not quedaron:
300                break
301            time.sleep(1)
302        if quedaron:
303            fatal(f"quedó un daemon vivo tras cerrar el sandbox: PID(s) {sorted(quedaron)}"
304                  " — se despide con `puriy-costura-torrent stop` DENTRO del sandbox")
305        print("✓ y se fue cuando se lo pidieron: el sandbox no deja daemon suelto")
306        return 0
307    finally:
308        servidor.shutdown()
309        # Barrer SÓLO lo que apareció durante esta corrida, y por PID: un test rojo no
310        # tiene derecho a dejar procesos, ni a matar los de otro agente.
311        for pid in sorted(daemons_vivos() - ajenos):
312            try:
313                os.kill(pid, signal.SIGTERM)
314            except OSError:
315                pass
316        shutil.rmtree(tmp, ignore_errors=True)
317
318
319sys.exit(main())