#!/usr/bin/env python3 """Censo MEDIDO de quién provee cada applet de busybox, contra los artefactos del store. Por qué existe. `docs/state/busybox-applets.tsv` asignaba un `destino` (el paquete que debería reemplazar cada applet) por JUICIO — el propio `docs/plan-botar-busybox.md` lo dice: «el reparto applet→destino es juicio, no medida». Al medirlo contra los artefactos sellados resultó que **31 applets los provee otro paquete** y **79 no los provee NADIE salvo busybox**, entre ellos seis —`xz unxz xzcat lzma unlzma lzcat`— cuyo dueño figura en seis perfiles con el `usr/bin` VACÍO. Cómo mide. Índice inverso de `/-/{bin,sbin,usr/bin,usr/sbin,libexec}`: un paquete «provee» un applet si instala un fichero o enlace con ESE nombre. Es equivalencia de NOMBRE, no de banderas — un `nc` de socat cuenta como proveedor aunque su sintaxis difiera, y por eso la columna `equivalencia` del TSV sigue haciendo falta. ⚠ Los rootfs ENSAMBLADOS (`product-rootfs`, `stage1-rootfs`) se excluyen: traen adentro el propio busybox con sus 277 symlinks, así que contarlos haría que todo applet se «proveyera» a sí mismo. El criterio no es el nombre sino el contenido — un artefacto con `bin/busybox` adentro que no SEA busybox es un rootfs. Uso: scripts/busybox-censo-proveedores.py [--store /store] [--escribir] [--guardian] [--auditar-destinos] --escribir reescribe el TSV (columnas `proveedor_medido` y `medido_el`, y con `--auditar-destinos` también `destino` y `estado_del_dueño`). --guardian sale ≠0 si algún applet PERDIÓ el proveedor que el TSV registra (CI). --auditar-destinos el `destino` y el `estado_del_dueño` DEJAN DE SER JUICIO. ⚠ **Por qué hace falta `--auditar-destinos` (2026-09-22).** Las dos columnas envejecen solas: el TSV seguía diciendo `psmisc-TRAER` y `bc-TRAER` con las dos recetas ya selladas y en los 7 perfiles (commit 4357b29c), y `awk-DECISION` con `akllay` —el awk propio, en Rust— sellado, en los 7 perfiles y publicando `/usr/bin/awk`. O sea: el censo pedía trabajo YA HECHO, que es la forma más cara de equivocarse porque nadie la nota. La regla es mecánica y no opina: **si un paquete que VIAJA EN LA IMAGEN provee el applet, ése es el destino.** Es [[la-etiqueta-no-es-el-hecho]] aplicado a una columna. ⚠ El guardián no vigila un NÚMERO, vigila las PÉRDIDAS, y la diferencia importa: un umbral del tipo «no más de 79 sin dueño» hay que subirlo cada vez que se retira un applet del defconfig, y a la tercera vez nadie lo sube con criterio. Lo que sí es siempre una regresión es que un applet que tenía proveedor medido deje de tenerlo — un `--disable-` nuevo en un `configure`, un `make install` que cambia de objetivo, una receta de herramientas convertida en receta de librería. Los applets que GANAN proveedor se reportan y no fallan: eso es avance, y el TSV se actualiza con `--escribir`. """ import argparse, csv, json, os, sys, collections, datetime sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) RAIZ = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) TSV = os.path.join(RAIZ, "docs/state/busybox-applets.tsv") ESTADO = os.path.join(RAIZ, "docs/state/build-state.json") SUBDIRS = ("bin", "sbin", "usr/bin", "usr/sbin", "usr/libexec", "libexec") def indice(store): """nombre de binario -> {paquetes que lo instalan}, excluidos los rootfs ensamblados.""" prov = collections.defaultdict(set) compuestos = [] for ent in os.scandir(store): if not ent.is_dir(): continue art = ent.name.split("-", 1)[1] if "-" in ent.name else ent.name if art != "busybox" and os.path.exists(os.path.join(ent.path, "bin/busybox")): compuestos.append(art) continue for sub in SUBDIRS: try: for f in os.scandir(os.path.join(ent.path, sub)): prov[f.name].add(art) except OSError: pass return prov, sorted(compuestos) def main(): ap = argparse.ArgumentParser() ap.add_argument("--store", default="/store") ap.add_argument("--escribir", action="store_true") ap.add_argument("--guardian", action="store_true") ap.add_argument("--auditar-destinos", action="store_true") a = ap.parse_args() prov, compuestos = indice(a.store) print(f"índice: {len(prov)} nombres · rootfs excluidos: {', '.join(compuestos) or '(ninguno)'}") filas = list(csv.DictReader(open(TSV, encoding="utf-8"), delimiter="\t")) vivos = [r for r in filas if r["recorte"] != "RETIRADO"] coincide, otro, solo = [], [], [] for r in vivos: p = sorted(x for x in prov.get(r["applet"], ()) if x != "busybox") r["_medido"] = ",".join(p) if p else "SOLO-BUSYBOX" (coincide if r["destino"] in p else (otro if p else solo)).append(r) print(f"\n el dueño del TSV lo provee : {len(coincide):>3}") print(f" lo provee OTRO paquete : {len(otro):>3}") print(f" SÓLO lo provee busybox : {len(solo):>3} ← el trabajo que queda") est = json.load(open(ESTADO, encoding="utf-8"))["nodes"] print("\n--- SÓLO BUSYBOX, por dueño declarado ---") pord = collections.defaultdict(list) for r in solo: pord[r["destino"]].append(r["applet"]) for d, aa in sorted(pord.items(), key=lambda x: -len(x[1])): n = est.get(d) pf = ("en " + ",".join(n["perfiles"])) if n and n["perfiles"] else ("sellado sin perfil" if n else "sin receta") print(f" {d:16} {len(aa):>2} [{pf}] {' '.join(sorted(aa))}") print("\n--- lo provee OTRO paquete (el `destino` del TSV está mal) ---") for r in sorted(otro, key=lambda r: r["applet"]): print(f" {r['applet']:14} TSV={r['destino']:16} REAL={r['_medido']}") if a.guardian: perdidos, ganados = [], [] for r in vivos: antes = (r.get("proveedor_medido") or "").strip() if not antes: continue # fila sin medición previa: nada que comparar ahora = r["_medido"] if antes != "SOLO-BUSYBOX" and ahora == "SOLO-BUSYBOX": perdidos.append((r["applet"], antes)) elif antes == "SOLO-BUSYBOX" and ahora != "SOLO-BUSYBOX": ganados.append((r["applet"], ahora)) if ganados: print(f"\n✓ {len(ganados)} applets GANARON proveedor (no es fallo; correr --escribir):") for x, q in sorted(ganados): print(f" {x:14} ahora lo provee {q}") if perdidos: print(f"\n✗ REGRESIÓN: {len(perdidos)} applets PERDIERON su proveedor y vuelven a depender de busybox:") for x, q in sorted(perdidos): print(f" {x:14} lo proveía {q}") return 1 print("\n✓ guardián: ningún applet perdió su proveedor.") return 0 if a.auditar_destinos: import yupana memb = yupana.membresia_imagen() en_imagen = {n for (q, n), ps in memb.items() if q != "wanted" and ps} cambios = [] for r in filas: # 1) `destino`: si un paquete que VIAJA provee el applet, es ése. Sin juicio. provs = sorted(x for x in prov.get(r["applet"], ()) if x != "busybox") viajan = [x for x in provs if x in en_imagen] # ⚠ `BORRAR` NO se reescribe. Es una DECISIÓN («este applet no se reemplaza, sale del # defconfig») y ninguna medición la contradice: que `cups` traiga un `lpr` no significa # que el applet `lpr` de busybox haya que conservarlo. Medir es para las filas que # declaran trabajo pendiente, no para deshacer lo decidido. if viajan and r["destino"] not in viajan and r["destino"] != "BORRAR": cambios.append((r["applet"], "destino", r["destino"], viajan[0])) r["destino"] = viajan[0] # 2) `estado_del_dueño`: del grafo, no de la memoria de quien escribió la fila. d = r["destino"] if d in ("BORRAR", "—", "") or d.endswith(("-TRAER", "-ESCRIBIR", "-DECISION")): nuevo = "—" if d in ("BORRAR", "—", "") else "sin receta" elif d in en_imagen: nuevo = "sellada y EN IMAGEN" elif est.get(d): nuevo = "sellada SIN perfil" if est[d].get("state") == "sealed" else est[d].get("state", "?") else: nuevo = "sin receta" if (r.get("estado_del_dueño") or "") != nuevo: cambios.append((r["applet"], "estado_del_dueño", r.get("estado_del_dueño"), nuevo)) r["estado_del_dueño"] = nuevo # Los `destino` se imprimen TODOS y los `estado` se resumen: son dos cosas distintas y # mezclarlas esconde la que importa. Un `destino` que cambia es trabajo que se creía # pendiente y ya estaba hecho (o al revés); un `estado` que cambia es sólo el grafo al día. d_cambios = [c for c in cambios if c[1] == "destino"] e_cambios = [c for c in cambios if c[1] != "destino"] print(f"\n--- auditoría: {len(cambios)} celda(s) que el TSV tenía mal ---") print(f" `destino` (trabajo mal contado): {len(d_cambios)}") for ap_, _c, antes, ahora in d_cambios: print(f" {ap_:14} {antes!r} → {ahora!r}") print(f" `estado_del_dueño` (el grafo al día): {len(e_cambios)}") resumen = collections.Counter((c[2], c[3]) for c in e_cambios) for (antes, ahora), n in resumen.most_common(): print(f" {n:>3} {antes!r} → {ahora!r}") if not a.escribir: print(" (no se escribió nada; añadí --escribir)") if a.escribir: hoy = datetime.date.today().isoformat() campos = [c for c in filas[0] if not c.startswith("_")] + ["proveedor_medido", "medido_el"] for r in filas: r["proveedor_medido"] = r.pop("_medido", "") or ("n/a (retirado)" if r["recorte"] == "RETIRADO" else "") r["medido_el"] = hoy if r["recorte"] != "RETIRADO" else "" with open(TSV, "w", encoding="utf-8", newline="") as fh: w = csv.DictWriter(fh, fieldnames=campos, delimiter="\t", lineterminator="\n") w.writeheader() w.writerows(filas) print(f"\nTSV reescrito: {TSV} (+2 columnas)") return 0 if __name__ == "__main__": sys.exit(main())