sergio/takana

1#!/bin/sh
2# build-farm.sh — Etapa G: GRANJA de build paralela sobre la COLA DE STAGING (recipes/incoming/).
3# El import escala (import-batch ~95% yield, cientos en minutos); el COMPILE es el cuello de botella
4# (1-7 min c/u) pero es embarrassingly-parallel + cacheable por contenido (el store dedup global). Esta
5# es la pieza que convierte "decenas por sesión serial" en "drenar la cola en paralelo": construye N a
6# la vez, y lo que CONSTRUYE+sella lo PROMUEVE incoming/->recipes/ y lo publica al repo firmado; lo que
7# falla queda staged con su motivo (MSRV, dep faltante, …) para revisión.
8#
9# Dos fases: (1) BUILD en paralelo (lo caro, worker pool de $JOBS) — escribe status por paquete; (2)
10# PROMOTE+PUBLISH en SERIE (el index.json del repo es mutable compartido ⇒ no se paraleliza) + firma 1 vez.
11# Idempotente: una receta ya sellada sale por cache-hit; re-correr sólo reintenta lo que falta.
12#
13# Uso:   JOBS=4 scripts/build-farm.sh                 # drena recipes/incoming/*.toml
14#        JOBS=6 QUEUE=recipes/incoming scripts/build-farm.sh
15# Env:   JOBS (def: nproc-2), QUEUE (def recipes/incoming), STORE (def ./store), REPO (def dist/repo),
16#        KEY (clave de firma; def dist/keys/release.ed25519), DISTRO (def dev), HAMMER (cmd del cli),
17#        PROMOTE (def 1; =0 sólo construye+mide, no toca recipes/ ni el repo).
18set -eu
19
20ROOT="$(cd "$(dirname "$0")/.." && pwd)"; cd "$ROOT"
21QUEUE="${QUEUE:-recipes/incoming}"
22STORE="${STORE:-./store}"
23REPO="${REPO:-$ROOT/dist/repo}"
24KEY="${KEY:-$ROOT/dist/keys/release.ed25519}"
25DISTRO="${DISTRO:-dev}"
26HAMMER="${HAMMER:-$ROOT/target/release/hammer}"
27PROMOTE="${PROMOTE:-1}"
28JOBS="${JOBS:-$(( $(nproc) - 2 ))}"; [ "$JOBS" -ge 1 ] || JOBS=1
29
30# Un subdir POR COLA: el worker-loop corre varias colas en serie por ciclo y con un dir compartido
31# la cola siguiente PISA los logs/status de la anterior (imposible diagnosticar fallos de la fase go
32# tras la fase clib). basename de $QUEUE ⇒ work/farm/incoming-go/{log,status}, etc.
33FARM="$ROOT/work/farm/$(basename "$QUEUE")"
34rm -rf "$FARM"; mkdir -p "$FARM/log" "$FARM/status"
35
36queue=$(ls "$QUEUE"/*.toml 2>/dev/null || true)
37[ -n "$queue" ] || { echo "cola vacía: $QUEUE/*.toml"; exit 0; }
38n_total=$(printf '%s\n' "$queue" | wc -l | tr -d ' ')
39echo "==> GRANJA: $n_total recetas en $QUEUE, $JOBS workers en paralelo"
40
41# ── Fase 1: BUILD en paralelo. Cada worker construye una receta y deja su status (.ok con hash | .fail
42# con motivo). El store sella atómico y cada RECETA usa sources/<name>-<sha> + out/<hash>-<name> propios.
43# CAVEAT: dos recetas DISTINTAS que comparten una dep transitiva NO sellada (p.ej. gtk4 bajo libadwaita
44# y gtksourceview) la construyen en el MISMO sources/<dep>-<sha>/output ⇒ chocan (meson/tar). Eso lo
45# concilia la Fase 1b (reintento serial). `xargs -P` es el pool.
46printf '%s\n' "$queue" | xargs -P"$JOBS" -I '{}' sh -c '
47  f="$1"; n=$(basename "$f" .toml); log="'"$FARM"'/log/$n.log"
48  H=$("'"$HAMMER"'" --store "'"$STORE"'" build "$f" 2>"$log" | tail -1 || true)
49  if [ "${H#b3:}" != "$H" ] && [ -n "$H" ]; then
50    echo "$H" > "'"$FARM"'/status/$n.ok"; printf "  ✓ %-18s %s\n" "$n" "$H"
51  else
52    r=$(grep -oiE "requires rustc [0-9.]+|cannot find -l[a-z0-9]+|could not find .[a-z0-9_-]+.|error\[E[0-9]+\]|not found|unsupported|no such file" "$log" | head -1)
53    echo "${r:-fallo (ver log)}" > "'"$FARM"'/status/$n.fail"; printf "  ✗ %-18s %s\n" "$n" "${r:-fallo}"
54  fi
55' _ '{}'
56
57# ── Fase 1b: REINTENTO SERIAL de fallos por COLISIÓN de concurrencia. El pool paralelo puede hacer que
58# dos recetas construyan la MISMA dep transitiva compartida (gtk4/cairo/pango bajo varios consumidores)
59# a la vez en sources/<dep>-<sha>/output ⇒ meson/tar chocan ("Some other Meson process is already using
60# this build directory", "Directory not empty", "No such file"). Tras la Fase 1 la dep ya la selló el
61# ganador de la carrera ⇒ reconstruir el fallo EN SERIE ahora cache-hitea la dep y compila sin colisión.
62# Un solo pase basta: cada `hammer build` arrastra sus deps, así que aunque el orden no sea topológico,
63# la dep se construye/sella dentro del propio reintento. Sólo se reintenta lo que tiene FIRMA de colisión
64# (no MSRV/dep-faltante reales, que re-fallarían y sólo gastarían tiempo).
65for s in "$FARM"/status/*.fail; do
66  [ -f "$s" ] || continue
67  n=$(basename "$s" .fail); log="$FARM/log/$n.log"; f="$QUEUE/$n.toml"
68  [ -f "$f" ] || continue
69  grep -qiE "Some other Meson process|already using this build directory|Directory not empty|No such file or directory|gdkconfig\.h" "$log" 2>/dev/null || continue
70  H=$("$HAMMER" --store "$STORE" build "$f" 2>"$log" | tail -1 || true)
71  if [ "${H#b3:}" != "$H" ] && [ -n "$H" ]; then
72    rm -f "$s"; echo "$H" > "$FARM/status/$n.ok"; printf "  ✓ (reintento serial) %-18s %s\n" "$n" "$H"
73  fi
74done
75
76# ── Fase 2: PROMOTE + PUBLISH en serie (índice del repo = recurso mutable compartido).
77ok=$(ls "$FARM"/status/*.ok 2>/dev/null | wc -l | tr -d ' ')
78fail=$(ls "$FARM"/status/*.fail 2>/dev/null | wc -l | tr -d ' ')
79echo "==> BUILD-YIELD: $ok/$n_total construyen ($fail fallan)"
80
81if [ "$PROMOTE" = 1 ] && [ "$ok" -gt 0 ]; then
82  echo "==> promoviendo + publicando $ok al repo firmado…"
83  for s in "$FARM"/status/*.ok; do
84    n=$(basename "$s" .ok)
85    # GUARDA DE COLISIÓN: si ya existe una receta canónica en recipes/ y la cola trae
86    # OTRA variante con el mismo nombre, NO la promovemos (mv sobrescribiría lo canónico:
87    # p.ej. un `curl` mínimo-para-appstream pisando el curl 8.20 full de la que dependen tools).
88    # Queda staged en la cola para triage manual; tampoco re-publicamos sobre lo canónico.
89    if [ -f "$QUEUE/$n.toml" ] && [ -f "recipes/$n.toml" ]; then
90      printf "  = %s (ya existe recipes/%s.toml canónica — NO promovido, queda en %s)\n" "$n" "$n" "$QUEUE"
91      continue
92    fi
93    if [ -f "$QUEUE/$n.toml" ]; then
94      # mover la receta Y sus patches referenciados (viven junto al .toml en la cola);
95      # si no, `pack` no los encuentra en recipes/ y falla toda receta parcheada.
96      for p in $(grep -oE '"[^"]+\.patch"' "$QUEUE/$n.toml" | tr -d '"'); do
97        [ -f "$QUEUE/$p" ] && mv -f "$QUEUE/$p" recipes/
98      done
99      mv "$QUEUE/$n.toml" recipes/
100    fi
101    "$HAMMER" --store "$STORE" pack "recipes/$n.toml" --repo "$REPO" --distro-version "$DISTRO" --build >/dev/null 2>&1 \
102      && printf "  + %s\n" "$n" || printf "  ! %s (pack falló)\n" "$n"
103  done
104  "$HAMMER" repo sign --repo "$REPO" --key "$KEY" >/dev/null 2>&1 && echo "==> release re-firmado"
105fi
106
107# ── Reporte de fallos (motivo por paquete) para triage.
108if [ "$fail" -gt 0 ]; then
109  echo "==> FALLARON ($fail) — quedan staged en $QUEUE:"
110  for s in "$FARM"/status/*.fail; do printf "  ✗ %-18s %s\n" "$(basename "$s" .fail)" "$(cat "$s")"; done
111fi
112echo "==> granja: $ok promovidos, $fail staged. logs en $FARM/log/"