takana/scripts/vigia-parches.py

#!/usr/bin/env python3
# vigia-parches.py — ¿los parches de la receta AGARRAN todavía en la fuente que la receta pinea?
#
# ══ EL PUNTO CIEGO QUE ESTE VIGÍA CUBRE ════════════════════════════════════════════════════════
# `hammer build` aplica los parches DESPUÉS de materializar las dependencias. En una receta hoja de
# la plataforma Gecko eso significa que el `patch` que no agarra se descubre detrás de horas de
# compilar OTRA COSA: waterfox estrena su primer build reconstruyendo nodejs (4414 objetivos de V8,
# a `-j2` porque el propio recipe capa por RAM). El parche que falla es el paso 3 de un camino cuyo
# paso 1 cuesta media noche, y el fallo no dice nada que no se supiera antes de empezar.
#
# La receta de waterfox además hace una APUESTA EXPLÍCITA y escrita: la base es Gecko 153.1.0 y los
# once parches de musl son los de Firefox 154, una release por encima. Su propio comentario dice
# «si `patch` falla, falla TEMPRANO, antes de compilar nada». Con el orden real de `hammer build`
# eso no es cierto: falla tarde. Este vigía es lo que lo vuelve cierto.
#
# ══ Y EL SEGUNDO PUNTO CIEGO, QUE ES EL CARO ═══════════════════════════════════════════════════
# `patch` no responde sí/no: responde sí, sí-con-desplazamiento y **sí-con-fuzz**. El fuzz es que
# las líneas de CONTEXTO no coinciden y `patch` decidió igual dónde meter el cambio, adivinando. Con
# `--silent` —que es como lo llama `fetch.rs`— eso sale por exit 0 y NADIE SE ENTERA. Un parche que
# entra con fuzz puede haber editado el sitio correcto (y en waterfox los dos que lo hacen editan el
# sitio correcto: el contexto que no casa son comillas simples vs dobles de un `black`, y un brazo
# `cfg` de más) o puede haber editado otro. La diferencia no la ve el exit code: hay que MIRARLA.
#
# Por eso esto no reporta «✓/✗» sino tres estados, y el del medio es el que existe para no perderse:
#
#     ok        entra limpio, sin fuzz. Con desplazamiento está bien: el desplazamiento sólo dice
#               que el fichero creció por arriba, no que el contexto haya cambiado.
#     FUZZ      entra, pero adivinando. NO es un fallo y no rompe el build — es la señal de que hay
#               que abrir el diff y confirmar a mano que el cambio cayó donde debía.
#     FUZZ✓     entra adivinando, PERO alguien ya abrió el diff y anotó dónde cayó, en
#               `docs/state/fuzz-verificado.tsv`. La entrada está indexada por una huella del parche
#               MÁS el pin de la fuente: si cualquiera de los dos cambia, deja de casar y vuelve a
#               salir como FUZZ. Un fuzz mirado no debería preguntarse en cada corrida —eso vuelve
#               ruido al vigía y así es como se pierde el FALLA del día que aparezca— pero tampoco
#               debe poder silenciarse para siempre.
#     FALLA     no entra. Esto sí es el muro, y es el que queremos ver en dos minutos y no en cuatro
#               horas. El arreglo es rebasar el parche que se queje, no bajar el listón del vigía.
#
# ══ POR QUÉ ES BARATO, QUE ES LO QUE LO HACE USABLE ════════════════════════════════════════════
# No baja el árbol. Saca de los propios parches los ficheros que tocan —21 en el caso de waterfox—
# y para una fuente git hace `--filter=blob:none` + sparse-checkout de ESOS. Un árbol Gecko entero
# se vuelve dos docenas de blobs. Para un tarball no hay atajo equivalente, así que se baja una vez
# y se extrae sólo lo que hace falta; sigue siendo órdenes de magnitud menos que construir.
#
# ══ SE APLICAN ACUMULATIVOS, COMO EN EL BUILD DE VERDAD ════════════════════════════════════════
# `fetch.rs::apply_patches` recorre `source.patches` EN ORDEN sobre el mismo árbol, con
# `patch -p1 --batch --silent`. Probar cada parche por separado contra el árbol virgen da el mismo
# resultado sólo mientras no haya dos que toquen el mismo fichero — y eso es una propiedad de hoy,
# no una garantía. Así que acá se aplican de verdad, uno tras otro, en el mismo árbol y en el mismo
# orden, y se conserva `-p1 --batch`. Lo único que se agrega es `--verbose`, para poder LEER lo que
# `--silent` calla.
#
# Uso:
#   scripts/vigia-parches.py recipes/waterfox.toml
#   scripts/vigia-parches.py --all            # las ~45 recetas del árbol que declaran parches
#   scripts/vigia-parches.py --all --git-only # sólo fuentes git (baratas); saltea los tarballs
#   scripts/vigia-parches.py recipes/x.toml --keep   # deja el árbol para inspeccionar el diff
#
# Exit: 0 si todos los parches entran. 1 si alguno FALLA. Con `--strict`, también 1 si alguno
# entra con FUZZ — que es lo que se quiere en CI, y no lo que se quiere mirando a mano.

import argparse
import os
import hashlib
import re
import shutil
import subprocess
import sys
import tarfile
import tempfile
import tomllib
import urllib.request
from pathlib import Path

ROOT = Path(__file__).resolve().parent.parent

# `patch` reporta el desplazamiento y el fuzz por hunk, en stdout, sólo con --verbose.
RE_HUNK = re.compile(r"^Hunk #(\d+) (succeeded|FAILED) at (\d+)(.*)$", re.M)
RE_FUZZ = re.compile(r"with fuzz (\d+)")

# ── EL LIBRO DE FUZZ YA MIRADOS ────────────────────────────────────────────────────────────────
# Un FUZZ no se puede resolver automáticamente: hay que abrir el diff y ver si el cambio cayó donde
# debía. Pero una vez mirado, el veredicto NO caduca solo — depende de dos cosas y las dos están
# pineadas: el TEXTO del parche y la FUENTE. Repreguntarlo en cada corrida convierte al vigía en
# ruido y se acaba ignorando (que es como se pierde el FALLA del día que aparezca).
#
# Por eso el libro se indexa por una HUELLA de las dos cosas. Si alguien toca el parche, o sube la
# versión de la receta, la huella cambia, la entrada deja de casar y el vigía vuelve a preguntar.
# Es lo contrario de una lista de excepciones: no hay forma de silenciar algo y que se quede
# silenciado cuando cambió.
LIBRO = Path(__file__).resolve().parent.parent / "docs/state/fuzz-verificado.tsv"


def huella(texto_parche: str, src: dict) -> str:
    """Identidad de un (parche, fuente) pineados. Cambiá cualquiera de los dos y cambia."""
    pin = src.get("sha256") or src.get("commit") or ""
    h = hashlib.sha256()
    h.update(texto_parche.encode())
    h.update(b"\n")
    h.update(pin.encode())
    return h.hexdigest()[:16]


def cargar_libro() -> dict:
    if not LIBRO.exists():
        return {}
    out = {}
    for linea in LIBRO.read_text(encoding="utf8").splitlines():
        if linea.startswith("#") or not linea.strip():
            continue
        campos = linea.split("\t")
        if len(campos) >= 4:
            out[(campos[0], campos[1], campos[2])] = campos[3]
    return out
RE_OFFSET = re.compile(r"offset (-?\d+) lines?")


def ficheros_del_parche(texto: str) -> list[str]:
    """Los caminos que el parche toca, tal como los verá `patch -p1`.

    Se leen del CUERPO (`---`/`+++`), nunca del diffstat de la cabecera: un parche recortado a mano
    conserva el diffstat del commit original y entonces la cabecera MIENTE. Pasa hoy mismo —
    `firefox-patches/time64.patch` anuncia tres ficheros y entrega dos (le falta el hunk de
    `wgpu-hal`), y como firefox 154 sella igual, nadie lo había notado.

    Se descarta SIEMPRE el primer componente, se llame como se llame, porque eso es exactamente lo
    que significa el `-p1` con el que `fetch.rs` los aplica. Suponer el prefijo `a/`+`b/` de git es
    un error: `echild-strerror.patch` (gawk) viene de un `diff -upr` a secas y sus caminos empiezan
    en `gawk-5.1.0.orig/` y `gawk-5.1.0/`. Con la suposición de git ese parche daba «can't find file
    to patch» sobre una receta que sella perfecto — o sea, el vigía mintiendo en la dirección cara.
    """
    out = []
    for m in re.finditer(r"^(?:---|\+\+\+) ([^\s\t]+)", texto, re.M):
        p = m.group(1)
        if p == "/dev/null":
            continue
        if "/" in p:
            out.append(p.split("/", 1)[1])
    return sorted(set(out))


def traer_git(repo: str, commit: str, ficheros: list[str], dest: Path) -> None:
    """Sparse-checkout de sólo `ficheros` en `commit`. No trae historia ni blobs de más."""
    run = lambda *a: subprocess.run(a, cwd=dest, check=True,
                                    stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
    run("git", "init", "-q", ".")
    run("git", "remote", "add", "origin", repo)
    run("git", "config", "core.sparseCheckout", "true")
    subprocess.run(["git", "fetch", "-q", "--depth", "1", "--filter=blob:none", "origin", commit],
                   cwd=dest, check=True)
    (dest / ".git" / "info" / "sparse-checkout").write_text(
        "".join(f"/{f}\n" for f in ficheros), encoding="utf8")
    run("git", "checkout", "-q", "FETCH_HEAD")


def traer_tarball(url: str, ficheros: list[str], dest: Path) -> None:
    """Sin atajo posible: se baja el tarball y se extraen sólo los miembros que hacen falta.

    El primer componente del camino se descarta (equivale al `-p1` con el que se aplican después),
    igual que hace hammer al extraer.
    """
    quiero = set(ficheros)
    with tempfile.NamedTemporaryFile(suffix=".tar", delete=True) as tmp:
        with urllib.request.urlopen(url) as r:
            shutil.copyfileobj(r, tmp)
        tmp.flush()
        with tarfile.open(tmp.name, "r:*") as tf:
            for m in tf:
                if not m.isfile():
                    continue
                rel = m.name.split("/", 1)[1] if "/" in m.name else m.name
                if rel not in quiero:
                    continue
                destino = dest / rel
                destino.parent.mkdir(parents=True, exist_ok=True)
                src = tf.extractfile(m)
                if src:
                    destino.write_bytes(src.read())


def probar(receta: Path, keep: bool, git_only: bool, libro: dict) -> tuple[str, list[str]]:
    """Devuelve (estado, líneas del informe) para una receta. Estado ∈ ok|fuzz|falla|saltada."""
    datos = tomllib.loads(receta.read_text(encoding="utf8"))
    src = datos.get("source", {})
    parches = src.get("patches") or []
    nombre = datos.get("name", receta.stem)
    if not parches:
        return "saltada", [f"{nombre}: sin parches"]

    textos = {}
    ficheros: set[str] = set()
    for p in parches:
        ruta = receta.parent / p
        if not ruta.exists():
            return "falla", [f"{nombre}: ✗ el parche declarado no existe en el disco: {p}"]
        t = ruta.read_text(encoding="utf8", errors="replace")
        textos[p] = t
        ficheros.update(ficheros_del_parche(t))

    es_git = "repo" in src
    if not es_git and git_only:
        return "saltada", [f"{nombre}: tarball, salteada por --git-only"]

    tmp = Path(tempfile.mkdtemp(prefix=f"vigia-parches-{nombre}-"))
    try:
        if es_git:
            commit = src.get("commit")
            if not commit or len(commit) < 40:
                # Un tag flotante no es un pin (ADR 0006); tampoco se puede verificar contra él.
                return "falla", [f"{nombre}: ✗ `commit` no es un sha completo: {commit!r}"]
            traer_git(src["repo"], commit, sorted(ficheros), tmp)
        else:
            url = src.get("tarball") or src.get("url")
            if not url:
                return "saltada", [f"{nombre}: [source] sin `repo` ni `tarball`"]
            traer_tarball(url, sorted(ficheros), tmp)

        lineas = [f"{nombre} ({datos.get('version','?')}) — {len(parches)} parches, "
                  f"{len(ficheros)} ficheros tocados"]
        peor = "ok"
        # Acumulativos y en orden, igual que fetch.rs::apply_patches.
        for p in parches:
            r = subprocess.run(["patch", "-p1", "--batch", "--verbose"],
                               cwd=tmp, input=textos[p], text=True,
                               stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
            hunks = RE_HUNK.findall(r.stdout)
            fuzz = [(h[0], RE_FUZZ.search(h[3]).group(1)) for h in hunks if RE_FUZZ.search(h[3])]
            offs = [h[0] for h in hunks if RE_OFFSET.search(h[3])]
            base = os.path.basename(p)
            if r.returncode != 0:
                peor = "falla"
                lineas.append(f"   FALLA  {base}")
                for l in r.stdout.splitlines():
                    if "FAILED" in l or "can't find file" in l or "Reversed" in l:
                        lineas.append(f"          {l.strip()}")
            elif fuzz:
                det = ", ".join(f"hunk #{h} fuzz {f}" for h, f in fuzz)
                hu = huella(textos[p], src)
                visto = libro.get((nombre, base, hu))
                if visto:
                    lineas.append(f"   FUZZ✓  {base}  ({det}) — ya mirado: {visto}")
                else:
                    if peor != "falla":
                        peor = "fuzz"
                    lineas.append(f"   FUZZ   {base}  ({det}) — entra ADIVINANDO, mirá el diff")
                    # La línea lista para pegar en el libro DESPUÉS de mirarlo. Se da acá porque
                    # calcular la huella a mano es justo la fricción que hace que nadie lo anote.
                    lineas.append(f"          libro: {nombre}\t{base}\t{hu}\t<tu veredicto>")
            else:
                extra = f"  ({len(offs)} hunks desplazados)" if offs else ""
                lineas.append(f"   ok     {base}{extra}")
        if keep:
            lineas.append(f"   árbol parcheado en {tmp}")
        return peor, lineas
    finally:
        if not keep:
            shutil.rmtree(tmp, ignore_errors=True)


def main() -> int:
    ap = argparse.ArgumentParser(description="¿los parches de una receta siguen agarrando?")
    ap.add_argument("recipes", nargs="*", type=Path)
    ap.add_argument("--all", action="store_true", help="todas las recetas que declaren parches")
    ap.add_argument("--git-only", action="store_true", help="saltear fuentes tarball (más caras)")
    ap.add_argument("--keep", action="store_true", help="no borrar el árbol parcheado")
    ap.add_argument("--strict", action="store_true", help="salir 1 también si algo entra con fuzz")
    a = ap.parse_args()

    objetivos = list(a.recipes)
    if a.all:
        for f in sorted((ROOT / "recipes").glob("*.toml")):
            if re.search(r"^\s*patches\s*=", f.read_text(encoding="utf8", errors="replace"), re.M):
                objetivos.append(f)
    if not objetivos:
        ap.error("dame una receta o --all")

    peor = "ok"
    libro = cargar_libro()
    orden = {"saltada": 0, "ok": 1, "fuzz": 2, "falla": 3}
    for r in objetivos:
        try:
            estado, lineas = probar(r, a.keep, a.git_only, libro)
        except subprocess.CalledProcessError as e:
            estado, lineas = "falla", [f"{r}: ✗ no pude traer la fuente ({e})"]
        except Exception as e:  # una receta rota no debe tumbar el barrido entero
            estado, lineas = "falla", [f"{r}: ✗ {type(e).__name__}: {e}"]
        print("\n".join(lineas))
        print()
        if orden[estado] > orden[peor]:
            peor = estado

    if peor == "falla":
        return 1
    if peor == "fuzz" and a.strict:
        return 1
    return 0


if __name__ == "__main__":
    sys.exit(main())