sergio/takana

1#!/usr/bin/env bash
2# farm-up.sh [N] — levanta N workers EFÍMEROS desde el snapshot golden y los alinea con la cola
3# actual del laptop. Modelo hub-and-spoke: el worker NO tiene secretos (ni firma ni gitea); es
4# compute puro y descartable. La imagen 'takana-golden' trae el toolchain + el store sellado
5# horneados ⇒ el worker arranca con TODO el catálogo cacheado (cache-hit instantáneo), sólo
6# construye lo NUEVO que el hub le empuje.
7#
8# Flujo:  scripts/farm/farm-up.sh 3      # crea hworker-1..3, los alimenta con la cola actual
9#         ... (muelen) ...
10#         scripts/farm/farm-down.sh      # cosecha su store al laptop y los DESTRUYE
11#
12# La flota viva se registra en scripts/farm/.fleet ("<name> <ip>" por línea; gitignored).
13# Idempotente al escalar: re-correr con más N agrega workers sin pisar los vivos.
14#
15# Env: IMAGE (snapshot, def 417847948=takana-golden-rust-go-2026-08-08), TYPE (def ccx23),
16#      LOCATION
17#      (def hel1), SSHKEY (llave del proyecto Hetzner, def desarrollo@jlsoltech.com), SSH_KEY
18#      (privada local p/ SSH, def ~/.ssh/github5), REMOTE (def /opt/hammer).
19set -euo pipefail
20
21N="${1:-1}"
22# ── GOLDEN 417847948 (2026-08-08): la anterior NO TENÍA RUST NI GO ─────────────────────────────
23# `takana` invoca `cargo vendor` (y el toolchain Go) en el HOST, no dentro del sandbox: el vendoreo
24# pasa ANTES de entrar a la caja. La golden vieja (408909310) no los traía, así que la granja no
25# podía construir NINGUNA receta Rust ni Go — o sea COSMIC entero, las 228 Rust y las 362 Go del
26# corpus: **el 76% del catálogo sólo se podía construir en el hub**, una sola máquina.
27#
28# Esta imagen añade cargo/rustc 1.96.0 y go 1.26.4, **las mismas versiones que el hub**, para no
29# introducir un skew de toolchain nuevo mientras se arregla otro. Verificado antes de snapshotear:
30# `cosmic-bg` —que minutos antes moría con `spawn cargo vendor: No such file`— sella en el worker.
31#
32# NO relaja la hermeticidad: cargo/go son herramientas de FETCH, del mismo orden que `git` para
33# clonar. El build sigue ocurriendo dentro del sandbox con el árbol ya vendoreado. Es lo contrario
34# del caso «no engordar el rootfs del worker», que habla del rootfs DEL SANDBOX.
35#
36# Trae además el store del worker al momento del snapshot (KDE y GNOME reconstruidos el 2026-08-08),
37# así que los workers nuevos arrancan con más caché que antes.
38IMAGE="${IMAGE:-417847948}"
39TYPE="${TYPE:-ccx23}"
40LOCATION="${LOCATION:-hel1}"
41SSHKEY="${SSHKEY:-desarrollo@jlsoltech.com}"
42SSH_KEY="${SSH_KEY:-$HOME/.ssh/github5}"
43REMOTE="${REMOTE:-/opt/hammer}"
44# MISMO volumen que harkaq-vol.sh, a propósito: eran DOS caminos de crear workers y sólo uno tenía
45# volumen+automuerte. hworker-4 nació por ÉSTE (farm-up) y por eso quedó 5 días idle con 37G que
46# nadie salvó — la protección existía y este camino la esquivaba. Compartir el volumen hace que
47# `harkaq-vol.sh collect` y `close` cosechen y clausuren lo de AMBOS caminos.
48VOL_NAME="${VOL_NAME:-harkaq-cosecha}"
49VOL_SIZE="${VOL_SIZE:-100}"                  # GB. ~€0.044/GB/mes ⇒ 100G ≈ €4.4/mes MIENTRAS exista.
50                                             # El baseline €0 lo da `harkaq-vol.sh close`, que es
51                                             # tuyo: el volumen es el único que sobrevive a propósito.
52ROOT="$(cd "$(dirname "$0")/../.." && pwd)"
53FLEET="$ROOT/scripts/farm/.fleet"
54# Workers efímeros RECICLAN IPs de Hetzner ⇒ un known_hosts persistente choca ("HOST KEY CHANGED")
55# y accept-new RECHAZA la clave cambiada, colgando el `until ssh true` para siempre. Como el modelo
56# es hub-and-spoke (el worker NO tiene secretos: compute puro descartable), saltamos la verificación
57# de host y no ensuciamos known_hosts (/dev/null). No hay superficie MITM que proteger acá.
58SSH="ssh -i $SSH_KEY -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -o LogLevel=ERROR -o ConnectTimeout=10"
59cd "$ROOT"
60touch "$FLEET"
61
62# ── GUARDIÁN DEL VOLUMEN (2026-08-23) ─────────────────────────────────────────────────────────
63# El chequeo de más abajo YA detectaba este fallo — y sólo imprimía un ⚠ mientras el script seguía
64# adelante: armaba el dead-man y sembraba la cola igual. La noche del 2026-08-22 eso costó 21 G y
65# 397 artefactos sellados. hworker-2 nació sin volumen (lo tenía hworker-1: un volumen de Hetzner se
66# adjunta a UN server), construyó el shard 1/2 entero en su disco raíz y el dead-man se lo llevó a
67# las 03:27Z. El aviso salió impreso, con estas mismas palabras, y no lo leyó nadie: el hub estaba
68# esperando una respuesta humana que llegó después del borrado.
69#
70# La lección no es "avisar mejor": es que un aviso que no detiene el pipeline no es un guardián
71# cuando nadie mira. Sembrar trabajo en un disco efímero es peor que no crear el worker, porque
72# gasta horas de CPU y las tira. Ahora CORTA.
73sin_volumen() {
74  local name="$1" motivo="$2"
75  echo "   ✗ $name: $motivo" >&2
76  echo "     Sin volumen, lo que selle vive en disco EFÍMERO y el dead-man se lo lleva entero." >&2
77  echo "     NO lo siembro. Salidas:" >&2
78  echo "       · un volumen POR worker:   VOL_NAME=harkaq-cosecha-$name scripts/farm/farm-up.sh 1" >&2
79  echo "       · cosechar y clausurar el actual:  scripts/farm/harkaq-vol.sh collect  (luego close)" >&2
80  echo "       · worker deliberadamente desechable:  SIN_VOLUMEN_OK=1 scripts/farm/farm-up.sh …" >&2
81  if [ "${SIN_VOLUMEN_OK:-0}" = "1" ]; then
82    echo "     SIN_VOLUMEN_OK=1 ⇒ sigo igual: este worker construye a disco efímero." >&2
83    return 0
84  fi
85  # El server acaba de nacer y todavía no tiene nada dentro. Dejarlo vivo sería un idle facturando
86  # (es el caso hworker-4, 5 días), así que se borra — con el MISMO blindaje que el dead-man y
87  # farm-down: sólo si lleva el label role=takana-worker. gioser no lo lleva ⇒ jamás cae por acá.
88  if hcloud server describe "$name" -o format='{{.Labels}}' 2>/dev/null | grep -q hammer-worker; then
89    if hcloud server delete "$name" >/dev/null 2>&1; then
90      echo "     $name borrado (recién creado, vacío): sin factura colgando." >&2
91      sed -i "/^$name /d" "$FLEET" 2>/dev/null || true
92    fi
93  fi
94  exit 1
95}
96
97# índice de arranque: el mayor hworker-N vivo + 1 (para escalar sin colisión de nombres)
98base=$(sed -n 's/^hworker-\([0-9]*\) .*/\1/p' "$FLEET" | sort -n | tail -1)
99base="${base:-0}"
100
101for k in $(seq 1 "$N"); do
102  i=$((base + k)); name="hworker-$i"
103  echo "==> creando $name ($TYPE @ $LOCATION desde image $IMAGE)"
104  hcloud server create --name "$name" --image "$IMAGE" --type "$TYPE" \
105    --location "$LOCATION" --ssh-key "$SSHKEY" --label role=hammer-worker >/dev/null
106  ip=$(hcloud server ip "$name")
107  echo "$name $ip" >> "$FLEET"
108  echo "   ip=$ip; esperando SSH…"
109  until $SSH root@"$ip" true 2>/dev/null; do sleep 3; done
110
111  echo "   alineando cola con el laptop (rsync código + recipes)…"
112  # ── EL MANIFIESTO VIAJA ACÁ TAMBIÉN, Y ESTE ERA EL AGUJERO ────────────────────────────────────
113  # `farm-sync.sh` ya mandaba `work/farm-sellados.txt` para que el worker no rehiciera lo que el hub
114  # tiene. Este fichero NO, así que un worker recién creado arrancaba con el manifiesto RANCIO que
115  # venía horneado en la golden. Medido el 2026-08-09: worker 1172 vs hub 1241 ⇒ el worker construía
116  # `vulkan-loader` en TODOS los ciclos aunque el hub ya lo tenía sellado, y encima fallaba.
117  #
118  # Es literalmente el error de método que este repo ya se documentó a sí mismo en `farm-sync.sh`:
119  # «lo puse allí, di el bucle por cerrado, y la churn siguió porque hay DOS rutas». Había dos rutas
120  # otra vez —`farm-sync` y `farm-up`— y sólo una estaba arreglada. Si aparece una tercera, va con
121  # el mismo include.
122  # ⚠ `--exclude /work` NO excluía el contenido, sólo la entrada. Con `--include '/work/'` delante,
123  # rsync entraba al directorio y sus hijos no casaban con ninguna regla ⇒ **se copiaba `work/`
124  # entero**. Medido el 2026-08-11 montando el primer worker con el lab anclado: llegaron 3,7 G de
125  # `work/`, incluidos los mirrors de git A MEDIO COPIAR (el rsync abortó antes de terminarlos), y
126  # el worker fallaba cada receta con `git fetch … exit 128`. Encima, con `--delete`, moría con
127  # «cannot delete non-empty directory» sobre los `vendor/` de cargo, que quedan de SÓLO LECTURA.
128  # `/work/**` sí ancla el contenido. Un `work/` a medias es peor que ninguno: parece que está.
129  set +e
130  rsync -az --delete -e "$SSH" \
131    --include '/work/' --include '/work/farm-sellados.txt' --exclude '/work/**' \
132    --exclude /store --exclude '/store-*' --exclude /target \
133    --exclude /dist --exclude /.dev-fs --exclude /.git --exclude /.scratch \
134    --exclude '*.png' --exclude '/content*' \
135    ./ "root@$ip:$REMOTE/"
136  rc=$?
137  set -e
138  # NO abortamos si el rsync falla. Lo que viene después es el ARMADO DEL DEAD-MAN, y un `set -e`
139  # aquí dejaba un server VIVO SIN poder autodestruirse — que es justo lo que este script declara
140  # inadmisible. El orden ideal sería armar el dead-man ANTES de cualquier paso que pueda fallar;
141  # mientras eso no se reordene, esto garantiza al menos que se llegue a armarlo.
142  [ "$rc" -ne 0 ] && echo "   ⚠ rsync de código salió $rc — el worker puede tener la cola incompleta; sigo para ARMAR EL DEAD-MAN"
143  # el servicio ya arrancó en el boot (baked/enabled); reiniciar fuerza rescan inmediato de la cola
144  $SSH root@"$ip" 'systemctl restart hammer-farm' 2>/dev/null || true
145
146  # VOLUMEN PERSISTENTE + STORE DENTRO. Sin esto la automuerte perdería lo construido: hworker-4
147  # tenía 438 artefactos (37G) SÓLO en su disco local. El store vive en /mnt/cosecha/store ⇒ cada
148  # artefacto está en el volumen persistente EN EL INSTANTE en que se sella. "Guardar lo generado"
149  # deja de ser un paso que puede fallar antes de morir y pasa a ser la estructura. El volumen
150  # sobrevive al server; se cosecha con harkaq-vol.sh collect y se clausura con close.
151  echo "   montando volumen persistente $VOL_NAME y anclando el store dentro…"
152  vid=$(hcloud volume list -o noheader -o columns=id,name 2>/dev/null | awk -v v="$VOL_NAME" '$2==v{print $1}')
153  if [ -z "$vid" ]; then
154    hcloud volume create --name "$VOL_NAME" --size "$VOL_SIZE" --location "$LOCATION" --format ext4 >/dev/null 2>&1 || true
155    vid=$(hcloud volume list -o noheader -o columns=id,name 2>/dev/null | awk -v v="$VOL_NAME" '$2==v{print $1}')
156  fi
157  if [ -n "$vid" ]; then
158    # UN VOLUMEN SE ADJUNTA A UN SERVER, y este script crea N workers en un bucle apuntando todos al
159    # MISMO VOL_NAME ⇒ del segundo en adelante el attach no tiene nada que adjuntar. Antes ese fallo
160    # se perdía dos veces: `>/dev/null 2>&1` escondía el mensaje y `|| true` el código de salida.
161    # Se pregunta ANTES, y el motivo se dice con el nombre del server que lo tiene tomado.
162    dueno=$(hcloud volume list -o noheader -o columns=name,server 2>/dev/null | awk -v v="$VOL_NAME" '$1==v{print $2}')
163    if [ -n "$dueno" ] && [ "$dueno" != "-" ] && [ "$dueno" != "$name" ]; then
164      sin_volumen "$name" "el volumen $VOL_NAME ya está adjunto a $dueno (un volumen = un server)"
165    fi
166    if ! err=$(hcloud volume attach --server "$name" "$VOL_NAME" 2>&1); then
167      sin_volumen "$name" "no pude adjuntar $VOL_NAME: ${err:-error desconocido}"
168    fi
169    dev="/dev/disk/by-id/scsi-0HC_Volume_$vid"
170    $SSH root@"$ip" "mkdir -p /mnt/cosecha
171      # ⚠ El mkfs.ext4 -F de rescate SÓLO si el dispositivo no tiene filesystem. La versión previa
172      # formateaba ante CUALQUIER fallo de montaje —incluida la carrera normal entre volume attach
173      # y la aparición del dispositivo— o sea que un hipo de segundos destruía el volumen entero.
174      # blkid distingue «vacío» de «no pude montarlo ahora».
175      if ! mount $dev /mnt/cosecha 2>/dev/null; then
176        if blkid $dev >/dev/null 2>&1; then
177          echo "   ✗ el volumen TIENE filesystem y no montó — NO lo formateo. Revisá a mano." >&2; exit 1
178        fi
179        mkfs.ext4 -q -F $dev && mount $dev /mnt/cosecha
180      fi
181      mkdir -p /mnt/cosecha/store /mnt/cosecha/verdicts /mnt/cosecha/logs
182      # el store del worker ES el del volumen: sellar YA es persistir.
183      # PERO antes hay que RESCATAR el store HORNEADO en la golden (2026-07-21): esto hacía
184      # \`rm -rf $REMOTE/store\` y tiraba el catálogo cacheado que es la razón de ser de la imagen
185      # golden ('arranca con TODO el catálogo ⇒ cache-hit instantáneo'). Sin él, el worker mide
186      # deuda contra un store casi vacío y se pone a reconstruir media distro: en la tanda del
187      # 2026-07-21 dio 716 recetas de deuda donde el hub medía 37. Es CAS (nombre = hash) ⇒
188      # fusionar es seguro por construcción: \`mv -n\` no pisa lo que el volumen ya tiene.
189      # ⚠ mountpoint -q NO ES OPCIONAL — sin él este bloque BORRA EL VOLUMEN.
190      # La guarda original sólo comprobaba «es directorio y no es symlink». Eso basta en un server
191      # recién creado desde la golden ORIGINAL, donde /opt/hammer/store es un directorio normal.
192      # Pero al re-snapshotear un worker (2026-08-08) la imagen se llevó también la CONFIGURACIÓN DE
193      # MONTAJE: el server nuevo monta el volumen en /opt/hammer/store al arrancar, ANTES de que
194      # corra este rescate. Entonces rm -rf $REMOTE/store borra A TRAVÉS DEL MONTAJE y se lleva el
195      # store del volumen entero — que es justo lo que el volumen existe para proteger.
196      # Medido: el volumen pasó de ~900 artefactos a 2. No se perdió el filesystem (lost+found es de
197      # julio, 17 montajes): se borró el CONTENIDO.
198      # ⇒ Si ya es punto de montaje, no hay nada que rescatar ni que borrar: el store ya está donde
199      #   tiene que estar.
200      if [ -d $REMOTE/store ] && [ ! -L $REMOTE/store ] && ! mountpoint -q $REMOTE/store; then
201        n=\$(ls $REMOTE/store 2>/dev/null | wc -l)
202        [ \"\$n\" -gt 0 ] && mv -n $REMOTE/store/* /mnt/cosecha/store/ 2>/dev/null
203        echo \"   ✓ rescatados \$n artefactos horneados de la golden al volumen\"
204        rm -rf $REMOTE/store
205      fi
206      # BIND-MOUNT, NO SYMLINK (2026-07-22). Anclar el store con \`ln -s\` rompía TODA receta con
207      # \`zig_version\` en el worker, y el síntoma se leía como deuda de la cascada GUI. Por qué:
208      # takana deriva el lab del PADRE DEL STORE (BuildConfig::defaults_for_store ⇒
209      # project_root = store_root.parent(), de ahí .dev-fs/{alpine,tools/zig,cache}). Con el symlink
210      # el store resuelve a /mnt/cosecha/store ⇒ busca /mnt/cosecha/.dev-fs, que no existe, y muere
211      # con 'no encuentro el ejecutable zig en …' apuntando al lugar equivocado. Un bind-mount deja
212      # los datos en el volumen igual, pero \$REMOTE/store sigue siendo una ruta REAL bajo
213      # \$REMOTE ⇒ el padre vuelve a ser /opt/hammer y .dev-fs se encuentra. Mantiene las dos
214      # invariantes a la vez: sellar = persistir, y el lab donde takana lo espera.
215      if [ -L $REMOTE/store ]; then rm -f $REMOTE/store; fi
216      mkdir -p $REMOTE/store
217      mountpoint -q $REMOTE/store || mount --bind /mnt/cosecha/store $REMOTE/store
218      grep -q /mnt/cosecha /etc/fstab || echo '$dev /mnt/cosecha ext4 defaults,nofail 0 0' >> /etc/fstab
219      grep -q \"$REMOTE/store\" /etc/fstab || echo '/mnt/cosecha/store $REMOTE/store none bind,nofail 0 0' >> /etc/fstab" >/dev/null 2>&1
220    if $SSH root@"$ip" 'mountpoint -q /mnt/cosecha && mountpoint -q '"$REMOTE"'/store' 2>/dev/null; then
221      echo "   ✓ store anclado al volumen ($(  $SSH root@"$ip" 'ls -d /mnt/cosecha/store/*/ 2>/dev/null | wc -l') artefactos ya presentes)"
222    else
223      sin_volumen "$name" "el store NO quedó anclado al volumen (mountpoint dice que no)"
224    fi
225  else
226    sin_volumen "$name" "no existe el volumen $VOL_NAME y no pude crearlo"
227  fi
228
229  # DEAD-MAN SWITCH: el worker se borra SOLO tras 1h sin trabajo. Va acá, en el nacimiento, porque
230  # el modelo "efímero" NO puede depender de que alguien llame a farm-down: hworker-4 estuvo 5 días
231  # idle (2026-07-17) justo por eso — el agente que lo creó se fue y el server quedó. Un invariante
232  # que necesita que alguien se acuerde no es un invariante.
233  echo "   armando dead-man switch (1h idle ⇒ auto-delete)…"
234  tok="${HCLOUD_TOKEN:-$(grep -shoE '^ *token *= *"?[A-Za-z0-9]+' "$HOME/.config/hcloud/cli.toml" 2>/dev/null | head -1 | sed 's/.*[= "]//')}"
235  if [ -z "$tok" ]; then
236    echo "   ⚠ SIN TOKEN para el dead-man switch: este worker NO se auto-borrará."
237    echo "     (un poweroff no sirve: Hetzner cobra igual con el server apagado)"
238  else
239    scp -q -i "$SSH_KEY" -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null \
240      scripts/farm/deadman.sh "root@$ip:/usr/local/bin/deadman.sh" 2>/dev/null
241    scp -q -i "$SSH_KEY" -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null \
242      scripts/farm/hammer-deadman.service scripts/farm/hammer-deadman.timer \
243      "root@$ip:/etc/systemd/system/" 2>/dev/null
244    $SSH root@"$ip" "chmod +x /usr/local/bin/deadman.sh
245      printf 'HCLOUD_TOKEN=%s\n' '$tok' > /etc/hammer-deadman.env; chmod 600 /etc/hammer-deadman.env
246      systemctl daemon-reload && systemctl enable --now hammer-deadman.timer" >/dev/null 2>&1
247    # EVIDENCIA, no fe: que el timer esté ARMADO se comprueba, no se asume (el cron de aquella vez
248    # estaba "validado" y nunca disparó porque el PID 1 no tenía crond).
249    # FIRING ≠ CAN-DELETE (2026-07-23): un worker quedó idle 3.5h quemando € porque su token no
250    # estaba donde la service lo lee ⇒ el dead-man DISPARABA pero salía 1 "sin HCLOUD_TOKEN" y nunca
251    # se borraba. Que el timer esté activo NO prueba que pueda matarse. El worker DEBE poder matarse
252    # SOLO, sin el hub — así que si NO PUEDE, no lo dejamos vivo: lo DESTRUIMOS acá mismo. Un worker
253    # que no se puede autodestruir es exactamente lo que el usuario prohíbe. `deadman.sh --puede-borrar`
254    # busca el token en cadena (env, volumen, /root) y prueba que ve su id en la API.
255    timer_ok=$($SSH root@"$ip" 'systemctl is-active hammer-deadman.timer' 2>/dev/null | grep -q active && echo 1)
256    puede=$($SSH root@"$ip" '/usr/local/bin/deadman.sh --puede-borrar' 2>/dev/null)
257    if [ -n "$timer_ok" ] && printf '%s' "$puede" | grep -q '^SÍ'; then
258      echo "   ✓ dead-man ARMADO y PUEDE borrarse solo ($puede) — no depende del hub"
259    else
260      echo "   ⛔ $name NO puede autodestruirse (timer=${timer_ok:-no} · $puede)."
261      echo "      Un worker que no se mata solo es INADMISIBLE ⇒ lo DESTRUYO ahora para no dejarlo idle."
262      # LISTA NEGRA (capa 1 de 2): gioser JAMÁS se toca. farm-up sólo crea hworker-N, pero defensa
263      # en profundidad — "ahí está nuestra vida". Segunda capa = el label check de abajo.
264      case "$name" in *gioser*) echo "      ⛔ $name en LISTA NEGRA ⇒ NO lo toco. Revisá a mano."; continue;; esac
265      if hcloud server describe "$name" -o format='{{.Labels}}' 2>/dev/null | grep -q hammer-worker; then
266        hcloud server delete "$name" >/dev/null 2>&1 && echo "      ☠ $name destruido (label verificado)."
267      else
268        echo "      ⛔ $name sin label hammer-worker ⇒ NO lo toco (protegido); borralo a mano."
269      fi
270      grep -v "^$name " "$FLEET" > "$FLEET.tmp" 2>/dev/null && mv "$FLEET.tmp" "$FLEET"
271      continue
272    fi
273  fi
274  echo "   ✓ $name muele la cola actual"
275done
276
277sort -u -o "$FLEET" "$FLEET"
278echo "==> flota viva:"; cat "$FLEET"
279echo "cosechar+destruir con: scripts/farm/farm-down.sh"